yaml

README

YAML reader for CUE

This yaml parser is a heavily modified version of Canonical's go-yaml parser, which in turn is a port of the libyaml parser.

License

The yaml package is licensed under the Apache License 2.0. Please see the LICENSE file for details.

Documentation

Overview

Package yaml implements YAML support for the Go language.

Source code and other details for the project are available at GitHub:

https://github.com/go-yaml/yaml

Index

• func Unmarshal(filename string, in []byte) (expr ast.Expr, err error)
• type Decoder
  • func NewDecoder(filename string, src interface{}) (*Decoder, error)
  • func (dec *Decoder) Decode() (expr ast.Expr, err error)
• type IsZeroer
• type MapItem
• type MapSlice
• type Marshaler
• type TypeError
  • func (e *TypeError) Error() string
• type Unmarshaler

Functions

func Unmarshal

func Unmarshal(filename string, in []byte) (expr ast.Expr, err error)

Unmarshal decodes the first document found within the in byte slice and assigns decoded values into the out value.

Maps and pointers (to a struct, string, int, etc) are accepted as out values. If an internal pointer within a struct is not initialized, the yaml package will initialize it if necessary for unmarshalling the provided data. The out parameter must not be nil.

The type of the decoded values should be compatible with the respective values in out. If one or more values cannot be decoded due to a type mismatches, decoding continues partially until the end of the YAML content, and a *yaml.TypeError is returned with details for all missed values.

Struct fields are only unmarshalled if they are exported (have an upper case first letter), and are unmarshalled using the field name lowercased as the default key. Custom keys may be defined via the "yaml" name in the field tag: the content preceding the first comma is used as the key, and the following comma-separated options are used to tweak the marshalling process (see Marshal). Conflicting names result in a runtime error.

For example:

type T struct {
    F int `yaml:"a,omitempty"`
    B int
}
var t T
yaml.Unmarshal([]byte("a: 1\nb: 2"), &t)

See the documentation of Marshal for the format of tags and a list of supported tag options.

Types

type Decoder

type Decoder struct {
	// contains filtered or unexported fields
}

A Decorder reads and decodes YAML values from an input stream.

func NewDecoder

func NewDecoder(filename string, src interface{}) (*Decoder, error)

NewDecoder returns a new decoder that reads from r.

The decoder introduces its own buffering and may read data from r beyond the YAML values requested.

func (*Decoder) Decode

func (dec *Decoder) Decode() (expr ast.Expr, err error)

Decode reads the next YAML-encoded value from its input and stores it in the value pointed to by v. It returns io.EOF if there are no more value in the stream.

See the documentation for Unmarshal for details about the conversion of YAML into a Go value.

type IsZeroer

type IsZeroer interface {
	IsZero() bool
}

IsZeroer is used to check whether an object is zero to determine whether it should be omitted when marshaling with the omitempty flag. One notable implementation is time.Time.

type MapItem

type MapItem struct {
	Key, Value interface{}
}

MapItem is an item in a MapSlice.

type MapSlice

type MapSlice []MapItem

MapSlice encodes and decodes as a YAML map. The order of keys is preserved when encoding and decoding.

type Marshaler

type Marshaler interface {
	MarshalYAML() (interface{}, error)
}

The Marshaler interface may be implemented by types to customize their behavior when being marshaled into a YAML document. The returned value is marshaled in place of the original value implementing Marshaler.

If an error is returned by MarshalYAML, the marshaling procedure stops and returns with the provided error.

type TypeError

type TypeError struct {
	Errors []string
}

A TypeError is returned by Unmarshal when one or more fields in the YAML document cannot be properly decoded into the requested types. When this error is returned, the value is still unmarshaled partially.

func (*TypeError) Error

func (e *TypeError) Error() string

type Unmarshaler

type Unmarshaler interface {
	UnmarshalYAML(unmarshal func(interface{}) error) error
}

The Unmarshaler interface may be implemented by types to customize their behavior when being unmarshaled from a YAML document. The UnmarshalYAML method receives a function that may be called to unmarshal the original YAML value into a field or variable. It is safe to call the unmarshal function parameter more than once if necessary.