decode.go raw
1 package yaml
2
3 import (
4 "bytes"
5 "context"
6 "encoding"
7 "encoding/base64"
8 "fmt"
9 "io"
10 "io/ioutil"
11 "math"
12 "os"
13 "path/filepath"
14 "reflect"
15 "strconv"
16 "time"
17
18 "github.com/goccy/go-yaml/ast"
19 "github.com/goccy/go-yaml/internal/errors"
20 "github.com/goccy/go-yaml/parser"
21 "github.com/goccy/go-yaml/token"
22 "golang.org/x/xerrors"
23 )
24
25 // Decoder reads and decodes YAML values from an input stream.
26 type Decoder struct {
27 reader io.Reader
28 referenceReaders []io.Reader
29 anchorNodeMap map[string]ast.Node
30 anchorValueMap map[string]reflect.Value
31 toCommentMap CommentMap
32 opts []DecodeOption
33 referenceFiles []string
34 referenceDirs []string
35 isRecursiveDir bool
36 isResolvedReference bool
37 validator StructValidator
38 disallowUnknownField bool
39 disallowDuplicateKey bool
40 useOrderedMap bool
41 useJSONUnmarshaler bool
42 parsedFile *ast.File
43 streamIndex int
44 }
45
46 // NewDecoder returns a new decoder that reads from r.
47 func NewDecoder(r io.Reader, opts ...DecodeOption) *Decoder {
48 return &Decoder{
49 reader: r,
50 anchorNodeMap: map[string]ast.Node{},
51 anchorValueMap: map[string]reflect.Value{},
52 opts: opts,
53 referenceReaders: []io.Reader{},
54 referenceFiles: []string{},
55 referenceDirs: []string{},
56 isRecursiveDir: false,
57 isResolvedReference: false,
58 disallowUnknownField: false,
59 disallowDuplicateKey: false,
60 useOrderedMap: false,
61 }
62 }
63
64 func (d *Decoder) castToFloat(v interface{}) interface{} {
65 switch vv := v.(type) {
66 case int:
67 return float64(vv)
68 case int8:
69 return float64(vv)
70 case int16:
71 return float64(vv)
72 case int32:
73 return float64(vv)
74 case int64:
75 return float64(vv)
76 case uint:
77 return float64(vv)
78 case uint8:
79 return float64(vv)
80 case uint16:
81 return float64(vv)
82 case uint32:
83 return float64(vv)
84 case uint64:
85 return float64(vv)
86 case float32:
87 return float64(vv)
88 case float64:
89 return vv
90 case string:
91 // if error occurred, return zero value
92 f, _ := strconv.ParseFloat(vv, 64)
93 return f
94 }
95 return 0
96 }
97
98 func (d *Decoder) mergeValueNode(value ast.Node) ast.Node {
99 if value.Type() == ast.AliasType {
100 aliasNode := value.(*ast.AliasNode)
101 aliasName := aliasNode.Value.GetToken().Value
102 return d.anchorNodeMap[aliasName]
103 }
104 return value
105 }
106
107 func (d *Decoder) mapKeyNodeToString(node ast.MapKeyNode) string {
108 key := d.nodeToValue(node)
109 if key == nil {
110 return "null"
111 }
112 if k, ok := key.(string); ok {
113 return k
114 }
115 return fmt.Sprint(key)
116 }
117
118 func (d *Decoder) setToMapValue(node ast.Node, m map[string]interface{}) {
119 d.setPathToCommentMap(node)
120 switch n := node.(type) {
121 case *ast.MappingValueNode:
122 if n.Key.Type() == ast.MergeKeyType {
123 d.setToMapValue(d.mergeValueNode(n.Value), m)
124 } else {
125 key := d.mapKeyNodeToString(n.Key)
126 m[key] = d.nodeToValue(n.Value)
127 }
128 case *ast.MappingNode:
129 for _, value := range n.Values {
130 d.setToMapValue(value, m)
131 }
132 case *ast.AnchorNode:
133 anchorName := n.Name.GetToken().Value
134 d.anchorNodeMap[anchorName] = n.Value
135 }
136 }
137
138 func (d *Decoder) setToOrderedMapValue(node ast.Node, m *MapSlice) {
139 switch n := node.(type) {
140 case *ast.MappingValueNode:
141 if n.Key.Type() == ast.MergeKeyType {
142 d.setToOrderedMapValue(d.mergeValueNode(n.Value), m)
143 } else {
144 key := d.mapKeyNodeToString(n.Key)
145 *m = append(*m, MapItem{Key: key, Value: d.nodeToValue(n.Value)})
146 }
147 case *ast.MappingNode:
148 for _, value := range n.Values {
149 d.setToOrderedMapValue(value, m)
150 }
151 }
152 }
153
154 func (d *Decoder) setPathToCommentMap(node ast.Node) {
155 if d.toCommentMap == nil {
156 return
157 }
158 commentGroup := node.GetComment()
159 if commentGroup == nil {
160 return
161 }
162 texts := []string{}
163 for _, comment := range commentGroup.Comments {
164 texts = append(texts, comment.Token.Value)
165 }
166 if len(texts) == 0 {
167 return
168 }
169 if len(texts) == 1 {
170 d.toCommentMap[node.GetPath()] = LineComment(texts[0])
171 } else {
172 d.toCommentMap[node.GetPath()] = HeadComment(texts...)
173 }
174 }
175
176 func (d *Decoder) nodeToValue(node ast.Node) interface{} {
177 d.setPathToCommentMap(node)
178 switch n := node.(type) {
179 case *ast.NullNode:
180 return nil
181 case *ast.StringNode:
182 return n.GetValue()
183 case *ast.IntegerNode:
184 return n.GetValue()
185 case *ast.FloatNode:
186 return n.GetValue()
187 case *ast.BoolNode:
188 return n.GetValue()
189 case *ast.InfinityNode:
190 return n.GetValue()
191 case *ast.NanNode:
192 return n.GetValue()
193 case *ast.TagNode:
194 switch token.ReservedTagKeyword(n.Start.Value) {
195 case token.TimestampTag:
196 t, _ := d.castToTime(n.Value)
197 return t
198 case token.IntegerTag:
199 i, _ := strconv.Atoi(fmt.Sprint(d.nodeToValue(n.Value)))
200 return i
201 case token.FloatTag:
202 return d.castToFloat(d.nodeToValue(n.Value))
203 case token.NullTag:
204 return nil
205 case token.BinaryTag:
206 b, _ := base64.StdEncoding.DecodeString(d.nodeToValue(n.Value).(string))
207 return b
208 case token.StringTag:
209 return d.nodeToValue(n.Value)
210 case token.MappingTag:
211 return d.nodeToValue(n.Value)
212 }
213 case *ast.AnchorNode:
214 anchorName := n.Name.GetToken().Value
215 anchorValue := d.nodeToValue(n.Value)
216 d.anchorNodeMap[anchorName] = n.Value
217 return anchorValue
218 case *ast.AliasNode:
219 aliasName := n.Value.GetToken().Value
220 node := d.anchorNodeMap[aliasName]
221 return d.nodeToValue(node)
222 case *ast.LiteralNode:
223 return n.Value.GetValue()
224 case *ast.MappingKeyNode:
225 return d.nodeToValue(n.Value)
226 case *ast.MappingValueNode:
227 if n.Key.Type() == ast.MergeKeyType {
228 value := d.mergeValueNode(n.Value)
229 if d.useOrderedMap {
230 m := MapSlice{}
231 d.setToOrderedMapValue(value, &m)
232 return m
233 }
234 m := map[string]interface{}{}
235 d.setToMapValue(value, m)
236 return m
237 }
238 key := d.mapKeyNodeToString(n.Key)
239 if d.useOrderedMap {
240 return MapSlice{{Key: key, Value: d.nodeToValue(n.Value)}}
241 }
242 return map[string]interface{}{
243 key: d.nodeToValue(n.Value),
244 }
245 case *ast.MappingNode:
246 if d.useOrderedMap {
247 m := make(MapSlice, 0, len(n.Values))
248 for _, value := range n.Values {
249 d.setToOrderedMapValue(value, &m)
250 }
251 return m
252 }
253 m := make(map[string]interface{}, len(n.Values))
254 for _, value := range n.Values {
255 d.setToMapValue(value, m)
256 }
257 return m
258 case *ast.SequenceNode:
259 v := make([]interface{}, 0, len(n.Values))
260 for _, value := range n.Values {
261 v = append(v, d.nodeToValue(value))
262 }
263 return v
264 }
265 return nil
266 }
267
268 func (d *Decoder) resolveAlias(node ast.Node) (ast.Node, error) {
269 switch n := node.(type) {
270 case *ast.MappingNode:
271 for idx, v := range n.Values {
272 value, err := d.resolveAlias(v)
273 if err != nil {
274 return nil, err
275 }
276 n.Values[idx] = value.(*ast.MappingValueNode)
277 }
278 case *ast.TagNode:
279 value, err := d.resolveAlias(n.Value)
280 if err != nil {
281 return nil, err
282 }
283 n.Value = value
284 case *ast.MappingKeyNode:
285 value, err := d.resolveAlias(n.Value)
286 if err != nil {
287 return nil, err
288 }
289 n.Value = value
290 case *ast.MappingValueNode:
291 if n.Key.Type() == ast.MergeKeyType && n.Value.Type() == ast.AliasType {
292 value, err := d.resolveAlias(n.Value)
293 if err != nil {
294 return nil, err
295 }
296 keyColumn := n.Key.GetToken().Position.Column
297 requiredColumn := keyColumn + 2
298 value.AddColumn(requiredColumn)
299 n.Value = value
300 } else {
301 key, err := d.resolveAlias(n.Key)
302 if err != nil {
303 return nil, err
304 }
305 n.Key = key.(ast.MapKeyNode)
306 value, err := d.resolveAlias(n.Value)
307 if err != nil {
308 return nil, err
309 }
310 n.Value = value
311 }
312 case *ast.SequenceNode:
313 for idx, v := range n.Values {
314 value, err := d.resolveAlias(v)
315 if err != nil {
316 return nil, err
317 }
318 n.Values[idx] = value
319 }
320 case *ast.AliasNode:
321 aliasName := n.Value.GetToken().Value
322 node := d.anchorNodeMap[aliasName]
323 if node == nil {
324 return nil, xerrors.Errorf("cannot find anchor by alias name %s", aliasName)
325 }
326 return d.resolveAlias(node)
327 }
328 return node, nil
329 }
330
331 func (d *Decoder) getMapNode(node ast.Node) (ast.MapNode, error) {
332 if _, ok := node.(*ast.NullNode); ok {
333 return nil, nil
334 }
335 if anchor, ok := node.(*ast.AnchorNode); ok {
336 mapNode, ok := anchor.Value.(ast.MapNode)
337 if ok {
338 return mapNode, nil
339 }
340 return nil, errUnexpectedNodeType(anchor.Value.Type(), ast.MappingType, node.GetToken())
341 }
342 if alias, ok := node.(*ast.AliasNode); ok {
343 aliasName := alias.Value.GetToken().Value
344 node := d.anchorNodeMap[aliasName]
345 if node == nil {
346 return nil, xerrors.Errorf("cannot find anchor by alias name %s", aliasName)
347 }
348 mapNode, ok := node.(ast.MapNode)
349 if ok {
350 return mapNode, nil
351 }
352 return nil, errUnexpectedNodeType(node.Type(), ast.MappingType, node.GetToken())
353 }
354 mapNode, ok := node.(ast.MapNode)
355 if !ok {
356 return nil, errUnexpectedNodeType(node.Type(), ast.MappingType, node.GetToken())
357 }
358 return mapNode, nil
359 }
360
361 func (d *Decoder) getArrayNode(node ast.Node) (ast.ArrayNode, error) {
362 if _, ok := node.(*ast.NullNode); ok {
363 return nil, nil
364 }
365 if anchor, ok := node.(*ast.AnchorNode); ok {
366 arrayNode, ok := anchor.Value.(ast.ArrayNode)
367 if ok {
368 return arrayNode, nil
369 }
370
371 return nil, errUnexpectedNodeType(anchor.Value.Type(), ast.SequenceType, node.GetToken())
372 }
373 if alias, ok := node.(*ast.AliasNode); ok {
374 aliasName := alias.Value.GetToken().Value
375 node := d.anchorNodeMap[aliasName]
376 if node == nil {
377 return nil, xerrors.Errorf("cannot find anchor by alias name %s", aliasName)
378 }
379 arrayNode, ok := node.(ast.ArrayNode)
380 if ok {
381 return arrayNode, nil
382 }
383 return nil, errUnexpectedNodeType(node.Type(), ast.SequenceType, node.GetToken())
384 }
385 arrayNode, ok := node.(ast.ArrayNode)
386 if !ok {
387 return nil, errUnexpectedNodeType(node.Type(), ast.SequenceType, node.GetToken())
388 }
389 return arrayNode, nil
390 }
391
392 func (d *Decoder) fileToNode(f *ast.File) ast.Node {
393 for _, doc := range f.Docs {
394 if v := d.nodeToValue(doc.Body); v != nil {
395 return doc.Body
396 }
397 }
398 return nil
399 }
400
401 func (d *Decoder) convertValue(v reflect.Value, typ reflect.Type, src ast.Node) (reflect.Value, error) {
402 if typ.Kind() != reflect.String {
403 if !v.Type().ConvertibleTo(typ) {
404 return reflect.Zero(typ), errTypeMismatch(typ, v.Type(), src.GetToken())
405 }
406 return v.Convert(typ), nil
407 }
408 // cast value to string
409 switch v.Type().Kind() {
410 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
411 return reflect.ValueOf(fmt.Sprint(v.Int())), nil
412 case reflect.Float32, reflect.Float64:
413 return reflect.ValueOf(fmt.Sprint(v.Float())), nil
414 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
415 return reflect.ValueOf(fmt.Sprint(v.Uint())), nil
416 case reflect.Bool:
417 return reflect.ValueOf(fmt.Sprint(v.Bool())), nil
418 }
419 if !v.Type().ConvertibleTo(typ) {
420 return reflect.Zero(typ), errTypeMismatch(typ, v.Type(), src.GetToken())
421 }
422 return v.Convert(typ), nil
423 }
424
425 type overflowError struct {
426 dstType reflect.Type
427 srcNum string
428 }
429
430 func (e *overflowError) Error() string {
431 return fmt.Sprintf("cannot unmarshal %s into Go value of type %s ( overflow )", e.srcNum, e.dstType)
432 }
433
434 func errOverflow(dstType reflect.Type, num string) *overflowError {
435 return &overflowError{dstType: dstType, srcNum: num}
436 }
437
438 func errTypeMismatch(dstType, srcType reflect.Type, token *token.Token) *errors.TypeError {
439 return &errors.TypeError{DstType: dstType, SrcType: srcType, Token: token}
440 }
441
442 type unknownFieldError struct {
443 err error
444 }
445
446 func (e *unknownFieldError) Error() string {
447 return e.err.Error()
448 }
449
450 func errUnknownField(msg string, tk *token.Token) *unknownFieldError {
451 return &unknownFieldError{err: errors.ErrSyntax(msg, tk)}
452 }
453
454 func errUnexpectedNodeType(actual, expected ast.NodeType, tk *token.Token) error {
455 return errors.ErrSyntax(fmt.Sprintf("%s was used where %s is expected", actual.YAMLName(), expected.YAMLName()), tk)
456 }
457
458 type duplicateKeyError struct {
459 err error
460 }
461
462 func (e *duplicateKeyError) Error() string {
463 return e.err.Error()
464 }
465
466 func errDuplicateKey(msg string, tk *token.Token) *duplicateKeyError {
467 return &duplicateKeyError{err: errors.ErrSyntax(msg, tk)}
468 }
469
470 func (d *Decoder) deleteStructKeys(structType reflect.Type, unknownFields map[string]ast.Node) error {
471 if structType.Kind() == reflect.Ptr {
472 structType = structType.Elem()
473 }
474 structFieldMap, err := structFieldMap(structType)
475 if err != nil {
476 return errors.Wrapf(err, "failed to create struct field map")
477 }
478
479 for j := 0; j < structType.NumField(); j++ {
480 field := structType.Field(j)
481 if isIgnoredStructField(field) {
482 continue
483 }
484
485 structField, exists := structFieldMap[field.Name]
486 if !exists {
487 continue
488 }
489
490 if structField.IsInline {
491 d.deleteStructKeys(field.Type, unknownFields)
492 } else {
493 delete(unknownFields, structField.RenderName)
494 }
495 }
496 return nil
497 }
498
499 func (d *Decoder) lastNode(node ast.Node) ast.Node {
500 switch n := node.(type) {
501 case *ast.MappingNode:
502 if len(n.Values) > 0 {
503 return d.lastNode(n.Values[len(n.Values)-1])
504 }
505 case *ast.MappingValueNode:
506 return d.lastNode(n.Value)
507 case *ast.SequenceNode:
508 if len(n.Values) > 0 {
509 return d.lastNode(n.Values[len(n.Values)-1])
510 }
511 }
512 return node
513 }
514
515 func (d *Decoder) unmarshalableDocument(node ast.Node) ([]byte, error) {
516 var err error
517 node, err = d.resolveAlias(node)
518 if err != nil {
519 return nil, err
520 }
521 doc := node.String()
522 last := d.lastNode(node)
523 if last != nil && last.Type() == ast.LiteralType {
524 doc += "\n"
525 }
526 return []byte(doc), nil
527 }
528
529 func (d *Decoder) unmarshalableText(node ast.Node) ([]byte, bool, error) {
530 var err error
531 node, err = d.resolveAlias(node)
532 if err != nil {
533 return nil, false, err
534 }
535 if node.Type() == ast.AnchorType {
536 node = node.(*ast.AnchorNode).Value
537 }
538 switch n := node.(type) {
539 case *ast.StringNode:
540 return []byte(n.Value), true, nil
541 case *ast.LiteralNode:
542 return []byte(n.Value.GetToken().Value), true, nil
543 default:
544 scalar, ok := n.(ast.ScalarNode)
545 if ok {
546 return []byte(fmt.Sprint(scalar.GetValue())), true, nil
547 }
548 }
549 return nil, false, nil
550 }
551
552 type jsonUnmarshaler interface {
553 UnmarshalJSON([]byte) error
554 }
555
556 func (d *Decoder) canDecodeByUnmarshaler(dst reflect.Value) bool {
557 iface := dst.Addr().Interface()
558 switch iface.(type) {
559 case BytesUnmarshalerContext:
560 return true
561 case BytesUnmarshaler:
562 return true
563 case InterfaceUnmarshalerContext:
564 return true
565 case InterfaceUnmarshaler:
566 return true
567 case *time.Time:
568 return true
569 case *time.Duration:
570 return true
571 case encoding.TextUnmarshaler:
572 return true
573 case jsonUnmarshaler:
574 return d.useJSONUnmarshaler
575 }
576 return false
577 }
578
579 func (d *Decoder) decodeByUnmarshaler(ctx context.Context, dst reflect.Value, src ast.Node) error {
580 iface := dst.Addr().Interface()
581
582 if unmarshaler, ok := iface.(BytesUnmarshalerContext); ok {
583 b, err := d.unmarshalableDocument(src)
584 if err != nil {
585 return errors.Wrapf(err, "failed to UnmarshalYAML")
586 }
587 if err := unmarshaler.UnmarshalYAML(ctx, b); err != nil {
588 return errors.Wrapf(err, "failed to UnmarshalYAML")
589 }
590 return nil
591 }
592
593 if unmarshaler, ok := iface.(BytesUnmarshaler); ok {
594 b, err := d.unmarshalableDocument(src)
595 if err != nil {
596 return errors.Wrapf(err, "failed to UnmarshalYAML")
597 }
598 if err := unmarshaler.UnmarshalYAML(b); err != nil {
599 return errors.Wrapf(err, "failed to UnmarshalYAML")
600 }
601 return nil
602 }
603
604 if unmarshaler, ok := iface.(InterfaceUnmarshalerContext); ok {
605 if err := unmarshaler.UnmarshalYAML(ctx, func(v interface{}) error {
606 rv := reflect.ValueOf(v)
607 if rv.Type().Kind() != reflect.Ptr {
608 return errors.ErrDecodeRequiredPointerType
609 }
610 if err := d.decodeValue(ctx, rv.Elem(), src); err != nil {
611 return errors.Wrapf(err, "failed to decode value")
612 }
613 return nil
614 }); err != nil {
615 return errors.Wrapf(err, "failed to UnmarshalYAML")
616 }
617 return nil
618 }
619
620 if unmarshaler, ok := iface.(InterfaceUnmarshaler); ok {
621 if err := unmarshaler.UnmarshalYAML(func(v interface{}) error {
622 rv := reflect.ValueOf(v)
623 if rv.Type().Kind() != reflect.Ptr {
624 return errors.ErrDecodeRequiredPointerType
625 }
626 if err := d.decodeValue(ctx, rv.Elem(), src); err != nil {
627 return errors.Wrapf(err, "failed to decode value")
628 }
629 return nil
630 }); err != nil {
631 return errors.Wrapf(err, "failed to UnmarshalYAML")
632 }
633 return nil
634 }
635
636 if _, ok := iface.(*time.Time); ok {
637 return d.decodeTime(ctx, dst, src)
638 }
639
640 if _, ok := iface.(*time.Duration); ok {
641 return d.decodeDuration(ctx, dst, src)
642 }
643
644 if unmarshaler, isText := iface.(encoding.TextUnmarshaler); isText {
645 b, ok, err := d.unmarshalableText(src)
646 if err != nil {
647 return errors.Wrapf(err, "failed to UnmarshalText")
648 }
649 if ok {
650 if err := unmarshaler.UnmarshalText(b); err != nil {
651 return errors.Wrapf(err, "failed to UnmarshalText")
652 }
653 return nil
654 }
655 }
656
657 if d.useJSONUnmarshaler {
658 if unmarshaler, ok := iface.(jsonUnmarshaler); ok {
659 b, err := d.unmarshalableDocument(src)
660 if err != nil {
661 return errors.Wrapf(err, "failed to UnmarshalJSON")
662 }
663 jsonBytes, err := YAMLToJSON(b)
664 if err != nil {
665 return errors.Wrapf(err, "failed to convert yaml to json")
666 }
667 jsonBytes = bytes.TrimRight(jsonBytes, "\n")
668 if err := unmarshaler.UnmarshalJSON(jsonBytes); err != nil {
669 return errors.Wrapf(err, "failed to UnmarshalJSON")
670 }
671 return nil
672 }
673 }
674
675 return xerrors.Errorf("does not implemented Unmarshaler")
676 }
677
678 var (
679 astNodeType = reflect.TypeOf((*ast.Node)(nil)).Elem()
680 )
681
682 func (d *Decoder) decodeValue(ctx context.Context, dst reflect.Value, src ast.Node) error {
683 if src.Type() == ast.AnchorType {
684 anchorName := src.(*ast.AnchorNode).Name.GetToken().Value
685 if _, exists := d.anchorValueMap[anchorName]; !exists {
686 d.anchorValueMap[anchorName] = dst
687 }
688 }
689 if d.canDecodeByUnmarshaler(dst) {
690 if err := d.decodeByUnmarshaler(ctx, dst, src); err != nil {
691 return errors.Wrapf(err, "failed to decode by unmarshaler")
692 }
693 return nil
694 }
695 valueType := dst.Type()
696 switch valueType.Kind() {
697 case reflect.Ptr:
698 if dst.IsNil() {
699 return nil
700 }
701 if src.Type() == ast.NullType {
702 // set nil value to pointer
703 dst.Set(reflect.Zero(valueType))
704 return nil
705 }
706 v := d.createDecodableValue(dst.Type())
707 if err := d.decodeValue(ctx, v, src); err != nil {
708 return errors.Wrapf(err, "failed to decode ptr value")
709 }
710 dst.Set(d.castToAssignableValue(v, dst.Type()))
711 case reflect.Interface:
712 if dst.Type() == astNodeType {
713 dst.Set(reflect.ValueOf(src))
714 return nil
715 }
716 v := reflect.ValueOf(d.nodeToValue(src))
717 if v.IsValid() {
718 dst.Set(v)
719 }
720 case reflect.Map:
721 return d.decodeMap(ctx, dst, src)
722 case reflect.Array:
723 return d.decodeArray(ctx, dst, src)
724 case reflect.Slice:
725 if mapSlice, ok := dst.Addr().Interface().(*MapSlice); ok {
726 return d.decodeMapSlice(ctx, mapSlice, src)
727 }
728 return d.decodeSlice(ctx, dst, src)
729 case reflect.Struct:
730 if mapItem, ok := dst.Addr().Interface().(*MapItem); ok {
731 return d.decodeMapItem(ctx, mapItem, src)
732 }
733 return d.decodeStruct(ctx, dst, src)
734 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
735 v := d.nodeToValue(src)
736 switch vv := v.(type) {
737 case int64:
738 if !dst.OverflowInt(vv) {
739 dst.SetInt(vv)
740 return nil
741 }
742 case uint64:
743 if vv <= math.MaxInt64 && !dst.OverflowInt(int64(vv)) {
744 dst.SetInt(int64(vv))
745 return nil
746 }
747 case float64:
748 if vv <= math.MaxInt64 && !dst.OverflowInt(int64(vv)) {
749 dst.SetInt(int64(vv))
750 return nil
751 }
752 default:
753 return errTypeMismatch(valueType, reflect.TypeOf(v), src.GetToken())
754 }
755 return errOverflow(valueType, fmt.Sprint(v))
756 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
757 v := d.nodeToValue(src)
758 switch vv := v.(type) {
759 case int64:
760 if 0 <= vv && !dst.OverflowUint(uint64(vv)) {
761 dst.SetUint(uint64(vv))
762 return nil
763 }
764 case uint64:
765 if !dst.OverflowUint(vv) {
766 dst.SetUint(vv)
767 return nil
768 }
769 case float64:
770 if 0 <= vv && vv <= math.MaxUint64 && !dst.OverflowUint(uint64(vv)) {
771 dst.SetUint(uint64(vv))
772 return nil
773 }
774 default:
775 return errTypeMismatch(valueType, reflect.TypeOf(v), src.GetToken())
776 }
777 return errOverflow(valueType, fmt.Sprint(v))
778 }
779 v := reflect.ValueOf(d.nodeToValue(src))
780 if v.IsValid() {
781 convertedValue, err := d.convertValue(v, dst.Type(), src)
782 if err != nil {
783 return errors.Wrapf(err, "failed to convert value")
784 }
785 dst.Set(convertedValue)
786 }
787 return nil
788 }
789
790 func (d *Decoder) createDecodableValue(typ reflect.Type) reflect.Value {
791 for {
792 if typ.Kind() == reflect.Ptr {
793 typ = typ.Elem()
794 continue
795 }
796 break
797 }
798 return reflect.New(typ).Elem()
799 }
800
801 func (d *Decoder) castToAssignableValue(value reflect.Value, target reflect.Type) reflect.Value {
802 if target.Kind() != reflect.Ptr {
803 return value
804 }
805 maxTryCount := 5
806 tryCount := 0
807 for {
808 if tryCount > maxTryCount {
809 return value
810 }
811 if value.Type().AssignableTo(target) {
812 break
813 }
814 value = value.Addr()
815 tryCount++
816 }
817 return value
818 }
819
820 func (d *Decoder) createDecodedNewValue(
821 ctx context.Context, typ reflect.Type, defaultVal reflect.Value, node ast.Node,
822 ) (reflect.Value, error) {
823 if node.Type() == ast.AliasType {
824 aliasName := node.(*ast.AliasNode).Value.GetToken().Value
825 newValue := d.anchorValueMap[aliasName]
826 if newValue.IsValid() {
827 return newValue, nil
828 }
829 }
830 if node.Type() == ast.NullType {
831 return reflect.Zero(typ), nil
832 }
833 newValue := d.createDecodableValue(typ)
834 for defaultVal.Kind() == reflect.Ptr {
835 defaultVal = defaultVal.Elem()
836 }
837 if defaultVal.IsValid() && defaultVal.Type().AssignableTo(newValue.Type()) {
838 newValue.Set(defaultVal)
839 }
840 if err := d.decodeValue(ctx, newValue, node); err != nil {
841 return newValue, errors.Wrapf(err, "failed to decode value")
842 }
843 return newValue, nil
844 }
845
846 func (d *Decoder) keyToNodeMap(node ast.Node, ignoreMergeKey bool, getKeyOrValueNode func(*ast.MapNodeIter) ast.Node) (map[string]ast.Node, error) {
847 mapNode, err := d.getMapNode(node)
848 if err != nil {
849 return nil, errors.Wrapf(err, "failed to get map node")
850 }
851 keyMap := map[string]struct{}{}
852 keyToNodeMap := map[string]ast.Node{}
853 if mapNode == nil {
854 return keyToNodeMap, nil
855 }
856 mapIter := mapNode.MapRange()
857 for mapIter.Next() {
858 keyNode := mapIter.Key()
859 if keyNode.Type() == ast.MergeKeyType {
860 if ignoreMergeKey {
861 continue
862 }
863 mergeMap, err := d.keyToNodeMap(mapIter.Value(), ignoreMergeKey, getKeyOrValueNode)
864 if err != nil {
865 return nil, errors.Wrapf(err, "failed to get keyToNodeMap by MergeKey node")
866 }
867 for k, v := range mergeMap {
868 if err := d.validateDuplicateKey(keyMap, k, v); err != nil {
869 return nil, errors.Wrapf(err, "invalid struct key")
870 }
871 keyToNodeMap[k] = v
872 }
873 } else {
874 key, ok := d.nodeToValue(keyNode).(string)
875 if !ok {
876 return nil, errors.Wrapf(err, "failed to decode map key")
877 }
878 if err := d.validateDuplicateKey(keyMap, key, keyNode); err != nil {
879 return nil, errors.Wrapf(err, "invalid struct key")
880 }
881 keyToNodeMap[key] = getKeyOrValueNode(mapIter)
882 }
883 }
884 return keyToNodeMap, nil
885 }
886
887 func (d *Decoder) keyToKeyNodeMap(node ast.Node, ignoreMergeKey bool) (map[string]ast.Node, error) {
888 m, err := d.keyToNodeMap(node, ignoreMergeKey, func(nodeMap *ast.MapNodeIter) ast.Node { return nodeMap.Key() })
889 if err != nil {
890 return nil, errors.Wrapf(err, "failed to get keyToNodeMap")
891 }
892 return m, nil
893 }
894
895 func (d *Decoder) keyToValueNodeMap(node ast.Node, ignoreMergeKey bool) (map[string]ast.Node, error) {
896 m, err := d.keyToNodeMap(node, ignoreMergeKey, func(nodeMap *ast.MapNodeIter) ast.Node { return nodeMap.Value() })
897 if err != nil {
898 return nil, errors.Wrapf(err, "failed to get keyToNodeMap")
899 }
900 return m, nil
901 }
902
903 func (d *Decoder) setDefaultValueIfConflicted(v reflect.Value, fieldMap StructFieldMap) error {
904 typ := v.Type()
905 if typ.Kind() != reflect.Struct {
906 return nil
907 }
908 embeddedStructFieldMap, err := structFieldMap(typ)
909 if err != nil {
910 return errors.Wrapf(err, "failed to get struct field map by embedded type")
911 }
912 for i := 0; i < typ.NumField(); i++ {
913 field := typ.Field(i)
914 if isIgnoredStructField(field) {
915 continue
916 }
917 structField := embeddedStructFieldMap[field.Name]
918 if !fieldMap.isIncludedRenderName(structField.RenderName) {
919 continue
920 }
921 // if declared same key name, set default value
922 fieldValue := v.Field(i)
923 if fieldValue.CanSet() {
924 fieldValue.Set(reflect.Zero(fieldValue.Type()))
925 }
926 }
927 return nil
928 }
929
930 // This is a subset of the formats allowed by the regular expression
931 // defined at http://yaml.org/type/timestamp.html.
932 var allowedTimestampFormats = []string{
933 "2006-1-2T15:4:5.999999999Z07:00", // RCF3339Nano with short date fields.
934 "2006-1-2t15:4:5.999999999Z07:00", // RFC3339Nano with short date fields and lower-case "t".
935 "2006-1-2 15:4:5.999999999", // space separated with no time zone
936 "2006-1-2", // date only
937 }
938
939 func (d *Decoder) castToTime(src ast.Node) (time.Time, error) {
940 if src == nil {
941 return time.Time{}, nil
942 }
943 v := d.nodeToValue(src)
944 if t, ok := v.(time.Time); ok {
945 return t, nil
946 }
947 s, ok := v.(string)
948 if !ok {
949 return time.Time{}, errTypeMismatch(reflect.TypeOf(time.Time{}), reflect.TypeOf(v), src.GetToken())
950 }
951 for _, format := range allowedTimestampFormats {
952 t, err := time.Parse(format, s)
953 if err != nil {
954 // invalid format
955 continue
956 }
957 return t, nil
958 }
959 return time.Time{}, nil
960 }
961
962 func (d *Decoder) decodeTime(ctx context.Context, dst reflect.Value, src ast.Node) error {
963 t, err := d.castToTime(src)
964 if err != nil {
965 return errors.Wrapf(err, "failed to convert to time")
966 }
967 dst.Set(reflect.ValueOf(t))
968 return nil
969 }
970
971 func (d *Decoder) castToDuration(src ast.Node) (time.Duration, error) {
972 if src == nil {
973 return 0, nil
974 }
975 v := d.nodeToValue(src)
976 if t, ok := v.(time.Duration); ok {
977 return t, nil
978 }
979 s, ok := v.(string)
980 if !ok {
981 return 0, errTypeMismatch(reflect.TypeOf(time.Duration(0)), reflect.TypeOf(v), src.GetToken())
982 }
983 t, err := time.ParseDuration(s)
984 if err != nil {
985 return 0, errors.Wrapf(err, "failed to parse duration")
986 }
987 return t, nil
988 }
989
990 func (d *Decoder) decodeDuration(ctx context.Context, dst reflect.Value, src ast.Node) error {
991 t, err := d.castToDuration(src)
992 if err != nil {
993 return errors.Wrapf(err, "failed to convert to duration")
994 }
995 dst.Set(reflect.ValueOf(t))
996 return nil
997 }
998
999 // getMergeAliasName support single alias only
1000 func (d *Decoder) getMergeAliasName(src ast.Node) string {
1001 mapNode, err := d.getMapNode(src)
1002 if err != nil {
1003 return ""
1004 }
1005 if mapNode == nil {
1006 return ""
1007 }
1008 mapIter := mapNode.MapRange()
1009 for mapIter.Next() {
1010 key := mapIter.Key()
1011 value := mapIter.Value()
1012 if key.Type() == ast.MergeKeyType && value.Type() == ast.AliasType {
1013 return value.(*ast.AliasNode).Value.GetToken().Value
1014 }
1015 }
1016 return ""
1017 }
1018
1019 func (d *Decoder) decodeStruct(ctx context.Context, dst reflect.Value, src ast.Node) error {
1020 if src == nil {
1021 return nil
1022 }
1023 structType := dst.Type()
1024 srcValue := reflect.ValueOf(src)
1025 srcType := srcValue.Type()
1026 if srcType.Kind() == reflect.Ptr {
1027 srcType = srcType.Elem()
1028 srcValue = srcValue.Elem()
1029 }
1030 if structType == srcType {
1031 // dst value implements ast.Node
1032 dst.Set(srcValue)
1033 return nil
1034 }
1035 structFieldMap, err := structFieldMap(structType)
1036 if err != nil {
1037 return errors.Wrapf(err, "failed to create struct field map")
1038 }
1039 ignoreMergeKey := structFieldMap.hasMergeProperty()
1040 keyToNodeMap, err := d.keyToValueNodeMap(src, ignoreMergeKey)
1041 if err != nil {
1042 return errors.Wrapf(err, "failed to get keyToValueNodeMap")
1043 }
1044 var unknownFields map[string]ast.Node
1045 if d.disallowUnknownField {
1046 unknownFields, err = d.keyToKeyNodeMap(src, ignoreMergeKey)
1047 if err != nil {
1048 return errors.Wrapf(err, "failed to get keyToKeyNodeMap")
1049 }
1050 }
1051
1052 aliasName := d.getMergeAliasName(src)
1053 var foundErr error
1054
1055 for i := 0; i < structType.NumField(); i++ {
1056 field := structType.Field(i)
1057 if isIgnoredStructField(field) {
1058 continue
1059 }
1060 structField := structFieldMap[field.Name]
1061 if structField.IsInline {
1062 fieldValue := dst.FieldByName(field.Name)
1063 if structField.IsAutoAlias {
1064 if aliasName != "" {
1065 newFieldValue := d.anchorValueMap[aliasName]
1066 if newFieldValue.IsValid() {
1067 fieldValue.Set(d.castToAssignableValue(newFieldValue, fieldValue.Type()))
1068 }
1069 }
1070 continue
1071 }
1072 if !fieldValue.CanSet() {
1073 return xerrors.Errorf("cannot set embedded type as unexported field %s.%s", field.PkgPath, field.Name)
1074 }
1075 if fieldValue.Type().Kind() == reflect.Ptr && src.Type() == ast.NullType {
1076 // set nil value to pointer
1077 fieldValue.Set(reflect.Zero(fieldValue.Type()))
1078 continue
1079 }
1080 mapNode := ast.Mapping(nil, false)
1081 for k, v := range keyToNodeMap {
1082 key := &ast.StringNode{BaseNode: &ast.BaseNode{}, Value: k}
1083 mapNode.Values = append(mapNode.Values, ast.MappingValue(nil, key, v))
1084 }
1085 newFieldValue, err := d.createDecodedNewValue(ctx, fieldValue.Type(), fieldValue, mapNode)
1086 if d.disallowUnknownField {
1087 if err := d.deleteStructKeys(fieldValue.Type(), unknownFields); err != nil {
1088 return errors.Wrapf(err, "cannot delete struct keys")
1089 }
1090 }
1091
1092 if err != nil {
1093 if foundErr != nil {
1094 continue
1095 }
1096 var te *errors.TypeError
1097 if xerrors.As(err, &te) {
1098 if te.StructFieldName != nil {
1099 fieldName := fmt.Sprintf("%s.%s", structType.Name(), *te.StructFieldName)
1100 te.StructFieldName = &fieldName
1101 } else {
1102 fieldName := fmt.Sprintf("%s.%s", structType.Name(), field.Name)
1103 te.StructFieldName = &fieldName
1104 }
1105 foundErr = te
1106 continue
1107 } else {
1108 foundErr = err
1109 }
1110 continue
1111 }
1112 d.setDefaultValueIfConflicted(newFieldValue, structFieldMap)
1113 fieldValue.Set(d.castToAssignableValue(newFieldValue, fieldValue.Type()))
1114 continue
1115 }
1116 v, exists := keyToNodeMap[structField.RenderName]
1117 if !exists {
1118 continue
1119 }
1120 delete(unknownFields, structField.RenderName)
1121 fieldValue := dst.FieldByName(field.Name)
1122 if fieldValue.Type().Kind() == reflect.Ptr && src.Type() == ast.NullType {
1123 // set nil value to pointer
1124 fieldValue.Set(reflect.Zero(fieldValue.Type()))
1125 continue
1126 }
1127 newFieldValue, err := d.createDecodedNewValue(ctx, fieldValue.Type(), fieldValue, v)
1128 if err != nil {
1129 if foundErr != nil {
1130 continue
1131 }
1132 var te *errors.TypeError
1133 if xerrors.As(err, &te) {
1134 fieldName := fmt.Sprintf("%s.%s", structType.Name(), field.Name)
1135 te.StructFieldName = &fieldName
1136 foundErr = te
1137 } else {
1138 foundErr = err
1139 }
1140 continue
1141 }
1142 fieldValue.Set(d.castToAssignableValue(newFieldValue, fieldValue.Type()))
1143 }
1144 if foundErr != nil {
1145 return errors.Wrapf(foundErr, "failed to decode value")
1146 }
1147
1148 // Ignore unknown fields when parsing an inline struct (recognized by a nil token).
1149 // Unknown fields are expected (they could be fields from the parent struct).
1150 if len(unknownFields) != 0 && d.disallowUnknownField && src.GetToken() != nil {
1151 for key, node := range unknownFields {
1152 return errUnknownField(fmt.Sprintf(`unknown field "%s"`, key), node.GetToken())
1153 }
1154 }
1155
1156 if d.validator != nil {
1157 if err := d.validator.Struct(dst.Interface()); err != nil {
1158 ev := reflect.ValueOf(err)
1159 if ev.Type().Kind() == reflect.Slice {
1160 for i := 0; i < ev.Len(); i++ {
1161 fieldErr, ok := ev.Index(i).Interface().(FieldError)
1162 if !ok {
1163 continue
1164 }
1165 fieldName := fieldErr.StructField()
1166 structField, exists := structFieldMap[fieldName]
1167 if !exists {
1168 continue
1169 }
1170 node, exists := keyToNodeMap[structField.RenderName]
1171 if exists {
1172 // TODO: to make FieldError message cutomizable
1173 return errors.ErrSyntax(fmt.Sprintf("%s", err), node.GetToken())
1174 } else if t := src.GetToken(); t != nil && t.Prev != nil && t.Prev.Prev != nil {
1175 // A missing required field will not be in the keyToNodeMap
1176 // the error needs to be associated with the parent of the source node
1177 return errors.ErrSyntax(fmt.Sprintf("%s", err), t.Prev.Prev)
1178 }
1179 }
1180 }
1181 return err
1182 }
1183 }
1184 return nil
1185 }
1186
1187 func (d *Decoder) decodeArray(ctx context.Context, dst reflect.Value, src ast.Node) error {
1188 arrayNode, err := d.getArrayNode(src)
1189 if err != nil {
1190 return errors.Wrapf(err, "failed to get array node")
1191 }
1192 if arrayNode == nil {
1193 return nil
1194 }
1195 iter := arrayNode.ArrayRange()
1196 arrayValue := reflect.New(dst.Type()).Elem()
1197 arrayType := dst.Type()
1198 elemType := arrayType.Elem()
1199 idx := 0
1200
1201 var foundErr error
1202 for iter.Next() {
1203 v := iter.Value()
1204 if elemType.Kind() == reflect.Ptr && v.Type() == ast.NullType {
1205 // set nil value to pointer
1206 arrayValue.Index(idx).Set(reflect.Zero(elemType))
1207 } else {
1208 dstValue, err := d.createDecodedNewValue(ctx, elemType, reflect.Value{}, v)
1209 if err != nil {
1210 if foundErr == nil {
1211 foundErr = err
1212 }
1213 continue
1214 } else {
1215 arrayValue.Index(idx).Set(d.castToAssignableValue(dstValue, elemType))
1216 }
1217 }
1218 idx++
1219 }
1220 dst.Set(arrayValue)
1221 if foundErr != nil {
1222 return errors.Wrapf(foundErr, "failed to decode value")
1223 }
1224 return nil
1225 }
1226
1227 func (d *Decoder) decodeSlice(ctx context.Context, dst reflect.Value, src ast.Node) error {
1228 arrayNode, err := d.getArrayNode(src)
1229 if err != nil {
1230 return errors.Wrapf(err, "failed to get array node")
1231 }
1232 if arrayNode == nil {
1233 return nil
1234 }
1235 iter := arrayNode.ArrayRange()
1236 sliceType := dst.Type()
1237 sliceValue := reflect.MakeSlice(sliceType, 0, iter.Len())
1238 elemType := sliceType.Elem()
1239
1240 var foundErr error
1241 for iter.Next() {
1242 v := iter.Value()
1243 if elemType.Kind() == reflect.Ptr && v.Type() == ast.NullType {
1244 // set nil value to pointer
1245 sliceValue = reflect.Append(sliceValue, reflect.Zero(elemType))
1246 continue
1247 }
1248 dstValue, err := d.createDecodedNewValue(ctx, elemType, reflect.Value{}, v)
1249 if err != nil {
1250 if foundErr == nil {
1251 foundErr = err
1252 }
1253 continue
1254 }
1255 sliceValue = reflect.Append(sliceValue, d.castToAssignableValue(dstValue, elemType))
1256 }
1257 dst.Set(sliceValue)
1258 if foundErr != nil {
1259 return errors.Wrapf(foundErr, "failed to decode value")
1260 }
1261 return nil
1262 }
1263
1264 func (d *Decoder) decodeMapItem(ctx context.Context, dst *MapItem, src ast.Node) error {
1265 mapNode, err := d.getMapNode(src)
1266 if err != nil {
1267 return errors.Wrapf(err, "failed to get map node")
1268 }
1269 if mapNode == nil {
1270 return nil
1271 }
1272 mapIter := mapNode.MapRange()
1273 if !mapIter.Next() {
1274 return nil
1275 }
1276 key := mapIter.Key()
1277 value := mapIter.Value()
1278 if key.Type() == ast.MergeKeyType {
1279 if err := d.decodeMapItem(ctx, dst, value); err != nil {
1280 return errors.Wrapf(err, "failed to decode map with merge key")
1281 }
1282 return nil
1283 }
1284 *dst = MapItem{
1285 Key: d.nodeToValue(key),
1286 Value: d.nodeToValue(value),
1287 }
1288 return nil
1289 }
1290
1291 func (d *Decoder) validateDuplicateKey(keyMap map[string]struct{}, key interface{}, keyNode ast.Node) error {
1292 k, ok := key.(string)
1293 if !ok {
1294 return nil
1295 }
1296 if d.disallowDuplicateKey {
1297 if _, exists := keyMap[k]; exists {
1298 return errDuplicateKey(fmt.Sprintf(`duplicate key "%s"`, k), keyNode.GetToken())
1299 }
1300 }
1301 keyMap[k] = struct{}{}
1302 return nil
1303 }
1304
1305 func (d *Decoder) decodeMapSlice(ctx context.Context, dst *MapSlice, src ast.Node) error {
1306 mapNode, err := d.getMapNode(src)
1307 if err != nil {
1308 return errors.Wrapf(err, "failed to get map node")
1309 }
1310 if mapNode == nil {
1311 return nil
1312 }
1313 mapSlice := MapSlice{}
1314 mapIter := mapNode.MapRange()
1315 keyMap := map[string]struct{}{}
1316 for mapIter.Next() {
1317 key := mapIter.Key()
1318 value := mapIter.Value()
1319 if key.Type() == ast.MergeKeyType {
1320 var m MapSlice
1321 if err := d.decodeMapSlice(ctx, &m, value); err != nil {
1322 return errors.Wrapf(err, "failed to decode map with merge key")
1323 }
1324 for _, v := range m {
1325 if err := d.validateDuplicateKey(keyMap, v.Key, value); err != nil {
1326 return errors.Wrapf(err, "invalid map key")
1327 }
1328 mapSlice = append(mapSlice, v)
1329 }
1330 continue
1331 }
1332 k := d.nodeToValue(key)
1333 if err := d.validateDuplicateKey(keyMap, k, key); err != nil {
1334 return errors.Wrapf(err, "invalid map key")
1335 }
1336 mapSlice = append(mapSlice, MapItem{
1337 Key: k,
1338 Value: d.nodeToValue(value),
1339 })
1340 }
1341 *dst = mapSlice
1342 return nil
1343 }
1344
1345 func (d *Decoder) decodeMap(ctx context.Context, dst reflect.Value, src ast.Node) error {
1346 mapNode, err := d.getMapNode(src)
1347 if err != nil {
1348 return errors.Wrapf(err, "failed to get map node")
1349 }
1350 if mapNode == nil {
1351 return nil
1352 }
1353 mapType := dst.Type()
1354 mapValue := reflect.MakeMap(mapType)
1355 keyType := mapValue.Type().Key()
1356 valueType := mapValue.Type().Elem()
1357 mapIter := mapNode.MapRange()
1358 keyMap := map[string]struct{}{}
1359 var foundErr error
1360 for mapIter.Next() {
1361 key := mapIter.Key()
1362 value := mapIter.Value()
1363 if key.Type() == ast.MergeKeyType {
1364 if err := d.decodeMap(ctx, dst, value); err != nil {
1365 return errors.Wrapf(err, "failed to decode map with merge key")
1366 }
1367 iter := dst.MapRange()
1368 for iter.Next() {
1369 if err := d.validateDuplicateKey(keyMap, iter.Key(), value); err != nil {
1370 return errors.Wrapf(err, "invalid map key")
1371 }
1372 mapValue.SetMapIndex(iter.Key(), iter.Value())
1373 }
1374 continue
1375 }
1376 k := reflect.ValueOf(d.nodeToValue(key))
1377 if k.IsValid() && k.Type().ConvertibleTo(keyType) {
1378 k = k.Convert(keyType)
1379 }
1380 if k.IsValid() {
1381 if err := d.validateDuplicateKey(keyMap, k.Interface(), key); err != nil {
1382 return errors.Wrapf(err, "invalid map key")
1383 }
1384 }
1385 if valueType.Kind() == reflect.Ptr && value.Type() == ast.NullType {
1386 // set nil value to pointer
1387 mapValue.SetMapIndex(k, reflect.Zero(valueType))
1388 continue
1389 }
1390 dstValue, err := d.createDecodedNewValue(ctx, valueType, reflect.Value{}, value)
1391 if err != nil {
1392 if foundErr == nil {
1393 foundErr = err
1394 }
1395 }
1396 if !k.IsValid() {
1397 // expect nil key
1398 mapValue.SetMapIndex(d.createDecodableValue(keyType), d.castToAssignableValue(dstValue, valueType))
1399 continue
1400 }
1401 mapValue.SetMapIndex(k, d.castToAssignableValue(dstValue, valueType))
1402 }
1403 dst.Set(mapValue)
1404 if foundErr != nil {
1405 return errors.Wrapf(foundErr, "failed to decode value")
1406 }
1407 return nil
1408 }
1409
1410 func (d *Decoder) fileToReader(file string) (io.Reader, error) {
1411 reader, err := os.Open(file)
1412 if err != nil {
1413 return nil, errors.Wrapf(err, "failed to open file")
1414 }
1415 return reader, nil
1416 }
1417
1418 func (d *Decoder) isYAMLFile(file string) bool {
1419 ext := filepath.Ext(file)
1420 if ext == ".yml" {
1421 return true
1422 }
1423 if ext == ".yaml" {
1424 return true
1425 }
1426 return false
1427 }
1428
1429 func (d *Decoder) readersUnderDir(dir string) ([]io.Reader, error) {
1430 pattern := fmt.Sprintf("%s/*", dir)
1431 matches, err := filepath.Glob(pattern)
1432 if err != nil {
1433 return nil, errors.Wrapf(err, "failed to get files by %s", pattern)
1434 }
1435 readers := []io.Reader{}
1436 for _, match := range matches {
1437 if !d.isYAMLFile(match) {
1438 continue
1439 }
1440 reader, err := d.fileToReader(match)
1441 if err != nil {
1442 return nil, errors.Wrapf(err, "failed to get reader")
1443 }
1444 readers = append(readers, reader)
1445 }
1446 return readers, nil
1447 }
1448
1449 func (d *Decoder) readersUnderDirRecursive(dir string) ([]io.Reader, error) {
1450 readers := []io.Reader{}
1451 if err := filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
1452 if !d.isYAMLFile(path) {
1453 return nil
1454 }
1455 reader, err := d.fileToReader(path)
1456 if err != nil {
1457 return errors.Wrapf(err, "failed to get reader")
1458 }
1459 readers = append(readers, reader)
1460 return nil
1461 }); err != nil {
1462 return nil, errors.Wrapf(err, "interrupt walk in %s", dir)
1463 }
1464 return readers, nil
1465 }
1466
1467 func (d *Decoder) resolveReference() error {
1468 for _, opt := range d.opts {
1469 if err := opt(d); err != nil {
1470 return errors.Wrapf(err, "failed to exec option")
1471 }
1472 }
1473 for _, file := range d.referenceFiles {
1474 reader, err := d.fileToReader(file)
1475 if err != nil {
1476 return errors.Wrapf(err, "failed to get reader")
1477 }
1478 d.referenceReaders = append(d.referenceReaders, reader)
1479 }
1480 for _, dir := range d.referenceDirs {
1481 if !d.isRecursiveDir {
1482 readers, err := d.readersUnderDir(dir)
1483 if err != nil {
1484 return errors.Wrapf(err, "failed to get readers from under the %s", dir)
1485 }
1486 d.referenceReaders = append(d.referenceReaders, readers...)
1487 } else {
1488 readers, err := d.readersUnderDirRecursive(dir)
1489 if err != nil {
1490 return errors.Wrapf(err, "failed to get readers from under the %s", dir)
1491 }
1492 d.referenceReaders = append(d.referenceReaders, readers...)
1493 }
1494 }
1495 for _, reader := range d.referenceReaders {
1496 bytes, err := ioutil.ReadAll(reader)
1497 if err != nil {
1498 return errors.Wrapf(err, "failed to read buffer")
1499 }
1500
1501 // assign new anchor definition to anchorMap
1502 if _, err := d.parse(bytes); err != nil {
1503 return errors.Wrapf(err, "failed to decode")
1504 }
1505 }
1506 d.isResolvedReference = true
1507 return nil
1508 }
1509
1510 func (d *Decoder) parse(bytes []byte) (*ast.File, error) {
1511 var parseMode parser.Mode
1512 if d.toCommentMap != nil {
1513 parseMode = parser.ParseComments
1514 }
1515 f, err := parser.ParseBytes(bytes, parseMode)
1516 if err != nil {
1517 return nil, errors.Wrapf(err, "failed to parse yaml")
1518 }
1519 normalizedFile := &ast.File{}
1520 for _, doc := range f.Docs {
1521 // try to decode ast.Node to value and map anchor value to anchorMap
1522 if v := d.nodeToValue(doc.Body); v != nil {
1523 normalizedFile.Docs = append(normalizedFile.Docs, doc)
1524 }
1525 }
1526 return normalizedFile, nil
1527 }
1528
1529 func (d *Decoder) isInitialized() bool {
1530 return d.parsedFile != nil
1531 }
1532
1533 func (d *Decoder) decodeInit() error {
1534 if !d.isResolvedReference {
1535 if err := d.resolveReference(); err != nil {
1536 return errors.Wrapf(err, "failed to resolve reference")
1537 }
1538 }
1539 var buf bytes.Buffer
1540 if _, err := io.Copy(&buf, d.reader); err != nil {
1541 return errors.Wrapf(err, "failed to copy from reader")
1542 }
1543 file, err := d.parse(buf.Bytes())
1544 if err != nil {
1545 return errors.Wrapf(err, "failed to decode")
1546 }
1547 d.parsedFile = file
1548 return nil
1549 }
1550
1551 func (d *Decoder) decode(ctx context.Context, v reflect.Value) error {
1552 if len(d.parsedFile.Docs) <= d.streamIndex {
1553 return io.EOF
1554 }
1555 body := d.parsedFile.Docs[d.streamIndex].Body
1556 if body == nil {
1557 return nil
1558 }
1559 if err := d.decodeValue(ctx, v.Elem(), body); err != nil {
1560 return errors.Wrapf(err, "failed to decode value")
1561 }
1562 d.streamIndex++
1563 return nil
1564 }
1565
1566 // Decode reads the next YAML-encoded value from its input
1567 // and stores it in the value pointed to by v.
1568 //
1569 // See the documentation for Unmarshal for details about the
1570 // conversion of YAML into a Go value.
1571 func (d *Decoder) Decode(v interface{}) error {
1572 return d.DecodeContext(context.Background(), v)
1573 }
1574
1575 // DecodeContext reads the next YAML-encoded value from its input
1576 // and stores it in the value pointed to by v with context.Context.
1577 func (d *Decoder) DecodeContext(ctx context.Context, v interface{}) error {
1578 rv := reflect.ValueOf(v)
1579 if rv.Type().Kind() != reflect.Ptr {
1580 return errors.ErrDecodeRequiredPointerType
1581 }
1582 if d.isInitialized() {
1583 if err := d.decode(ctx, rv); err != nil {
1584 if err == io.EOF {
1585 return err
1586 }
1587 return errors.Wrapf(err, "failed to decode")
1588 }
1589 return nil
1590 }
1591 if err := d.decodeInit(); err != nil {
1592 return errors.Wrapf(err, "failed to decodeInit")
1593 }
1594 if err := d.decode(ctx, rv); err != nil {
1595 if err == io.EOF {
1596 return err
1597 }
1598 return errors.Wrapf(err, "failed to decode")
1599 }
1600 return nil
1601 }
1602
1603 // DecodeFromNode decodes node into the value pointed to by v.
1604 func (d *Decoder) DecodeFromNode(node ast.Node, v interface{}) error {
1605 return d.DecodeFromNodeContext(context.Background(), node, v)
1606 }
1607
1608 // DecodeFromNodeContext decodes node into the value pointed to by v with context.Context.
1609 func (d *Decoder) DecodeFromNodeContext(ctx context.Context, node ast.Node, v interface{}) error {
1610 rv := reflect.ValueOf(v)
1611 if rv.Type().Kind() != reflect.Ptr {
1612 return errors.ErrDecodeRequiredPointerType
1613 }
1614 if !d.isInitialized() {
1615 if err := d.decodeInit(); err != nil {
1616 return errors.Wrapf(err, "failed to decodInit")
1617 }
1618 }
1619 // resolve references to the anchor on the same file
1620 d.nodeToValue(node)
1621 if err := d.decodeValue(ctx, rv.Elem(), node); err != nil {
1622 return errors.Wrapf(err, "failed to decode value")
1623 }
1624 return nil
1625 }
1626