gyaml

func Marshal ¶

func Marshal(v any) ([]byte, error)

Marshal returns the YAML encoding of v.

Marshal traverses the value v recursively. If an encountered value implements Marshaler and is not a nil pointer, Marshal calls [Marshaler.MarshalYAML] to produce YAML. If no [Marshaler.MarshalYAML] method is present but the value implements encoding.TextMarshaler instead, Marshal calls encoding.TextMarshaler.MarshalText and encodes the result as a YAML string. The nil pointer exception is not strictly necessary but mimics a similar, necessary exception in the behavior of [Unmarshaler.UnmarshalYAML].

Otherwise, Marshal uses the following type-dependent default encodings:

Boolean values encode as YAML booleans.

Floating point, integer, and [Number] values encode as YAML numbers.

String values encode as YAML unquoted strings, unless it passes the IsNeedQuoted function check for ambiguities: if it consists of a pure number, time.Time, boolean value, etc.

Array and slice values encode as YAML sequences, by default using a block style. For flow style you need to set a "flow" tag or use a global flow style for encoder.

Struct values encode as YAML objects. Again optional flow style is supported. Each exported struct field becomes a member of the object, using the lowercased field name as the object key, unless the field is omitted for one of the reasons given below.

The encoding of each struct field can be customized by the format string stored under the "yaml" key in the struct field's tag. The format string gives the name of the field, possibly followed by a comma-separated list of options. The name may be empty in order to specify options without overriding the default field name.

The "omitempty" option specifies that the field should be omitted from the encoding if the field has an empty value, defined as false, 0, a nil pointer, a nil interface value, and any array, slice, map, or string of length zero.

As a special case, if the field tag is "-", the field is always omitted. Note that a field with name "-" can still be generated using the tag "-,".

Examples of struct field tags and their meanings:

// Field appears in YAML as key "myName".
Field int `yaml:"myName"`

// Field appears in YAML as key "myName" and
// the field is omitted from the object if its value is empty,
// as defined above.
Field int `yaml:"myName,omitempty"`

// Field appears in YAML as key "Field" (the default), but
// the field is skipped if empty.
// Note the leading comma.
Field int `yaml:",omitempty"`

// Field is ignored by this package.
Field int `yaml:"-"`

// Field appears in YAML as key "-".
Field int `yaml:"-,"`

The "omitzero" option specifies that the field should be omitted from the encoding if the field has a zero value, according to rules:

1) If the field type has an "IsZero() bool" method, that will be used to determine whether the value is zero.

2) Otherwise, the value is zero if it is the zero value for its type.

If both "omitempty" and "omitzero" are specified, the field will be omitted if the value is either empty or zero (or both).

Embedded struct fields are usually marshaled as if their inner exported fields were fields in the outer struct, subject to the usual Go visibility rules amended as described in the next paragraph. An anonymous struct field with a name given in its YAML tag is treated as having that name, rather than being anonymous. An anonymous struct field of interface type is treated the same as having that type as its name, rather than being anonymous.

The Go visibility rules for struct fields are amended for YAML when deciding which field to marshal or unmarshal. If there are multiple fields at the same level, and that level is the least nested (and would therefore be the nesting level selected by the usual Go rules), the following extra rules apply:

1) Of those fields, if any are YAML-tagged, only tagged fields are considered, even if there are multiple untagged fields that would otherwise conflict.

2) If there is exactly one field (tagged or not according to the first rule), that is selected.

3) Otherwise there are multiple fields, and all are ignored; no error occurs.

Handling of anonymous struct fields is new in Go 1.1. Prior to Go 1.1, anonymous struct fields were ignored. To force ignoring of an anonymous struct field in both current and earlier versions, give the field a YAML tag of "-".

Map values encode as YAML objects. The map's key type must either be a string, an integer type, uintptr, float, bool, or implement encoding.TextMarshaler. The map keys are sorted and used as YAML object keys by applying the following rules, subject to the UTF-8 coercion described for string values above:

• keys of any string type are used directly
• keys that implement encoding.TextMarshaler are marshaled
• number and bool keys are converted to strings

Pointer values encode as the value pointed to unless anchor is found. A nil pointer encodes as the null YAML value.

Interface values encode as the value contained in the interface. A nil interface value encodes as the null YAML value.

Channel, complex, and function values cannot be encoded in YAML. Attempting to encode such a value causes Marshal to return an UnsupportedTypeError.

YAML cannot represent cyclic data structures and Marshal does not handle them. Passing cyclic structures to Marshal will result in an error.

func MarshalWithOptions ¶

func MarshalWithOptions(v any, opts EncoderOptions) ([]byte, error)

MarshalWithOptions calls Marshal with specified global options, see EncoderOptions

func Unmarshal ¶

func Unmarshal(data []byte, v any) error

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

Struct fields are only unmarshalled if they are exported, and are unmarshalled using the field name lowercased as the default key. Custom name may be defined via the "yaml" field tag: the content preceding the first comma is used as the key, and the following comma-separated options are used to tweak the marshaling 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.

func Valid ¶

func Valid(data []byte) bool

Valid reports whether data is a valid YAML encoding.