From beb76d932184532053838b617bb39a2629b8abe0 Mon Sep 17 00:00:00 2001 From: Florian Rey Date: Wed, 11 Oct 2023 15:40:18 +0200 Subject: [PATCH] Fix xerrors deprecations --- decode.go | 177 +++++++++++++++++---------------- decode_test.go | 5 +- encode.go | 80 +++++++-------- error.go | 16 +-- go.mod | 2 +- go.sum | 4 +- internal/{errors => }/error.go | 5 +- parser/parser.go | 94 ++++++++--------- path.go | 152 ++++++++++++++-------------- yaml.go | 26 ++--- 10 files changed, 283 insertions(+), 278 deletions(-) rename internal/{errors => }/error.go (99%) diff --git a/decode.go b/decode.go index d3dbabcb..e2b0c6df 100644 --- a/decode.go +++ b/decode.go @@ -5,6 +5,7 @@ import ( "context" "encoding" "encoding/base64" + "errors" "fmt" "io" "io/ioutil" @@ -17,7 +18,7 @@ import ( "time" "github.com/goccy/go-yaml/ast" - "github.com/goccy/go-yaml/internal/errors" + "github.com/goccy/go-yaml/internal" "github.com/goccy/go-yaml/parser" "github.com/goccy/go-yaml/token" "golang.org/x/xerrors" @@ -522,8 +523,8 @@ func errOverflow(dstType reflect.Type, num string) *overflowError { return &overflowError{dstType: dstType, srcNum: num} } -func errTypeMismatch(dstType, srcType reflect.Type, token *token.Token) *errors.TypeError { - return &errors.TypeError{DstType: dstType, SrcType: srcType, Token: token} +func errTypeMismatch(dstType, srcType reflect.Type, token *token.Token) *internal.TypeError { + return &internal.TypeError{DstType: dstType, SrcType: srcType, Token: token} } type unknownFieldError struct { @@ -535,11 +536,11 @@ func (e *unknownFieldError) Error() string { } func errUnknownField(msg string, tk *token.Token) *unknownFieldError { - return &unknownFieldError{err: errors.ErrSyntax(msg, tk)} + return &unknownFieldError{err: internal.ErrSyntax(msg, tk)} } func errUnexpectedNodeType(actual, expected ast.NodeType, tk *token.Token) error { - return errors.ErrSyntax(fmt.Sprintf("%s was used where %s is expected", actual.YAMLName(), expected.YAMLName()), tk) + return internal.ErrSyntax(fmt.Sprintf("%s was used where %s is expected", actual.YAMLName(), expected.YAMLName()), tk) } type duplicateKeyError struct { @@ -551,7 +552,7 @@ func (e *duplicateKeyError) Error() string { } func errDuplicateKey(msg string, tk *token.Token) *duplicateKeyError { - return &duplicateKeyError{err: errors.ErrSyntax(msg, tk)} + return &duplicateKeyError{err: internal.ErrSyntax(msg, tk)} } func (d *Decoder) deleteStructKeys(structType reflect.Type, unknownFields map[string]ast.Node) error { @@ -560,7 +561,7 @@ func (d *Decoder) deleteStructKeys(structType reflect.Type, unknownFields map[st } structFieldMap, err := structFieldMap(structType) if err != nil { - return errors.Wrapf(err, "failed to create struct field map") + return internal.Wrapf(err, "failed to create struct field map") } for j := 0; j < structType.NumField(); j++ { @@ -698,10 +699,10 @@ func (d *Decoder) decodeByUnmarshaler(ctx context.Context, dst reflect.Value, sr if unmarshaler, exists := d.unmarshalerFromCustomUnmarshalerMap(ptrValue.Type()); exists { b, err := d.unmarshalableDocument(src) if err != nil { - return errors.Wrapf(err, "failed to UnmarshalYAML") + return internal.Wrapf(err, "failed to UnmarshalYAML") } if err := unmarshaler(ptrValue.Interface(), b); err != nil { - return errors.Wrapf(err, "failed to UnmarshalYAML") + return internal.Wrapf(err, "failed to UnmarshalYAML") } return nil } @@ -710,10 +711,10 @@ func (d *Decoder) decodeByUnmarshaler(ctx context.Context, dst reflect.Value, sr if unmarshaler, ok := iface.(BytesUnmarshalerContext); ok { b, err := d.unmarshalableDocument(src) if err != nil { - return errors.Wrapf(err, "failed to UnmarshalYAML") + return internal.Wrapf(err, "failed to UnmarshalYAML") } if err := unmarshaler.UnmarshalYAML(ctx, b); err != nil { - return errors.Wrapf(err, "failed to UnmarshalYAML") + return internal.Wrapf(err, "failed to UnmarshalYAML") } return nil } @@ -721,10 +722,10 @@ func (d *Decoder) decodeByUnmarshaler(ctx context.Context, dst reflect.Value, sr if unmarshaler, ok := iface.(BytesUnmarshaler); ok { b, err := d.unmarshalableDocument(src) if err != nil { - return errors.Wrapf(err, "failed to UnmarshalYAML") + return internal.Wrapf(err, "failed to UnmarshalYAML") } if err := unmarshaler.UnmarshalYAML(b); err != nil { - return errors.Wrapf(err, "failed to UnmarshalYAML") + return internal.Wrapf(err, "failed to UnmarshalYAML") } return nil } @@ -733,14 +734,14 @@ func (d *Decoder) decodeByUnmarshaler(ctx context.Context, dst reflect.Value, sr if err := unmarshaler.UnmarshalYAML(ctx, func(v interface{}) error { rv := reflect.ValueOf(v) if rv.Type().Kind() != reflect.Ptr { - return errors.ErrDecodeRequiredPointerType + return internal.ErrDecodeRequiredPointerType } if err := d.decodeValue(ctx, rv.Elem(), src); err != nil { - return errors.Wrapf(err, "failed to decode value") + return internal.Wrapf(err, "failed to decode value") } return nil }); err != nil { - return errors.Wrapf(err, "failed to UnmarshalYAML") + return internal.Wrapf(err, "failed to UnmarshalYAML") } return nil } @@ -749,14 +750,14 @@ func (d *Decoder) decodeByUnmarshaler(ctx context.Context, dst reflect.Value, sr if err := unmarshaler.UnmarshalYAML(func(v interface{}) error { rv := reflect.ValueOf(v) if rv.Type().Kind() != reflect.Ptr { - return errors.ErrDecodeRequiredPointerType + return internal.ErrDecodeRequiredPointerType } if err := d.decodeValue(ctx, rv.Elem(), src); err != nil { - return errors.Wrapf(err, "failed to decode value") + return internal.Wrapf(err, "failed to decode value") } return nil }); err != nil { - return errors.Wrapf(err, "failed to UnmarshalYAML") + return internal.Wrapf(err, "failed to UnmarshalYAML") } return nil } @@ -772,11 +773,11 @@ func (d *Decoder) decodeByUnmarshaler(ctx context.Context, dst reflect.Value, sr if unmarshaler, isText := iface.(encoding.TextUnmarshaler); isText { b, ok, err := d.unmarshalableText(src) if err != nil { - return errors.Wrapf(err, "failed to UnmarshalText") + return internal.Wrapf(err, "failed to UnmarshalText") } if ok { if err := unmarshaler.UnmarshalText(b); err != nil { - return errors.Wrapf(err, "failed to UnmarshalText") + return internal.Wrapf(err, "failed to UnmarshalText") } return nil } @@ -786,15 +787,15 @@ func (d *Decoder) decodeByUnmarshaler(ctx context.Context, dst reflect.Value, sr if unmarshaler, ok := iface.(jsonUnmarshaler); ok { b, err := d.unmarshalableDocument(src) if err != nil { - return errors.Wrapf(err, "failed to UnmarshalJSON") + return internal.Wrapf(err, "failed to UnmarshalJSON") } jsonBytes, err := YAMLToJSON(b) if err != nil { - return errors.Wrapf(err, "failed to convert yaml to json") + return internal.Wrapf(err, "failed to convert yaml to json") } jsonBytes = bytes.TrimRight(jsonBytes, "\n") if err := unmarshaler.UnmarshalJSON(jsonBytes); err != nil { - return errors.Wrapf(err, "failed to UnmarshalJSON") + return internal.Wrapf(err, "failed to UnmarshalJSON") } return nil } @@ -816,7 +817,7 @@ func (d *Decoder) decodeValue(ctx context.Context, dst reflect.Value, src ast.No } if d.canDecodeByUnmarshaler(dst) { if err := d.decodeByUnmarshaler(ctx, dst, src); err != nil { - return errors.Wrapf(err, "failed to decode by unmarshaler") + return internal.Wrapf(err, "failed to decode by unmarshaler") } return nil } @@ -833,7 +834,7 @@ func (d *Decoder) decodeValue(ctx context.Context, dst reflect.Value, src ast.No } v := d.createDecodableValue(dst.Type()) if err := d.decodeValue(ctx, v, src); err != nil { - return errors.Wrapf(err, "failed to decode ptr value") + return internal.Wrapf(err, "failed to decode ptr value") } dst.Set(d.castToAssignableValue(v, dst.Type())) case reflect.Interface: @@ -908,7 +909,7 @@ func (d *Decoder) decodeValue(ctx context.Context, dst reflect.Value, src ast.No if v.IsValid() { convertedValue, err := d.convertValue(v, dst.Type(), src) if err != nil { - return errors.Wrapf(err, "failed to convert value") + return internal.Wrapf(err, "failed to convert value") } dst.Set(convertedValue) } @@ -966,7 +967,7 @@ func (d *Decoder) createDecodedNewValue( newValue.Set(defaultVal) } if err := d.decodeValue(ctx, newValue, node); err != nil { - return newValue, errors.Wrapf(err, "failed to decode value") + return newValue, internal.Wrapf(err, "failed to decode value") } return newValue, nil } @@ -974,7 +975,7 @@ func (d *Decoder) createDecodedNewValue( func (d *Decoder) keyToNodeMap(node ast.Node, ignoreMergeKey bool, getKeyOrValueNode func(*ast.MapNodeIter) ast.Node) (map[string]ast.Node, error) { mapNode, err := d.getMapNode(node) if err != nil { - return nil, errors.Wrapf(err, "failed to get map node") + return nil, internal.Wrapf(err, "failed to get map node") } keyMap := map[string]struct{}{} keyToNodeMap := map[string]ast.Node{} @@ -990,21 +991,21 @@ func (d *Decoder) keyToNodeMap(node ast.Node, ignoreMergeKey bool, getKeyOrValue } mergeMap, err := d.keyToNodeMap(mapIter.Value(), ignoreMergeKey, getKeyOrValueNode) if err != nil { - return nil, errors.Wrapf(err, "failed to get keyToNodeMap by MergeKey node") + return nil, internal.Wrapf(err, "failed to get keyToNodeMap by MergeKey node") } for k, v := range mergeMap { if err := d.validateDuplicateKey(keyMap, k, v); err != nil { - return nil, errors.Wrapf(err, "invalid struct key") + return nil, internal.Wrapf(err, "invalid struct key") } keyToNodeMap[k] = v } } else { key, ok := d.nodeToValue(keyNode).(string) if !ok { - return nil, errors.Wrapf(err, "failed to decode map key") + return nil, internal.Wrapf(err, "failed to decode map key") } if err := d.validateDuplicateKey(keyMap, key, keyNode); err != nil { - return nil, errors.Wrapf(err, "invalid struct key") + return nil, internal.Wrapf(err, "invalid struct key") } keyToNodeMap[key] = getKeyOrValueNode(mapIter) } @@ -1015,7 +1016,7 @@ func (d *Decoder) keyToNodeMap(node ast.Node, ignoreMergeKey bool, getKeyOrValue func (d *Decoder) keyToKeyNodeMap(node ast.Node, ignoreMergeKey bool) (map[string]ast.Node, error) { m, err := d.keyToNodeMap(node, ignoreMergeKey, func(nodeMap *ast.MapNodeIter) ast.Node { return nodeMap.Key() }) if err != nil { - return nil, errors.Wrapf(err, "failed to get keyToNodeMap") + return nil, internal.Wrapf(err, "failed to get keyToNodeMap") } return m, nil } @@ -1023,7 +1024,7 @@ func (d *Decoder) keyToKeyNodeMap(node ast.Node, ignoreMergeKey bool) (map[strin func (d *Decoder) keyToValueNodeMap(node ast.Node, ignoreMergeKey bool) (map[string]ast.Node, error) { m, err := d.keyToNodeMap(node, ignoreMergeKey, func(nodeMap *ast.MapNodeIter) ast.Node { return nodeMap.Value() }) if err != nil { - return nil, errors.Wrapf(err, "failed to get keyToNodeMap") + return nil, internal.Wrapf(err, "failed to get keyToNodeMap") } return m, nil } @@ -1035,7 +1036,7 @@ func (d *Decoder) setDefaultValueIfConflicted(v reflect.Value, fieldMap StructFi } embeddedStructFieldMap, err := structFieldMap(typ) if err != nil { - return errors.Wrapf(err, "failed to get struct field map by embedded type") + return internal.Wrapf(err, "failed to get struct field map by embedded type") } for i := 0; i < typ.NumField(); i++ { field := typ.Field(i) @@ -1090,7 +1091,7 @@ func (d *Decoder) castToTime(src ast.Node) (time.Time, error) { func (d *Decoder) decodeTime(ctx context.Context, dst reflect.Value, src ast.Node) error { t, err := d.castToTime(src) if err != nil { - return errors.Wrapf(err, "failed to convert to time") + return internal.Wrapf(err, "failed to convert to time") } dst.Set(reflect.ValueOf(t)) return nil @@ -1110,7 +1111,7 @@ func (d *Decoder) castToDuration(src ast.Node) (time.Duration, error) { } t, err := time.ParseDuration(s) if err != nil { - return 0, errors.Wrapf(err, "failed to parse duration") + return 0, internal.Wrapf(err, "failed to parse duration") } return t, nil } @@ -1118,7 +1119,7 @@ func (d *Decoder) castToDuration(src ast.Node) (time.Duration, error) { func (d *Decoder) decodeDuration(ctx context.Context, dst reflect.Value, src ast.Node) error { t, err := d.castToDuration(src) if err != nil { - return errors.Wrapf(err, "failed to convert to duration") + return internal.Wrapf(err, "failed to convert to duration") } dst.Set(reflect.ValueOf(t)) return nil @@ -1162,18 +1163,18 @@ func (d *Decoder) decodeStruct(ctx context.Context, dst reflect.Value, src ast.N } structFieldMap, err := structFieldMap(structType) if err != nil { - return errors.Wrapf(err, "failed to create struct field map") + return internal.Wrapf(err, "failed to create struct field map") } ignoreMergeKey := structFieldMap.hasMergeProperty() keyToNodeMap, err := d.keyToValueNodeMap(src, ignoreMergeKey) if err != nil { - return errors.Wrapf(err, "failed to get keyToValueNodeMap") + return internal.Wrapf(err, "failed to get keyToValueNodeMap") } var unknownFields map[string]ast.Node if d.disallowUnknownField { unknownFields, err = d.keyToKeyNodeMap(src, ignoreMergeKey) if err != nil { - return errors.Wrapf(err, "failed to get keyToKeyNodeMap") + return internal.Wrapf(err, "failed to get keyToKeyNodeMap") } } @@ -1213,7 +1214,7 @@ func (d *Decoder) decodeStruct(ctx context.Context, dst reflect.Value, src ast.N newFieldValue, err := d.createDecodedNewValue(ctx, fieldValue.Type(), fieldValue, mapNode) if d.disallowUnknownField { if err := d.deleteStructKeys(fieldValue.Type(), unknownFields); err != nil { - return errors.Wrapf(err, "cannot delete struct keys") + return internal.Wrapf(err, "cannot delete struct keys") } } @@ -1221,8 +1222,8 @@ func (d *Decoder) decodeStruct(ctx context.Context, dst reflect.Value, src ast.N if foundErr != nil { continue } - var te *errors.TypeError - if xerrors.As(err, &te) { + var te *internal.TypeError + if errors.As(err, &te) { if te.StructFieldName != nil { fieldName := fmt.Sprintf("%s.%s", structType.Name(), *te.StructFieldName) te.StructFieldName = &fieldName @@ -1257,8 +1258,8 @@ func (d *Decoder) decodeStruct(ctx context.Context, dst reflect.Value, src ast.N if foundErr != nil { continue } - var te *errors.TypeError - if xerrors.As(err, &te) { + var te *internal.TypeError + if errors.As(err, &te) { fieldName := fmt.Sprintf("%s.%s", structType.Name(), field.Name) te.StructFieldName = &fieldName foundErr = te @@ -1270,7 +1271,7 @@ func (d *Decoder) decodeStruct(ctx context.Context, dst reflect.Value, src ast.N fieldValue.Set(d.castToAssignableValue(newFieldValue, fieldValue.Type())) } if foundErr != nil { - return errors.Wrapf(foundErr, "failed to decode value") + return internal.Wrapf(foundErr, "failed to decode value") } // Ignore unknown fields when parsing an inline struct (recognized by a nil token). @@ -1298,11 +1299,11 @@ func (d *Decoder) decodeStruct(ctx context.Context, dst reflect.Value, src ast.N node, exists := keyToNodeMap[structField.RenderName] if exists { // TODO: to make FieldError message cutomizable - return errors.ErrSyntax(fmt.Sprintf("%s", err), node.GetToken()) + return internal.ErrSyntax(fmt.Sprintf("%s", err), node.GetToken()) } else if t := src.GetToken(); t != nil && t.Prev != nil && t.Prev.Prev != nil { // A missing required field will not be in the keyToNodeMap // the error needs to be associated with the parent of the source node - return errors.ErrSyntax(fmt.Sprintf("%s", err), t.Prev.Prev) + return internal.ErrSyntax(fmt.Sprintf("%s", err), t.Prev.Prev) } } } @@ -1315,7 +1316,7 @@ func (d *Decoder) decodeStruct(ctx context.Context, dst reflect.Value, src ast.N func (d *Decoder) decodeArray(ctx context.Context, dst reflect.Value, src ast.Node) error { arrayNode, err := d.getArrayNode(src) if err != nil { - return errors.Wrapf(err, "failed to get array node") + return internal.Wrapf(err, "failed to get array node") } if arrayNode == nil { return nil @@ -1347,7 +1348,7 @@ func (d *Decoder) decodeArray(ctx context.Context, dst reflect.Value, src ast.No } dst.Set(arrayValue) if foundErr != nil { - return errors.Wrapf(foundErr, "failed to decode value") + return internal.Wrapf(foundErr, "failed to decode value") } return nil } @@ -1355,7 +1356,7 @@ func (d *Decoder) decodeArray(ctx context.Context, dst reflect.Value, src ast.No func (d *Decoder) decodeSlice(ctx context.Context, dst reflect.Value, src ast.Node) error { arrayNode, err := d.getArrayNode(src) if err != nil { - return errors.Wrapf(err, "failed to get array node") + return internal.Wrapf(err, "failed to get array node") } if arrayNode == nil { return nil @@ -1384,7 +1385,7 @@ func (d *Decoder) decodeSlice(ctx context.Context, dst reflect.Value, src ast.No } dst.Set(sliceValue) if foundErr != nil { - return errors.Wrapf(foundErr, "failed to decode value") + return internal.Wrapf(foundErr, "failed to decode value") } return nil } @@ -1392,7 +1393,7 @@ func (d *Decoder) decodeSlice(ctx context.Context, dst reflect.Value, src ast.No func (d *Decoder) decodeMapItem(ctx context.Context, dst *MapItem, src ast.Node) error { mapNode, err := d.getMapNode(src) if err != nil { - return errors.Wrapf(err, "failed to get map node") + return internal.Wrapf(err, "failed to get map node") } if mapNode == nil { return nil @@ -1405,7 +1406,7 @@ func (d *Decoder) decodeMapItem(ctx context.Context, dst *MapItem, src ast.Node) value := mapIter.Value() if key.Type() == ast.MergeKeyType { if err := d.decodeMapItem(ctx, dst, value); err != nil { - return errors.Wrapf(err, "failed to decode map with merge key") + return internal.Wrapf(err, "failed to decode map with merge key") } return nil } @@ -1433,7 +1434,7 @@ func (d *Decoder) validateDuplicateKey(keyMap map[string]struct{}, key interface func (d *Decoder) decodeMapSlice(ctx context.Context, dst *MapSlice, src ast.Node) error { mapNode, err := d.getMapNode(src) if err != nil { - return errors.Wrapf(err, "failed to get map node") + return internal.Wrapf(err, "failed to get map node") } if mapNode == nil { return nil @@ -1447,11 +1448,11 @@ func (d *Decoder) decodeMapSlice(ctx context.Context, dst *MapSlice, src ast.Nod if key.Type() == ast.MergeKeyType { var m MapSlice if err := d.decodeMapSlice(ctx, &m, value); err != nil { - return errors.Wrapf(err, "failed to decode map with merge key") + return internal.Wrapf(err, "failed to decode map with merge key") } for _, v := range m { if err := d.validateDuplicateKey(keyMap, v.Key, value); err != nil { - return errors.Wrapf(err, "invalid map key") + return internal.Wrapf(err, "invalid map key") } mapSlice = append(mapSlice, v) } @@ -1459,7 +1460,7 @@ func (d *Decoder) decodeMapSlice(ctx context.Context, dst *MapSlice, src ast.Nod } k := d.nodeToValue(key) if err := d.validateDuplicateKey(keyMap, k, key); err != nil { - return errors.Wrapf(err, "invalid map key") + return internal.Wrapf(err, "invalid map key") } mapSlice = append(mapSlice, MapItem{ Key: k, @@ -1473,7 +1474,7 @@ func (d *Decoder) decodeMapSlice(ctx context.Context, dst *MapSlice, src ast.Nod func (d *Decoder) decodeMap(ctx context.Context, dst reflect.Value, src ast.Node) error { mapNode, err := d.getMapNode(src) if err != nil { - return errors.Wrapf(err, "failed to get map node") + return internal.Wrapf(err, "failed to get map node") } if mapNode == nil { return nil @@ -1490,12 +1491,12 @@ func (d *Decoder) decodeMap(ctx context.Context, dst reflect.Value, src ast.Node value := mapIter.Value() if key.Type() == ast.MergeKeyType { if err := d.decodeMap(ctx, dst, value); err != nil { - return errors.Wrapf(err, "failed to decode map with merge key") + return internal.Wrapf(err, "failed to decode map with merge key") } iter := dst.MapRange() for iter.Next() { if err := d.validateDuplicateKey(keyMap, iter.Key(), value); err != nil { - return errors.Wrapf(err, "invalid map key") + return internal.Wrapf(err, "invalid map key") } mapValue.SetMapIndex(iter.Key(), iter.Value()) } @@ -1507,7 +1508,7 @@ func (d *Decoder) decodeMap(ctx context.Context, dst reflect.Value, src ast.Node } if k.IsValid() { if err := d.validateDuplicateKey(keyMap, k.Interface(), key); err != nil { - return errors.Wrapf(err, "invalid map key") + return internal.Wrapf(err, "invalid map key") } } if valueType.Kind() == reflect.Ptr && value.Type() == ast.NullType { @@ -1530,7 +1531,7 @@ func (d *Decoder) decodeMap(ctx context.Context, dst reflect.Value, src ast.Node } dst.Set(mapValue) if foundErr != nil { - return errors.Wrapf(foundErr, "failed to decode value") + return internal.Wrapf(foundErr, "failed to decode value") } return nil } @@ -1538,7 +1539,7 @@ func (d *Decoder) decodeMap(ctx context.Context, dst reflect.Value, src ast.Node func (d *Decoder) fileToReader(file string) (io.Reader, error) { reader, err := os.Open(file) if err != nil { - return nil, errors.Wrapf(err, "failed to open file") + return nil, internal.Wrapf(err, "failed to open file") } return reader, nil } @@ -1558,7 +1559,7 @@ func (d *Decoder) readersUnderDir(dir string) ([]io.Reader, error) { pattern := fmt.Sprintf("%s/*", dir) matches, err := filepath.Glob(pattern) if err != nil { - return nil, errors.Wrapf(err, "failed to get files by %s", pattern) + return nil, internal.Wrapf(err, "failed to get files by %s", pattern) } readers := []io.Reader{} for _, match := range matches { @@ -1567,7 +1568,7 @@ func (d *Decoder) readersUnderDir(dir string) ([]io.Reader, error) { } reader, err := d.fileToReader(match) if err != nil { - return nil, errors.Wrapf(err, "failed to get reader") + return nil, internal.Wrapf(err, "failed to get reader") } readers = append(readers, reader) } @@ -1582,12 +1583,12 @@ func (d *Decoder) readersUnderDirRecursive(dir string) ([]io.Reader, error) { } reader, err := d.fileToReader(path) if err != nil { - return errors.Wrapf(err, "failed to get reader") + return internal.Wrapf(err, "failed to get reader") } readers = append(readers, reader) return nil }); err != nil { - return nil, errors.Wrapf(err, "interrupt walk in %s", dir) + return nil, internal.Wrapf(err, "interrupt walk in %s", dir) } return readers, nil } @@ -1595,13 +1596,13 @@ func (d *Decoder) readersUnderDirRecursive(dir string) ([]io.Reader, error) { func (d *Decoder) resolveReference() error { for _, opt := range d.opts { if err := opt(d); err != nil { - return errors.Wrapf(err, "failed to exec option") + return internal.Wrapf(err, "failed to exec option") } } for _, file := range d.referenceFiles { reader, err := d.fileToReader(file) if err != nil { - return errors.Wrapf(err, "failed to get reader") + return internal.Wrapf(err, "failed to get reader") } d.referenceReaders = append(d.referenceReaders, reader) } @@ -1609,13 +1610,13 @@ func (d *Decoder) resolveReference() error { if !d.isRecursiveDir { readers, err := d.readersUnderDir(dir) if err != nil { - return errors.Wrapf(err, "failed to get readers from under the %s", dir) + return internal.Wrapf(err, "failed to get readers from under the %s", dir) } d.referenceReaders = append(d.referenceReaders, readers...) } else { readers, err := d.readersUnderDirRecursive(dir) if err != nil { - return errors.Wrapf(err, "failed to get readers from under the %s", dir) + return internal.Wrapf(err, "failed to get readers from under the %s", dir) } d.referenceReaders = append(d.referenceReaders, readers...) } @@ -1623,12 +1624,12 @@ func (d *Decoder) resolveReference() error { for _, reader := range d.referenceReaders { bytes, err := ioutil.ReadAll(reader) if err != nil { - return errors.Wrapf(err, "failed to read buffer") + return internal.Wrapf(err, "failed to read buffer") } // assign new anchor definition to anchorMap if _, err := d.parse(bytes); err != nil { - return errors.Wrapf(err, "failed to decode") + return internal.Wrapf(err, "failed to decode") } } d.isResolvedReference = true @@ -1642,7 +1643,7 @@ func (d *Decoder) parse(bytes []byte) (*ast.File, error) { } f, err := parser.ParseBytes(bytes, parseMode) if err != nil { - return nil, errors.Wrapf(err, "failed to parse yaml") + return nil, internal.Wrapf(err, "failed to parse yaml") } normalizedFile := &ast.File{} for _, doc := range f.Docs { @@ -1661,16 +1662,16 @@ func (d *Decoder) isInitialized() bool { func (d *Decoder) decodeInit() error { if !d.isResolvedReference { if err := d.resolveReference(); err != nil { - return errors.Wrapf(err, "failed to resolve reference") + return internal.Wrapf(err, "failed to resolve reference") } } var buf bytes.Buffer if _, err := io.Copy(&buf, d.reader); err != nil { - return errors.Wrapf(err, "failed to copy from reader") + return internal.Wrapf(err, "failed to copy from reader") } file, err := d.parse(buf.Bytes()) if err != nil { - return errors.Wrapf(err, "failed to decode") + return internal.Wrapf(err, "failed to decode") } d.parsedFile = file return nil @@ -1685,7 +1686,7 @@ func (d *Decoder) decode(ctx context.Context, v reflect.Value) error { return nil } if err := d.decodeValue(ctx, v.Elem(), body); err != nil { - return errors.Wrapf(err, "failed to decode value") + return internal.Wrapf(err, "failed to decode value") } d.streamIndex++ return nil @@ -1705,25 +1706,25 @@ func (d *Decoder) Decode(v interface{}) error { func (d *Decoder) DecodeContext(ctx context.Context, v interface{}) error { rv := reflect.ValueOf(v) if rv.Type().Kind() != reflect.Ptr { - return errors.ErrDecodeRequiredPointerType + return internal.ErrDecodeRequiredPointerType } if d.isInitialized() { if err := d.decode(ctx, rv); err != nil { if err == io.EOF { return err } - return errors.Wrapf(err, "failed to decode") + return internal.Wrapf(err, "failed to decode") } return nil } if err := d.decodeInit(); err != nil { - return errors.Wrapf(err, "failed to decodeInit") + return internal.Wrapf(err, "failed to decodeInit") } if err := d.decode(ctx, rv); err != nil { if err == io.EOF { return err } - return errors.Wrapf(err, "failed to decode") + return internal.Wrapf(err, "failed to decode") } return nil } @@ -1737,17 +1738,17 @@ func (d *Decoder) DecodeFromNode(node ast.Node, v interface{}) error { func (d *Decoder) DecodeFromNodeContext(ctx context.Context, node ast.Node, v interface{}) error { rv := reflect.ValueOf(v) if rv.Type().Kind() != reflect.Ptr { - return errors.ErrDecodeRequiredPointerType + return internal.ErrDecodeRequiredPointerType } if !d.isInitialized() { if err := d.decodeInit(); err != nil { - return errors.Wrapf(err, "failed to decodInit") + return internal.Wrapf(err, "failed to decodInit") } } // resolve references to the anchor on the same file d.nodeToValue(node) if err := d.decodeValue(ctx, rv.Elem(), node); err != nil { - return errors.Wrapf(err, "failed to decode value") + return internal.Wrapf(err, "failed to decode value") } return nil } diff --git a/decode_test.go b/decode_test.go index 2373804d..b748eac0 100644 --- a/decode_test.go +++ b/decode_test.go @@ -3,6 +3,7 @@ package yaml_test import ( "bytes" "context" + "errors" "fmt" "io" "log" @@ -16,7 +17,7 @@ import ( "github.com/goccy/go-yaml" "github.com/goccy/go-yaml/ast" - "github.com/goccy/go-yaml/internal/errors" + "github.com/goccy/go-yaml/internal" "github.com/goccy/go-yaml/parser" "golang.org/x/xerrors" ) @@ -2008,7 +2009,7 @@ map: &map var buf bytes.Buffer var v bool err := yaml.NewDecoder(&buf).DecodeFromNode(nil, v) - if !xerrors.Is(err, errors.ErrDecodeRequiredPointerType) { + if !errors.Is(err, internal.ErrDecodeRequiredPointerType) { t.Fatalf("unexpected error: %s", err) } }) diff --git a/encode.go b/encode.go index 3b9b2981..edaddcb8 100644 --- a/encode.go +++ b/encode.go @@ -13,7 +13,7 @@ import ( "time" "github.com/goccy/go-yaml/ast" - "github.com/goccy/go-yaml/internal/errors" + "github.com/goccy/go-yaml/internal" "github.com/goccy/go-yaml/parser" "github.com/goccy/go-yaml/printer" "github.com/goccy/go-yaml/token" @@ -84,10 +84,10 @@ func (e *Encoder) Encode(v interface{}) error { func (e *Encoder) EncodeContext(ctx context.Context, v interface{}) error { node, err := e.EncodeToNodeContext(ctx, v) if err != nil { - return errors.Wrapf(err, "failed to encode to node") + return internal.Wrapf(err, "failed to encode to node") } if err := e.setCommentByCommentMap(node); err != nil { - return errors.Wrapf(err, "failed to set comment by comment map") + return internal.Wrapf(err, "failed to set comment by comment map") } if !e.written { e.written = true @@ -109,12 +109,12 @@ func (e *Encoder) EncodeToNode(v interface{}) (ast.Node, error) { func (e *Encoder) EncodeToNodeContext(ctx context.Context, v interface{}) (ast.Node, error) { for _, opt := range e.opts { if err := opt(e); err != nil { - return nil, errors.Wrapf(err, "failed to run option for encoder") + return nil, internal.Wrapf(err, "failed to run option for encoder") } } node, err := e.encodeValue(ctx, reflect.ValueOf(v), 1) if err != nil { - return nil, errors.Wrapf(err, "failed to encode value") + return nil, internal.Wrapf(err, "failed to encode value") } return node, nil } @@ -126,7 +126,7 @@ func (e *Encoder) setCommentByCommentMap(node ast.Node) error { for path, comments := range e.commentMap { n, err := path.FilterNode(node) if err != nil { - return errors.Wrapf(err, "failed to filter node") + return internal.Wrapf(err, "failed to filter node") } if n == nil { continue @@ -140,15 +140,15 @@ func (e *Encoder) setCommentByCommentMap(node ast.Node) error { switch comment.Position { case CommentHeadPosition: if err := e.setHeadComment(node, n, commentGroup); err != nil { - return errors.Wrapf(err, "failed to set head comment") + return internal.Wrapf(err, "failed to set head comment") } case CommentLinePosition: if err := e.setLineComment(node, n, commentGroup); err != nil { - return errors.Wrapf(err, "failed to set line comment") + return internal.Wrapf(err, "failed to set line comment") } case CommentFootPosition: if err := e.setFootComment(node, n, commentGroup); err != nil { - return errors.Wrapf(err, "failed to set foot comment") + return internal.Wrapf(err, "failed to set foot comment") } default: return ErrUnknownCommentPositionType @@ -166,11 +166,11 @@ func (e *Encoder) setHeadComment(node ast.Node, filtered ast.Node, comment *ast. switch p := parent.(type) { case *ast.MappingValueNode: if err := p.SetComment(comment); err != nil { - return errors.Wrapf(err, "failed to set comment") + return internal.Wrapf(err, "failed to set comment") } case *ast.MappingNode: if err := p.SetComment(comment); err != nil { - return errors.Wrapf(err, "failed to set comment") + return internal.Wrapf(err, "failed to set comment") } case *ast.SequenceNode: if len(p.ValueHeadComments) == 0 { @@ -196,11 +196,11 @@ func (e *Encoder) setLineComment(node ast.Node, filtered ast.Node, comment *ast. // Line comment cannot be set for mapping value node. // It should probably be set for the parent map node if err := e.setLineCommentToParentMapNode(node, filtered, comment); err != nil { - return errors.Wrapf(err, "failed to set line comment to parent node") + return internal.Wrapf(err, "failed to set line comment to parent node") } default: if err := filtered.SetComment(comment); err != nil { - return errors.Wrapf(err, "failed to set comment") + return internal.Wrapf(err, "failed to set comment") } } return nil @@ -214,11 +214,11 @@ func (e *Encoder) setLineCommentToParentMapNode(node ast.Node, filtered ast.Node switch p := parent.(type) { case *ast.MappingValueNode: if err := p.Key.SetComment(comment); err != nil { - return errors.Wrapf(err, "failed to set comment") + return internal.Wrapf(err, "failed to set comment") } case *ast.MappingNode: if err := p.SetComment(comment); err != nil { - return errors.Wrapf(err, "failed to set comment") + return internal.Wrapf(err, "failed to set comment") } default: return ErrUnsupportedLinePositionType(parent) @@ -247,7 +247,7 @@ func (e *Encoder) setFootComment(node ast.Node, filtered ast.Node, comment *ast. func (e *Encoder) encodeDocument(doc []byte) (ast.Node, error) { f, err := parser.ParseBytes(doc, 0) if err != nil { - return nil, errors.Wrapf(err, "failed to parse yaml") + return nil, internal.Wrapf(err, "failed to parse yaml") } for _, docNode := range f.Docs { if docNode.Body != nil { @@ -336,11 +336,11 @@ func (e *Encoder) encodeByMarshaler(ctx context.Context, v reflect.Value, column if marshaler, exists := e.marshalerFromCustomMarshalerMap(v.Type()); exists { doc, err := marshaler(iface) if err != nil { - return nil, errors.Wrapf(err, "failed to MarshalYAML") + return nil, internal.Wrapf(err, "failed to MarshalYAML") } node, err := e.encodeDocument(doc) if err != nil { - return nil, errors.Wrapf(err, "failed to encode document") + return nil, internal.Wrapf(err, "failed to encode document") } return node, nil } @@ -348,11 +348,11 @@ func (e *Encoder) encodeByMarshaler(ctx context.Context, v reflect.Value, column if marshaler, ok := iface.(BytesMarshalerContext); ok { doc, err := marshaler.MarshalYAML(ctx) if err != nil { - return nil, errors.Wrapf(err, "failed to MarshalYAML") + return nil, internal.Wrapf(err, "failed to MarshalYAML") } node, err := e.encodeDocument(doc) if err != nil { - return nil, errors.Wrapf(err, "failed to encode document") + return nil, internal.Wrapf(err, "failed to encode document") } return node, nil } @@ -360,11 +360,11 @@ func (e *Encoder) encodeByMarshaler(ctx context.Context, v reflect.Value, column if marshaler, ok := iface.(BytesMarshaler); ok { doc, err := marshaler.MarshalYAML() if err != nil { - return nil, errors.Wrapf(err, "failed to MarshalYAML") + return nil, internal.Wrapf(err, "failed to MarshalYAML") } node, err := e.encodeDocument(doc) if err != nil { - return nil, errors.Wrapf(err, "failed to encode document") + return nil, internal.Wrapf(err, "failed to encode document") } return node, nil } @@ -372,7 +372,7 @@ func (e *Encoder) encodeByMarshaler(ctx context.Context, v reflect.Value, column if marshaler, ok := iface.(InterfaceMarshalerContext); ok { marshalV, err := marshaler.MarshalYAML(ctx) if err != nil { - return nil, errors.Wrapf(err, "failed to MarshalYAML") + return nil, internal.Wrapf(err, "failed to MarshalYAML") } return e.encodeValue(ctx, reflect.ValueOf(marshalV), column) } @@ -380,7 +380,7 @@ func (e *Encoder) encodeByMarshaler(ctx context.Context, v reflect.Value, column if marshaler, ok := iface.(InterfaceMarshaler); ok { marshalV, err := marshaler.MarshalYAML() if err != nil { - return nil, errors.Wrapf(err, "failed to MarshalYAML") + return nil, internal.Wrapf(err, "failed to MarshalYAML") } return e.encodeValue(ctx, reflect.ValueOf(marshalV), column) } @@ -396,11 +396,11 @@ func (e *Encoder) encodeByMarshaler(ctx context.Context, v reflect.Value, column if marshaler, ok := iface.(encoding.TextMarshaler); ok { doc, err := marshaler.MarshalText() if err != nil { - return nil, errors.Wrapf(err, "failed to MarshalText") + return nil, internal.Wrapf(err, "failed to MarshalText") } node, err := e.encodeDocument(doc) if err != nil { - return nil, errors.Wrapf(err, "failed to encode document") + return nil, internal.Wrapf(err, "failed to encode document") } return node, nil } @@ -409,15 +409,15 @@ func (e *Encoder) encodeByMarshaler(ctx context.Context, v reflect.Value, column if marshaler, ok := iface.(jsonMarshaler); ok { jsonBytes, err := marshaler.MarshalJSON() if err != nil { - return nil, errors.Wrapf(err, "failed to MarshalJSON") + return nil, internal.Wrapf(err, "failed to MarshalJSON") } doc, err := JSONToYAML(jsonBytes) if err != nil { - return nil, errors.Wrapf(err, "failed to convert json to yaml") + return nil, internal.Wrapf(err, "failed to convert json to yaml") } node, err := e.encodeDocument(doc) if err != nil { - return nil, errors.Wrapf(err, "failed to encode document") + return nil, internal.Wrapf(err, "failed to encode document") } return node, nil } @@ -433,7 +433,7 @@ func (e *Encoder) encodeValue(ctx context.Context, v reflect.Value, column int) if e.canEncodeByMarshaler(v) { node, err := e.encodeByMarshaler(ctx, v, column) if err != nil { - return nil, errors.Wrapf(err, "failed to encode by marshaler") + return nil, internal.Wrapf(err, "failed to encode by marshaler") } return node, nil } @@ -570,7 +570,7 @@ func (e *Encoder) encodeSlice(ctx context.Context, value reflect.Value) (*ast.Se for i := 0; i < value.Len(); i++ { node, err := e.encodeValue(ctx, value.Index(i), column) if err != nil { - return nil, errors.Wrapf(err, "failed to encode value for slice") + return nil, internal.Wrapf(err, "failed to encode value for slice") } sequence.Values = append(sequence.Values, node) } @@ -589,7 +589,7 @@ func (e *Encoder) encodeArray(ctx context.Context, value reflect.Value) (*ast.Se for i := 0; i < value.Len(); i++ { node, err := e.encodeValue(ctx, value.Index(i), column) if err != nil { - return nil, errors.Wrapf(err, "failed to encode value for array") + return nil, internal.Wrapf(err, "failed to encode value for array") } sequence.Values = append(sequence.Values, node) } @@ -604,7 +604,7 @@ func (e *Encoder) encodeMapItem(ctx context.Context, item MapItem, column int) ( v := reflect.ValueOf(item.Value) value, err := e.encodeValue(ctx, v, column) if err != nil { - return nil, errors.Wrapf(err, "failed to encode MapItem") + return nil, internal.Wrapf(err, "failed to encode MapItem") } if e.isMapNode(value) { value.AddColumn(e.indent) @@ -621,7 +621,7 @@ func (e *Encoder) encodeMapSlice(ctx context.Context, value MapSlice, column int for _, item := range value { value, err := e.encodeMapItem(ctx, item, column) if err != nil { - return nil, errors.Wrapf(err, "failed to encode MapItem for MapSlice") + return nil, internal.Wrapf(err, "failed to encode MapItem for MapSlice") } node.Values = append(node.Values, value) } @@ -730,7 +730,7 @@ func (e *Encoder) encodeAnchor(anchorName string, value ast.Node, fieldValue ref anchorNode.Value = value if e.anchorCallback != nil { if err := e.anchorCallback(anchorNode, fieldValue.Interface()); err != nil { - return nil, errors.Wrapf(err, "failed to marshal anchor") + return nil, internal.Wrapf(err, "failed to marshal anchor") } if snode, ok := anchorNode.Name.(*ast.StringNode); ok { anchorName = snode.Value @@ -747,7 +747,7 @@ func (e *Encoder) encodeStruct(ctx context.Context, value reflect.Value, column structType := value.Type() structFieldMap, err := structFieldMap(structType) if err != nil { - return nil, errors.Wrapf(err, "failed to get struct field map") + return nil, internal.Wrapf(err, "failed to get struct field map") } hasInlineAnchorField := false var inlineAnchorValue reflect.Value @@ -770,7 +770,7 @@ func (e *Encoder) encodeStruct(ctx context.Context, value reflect.Value, column } value, err := ve.encodeValue(ctx, fieldValue, column) if err != nil { - return nil, errors.Wrapf(err, "failed to encode value") + return nil, internal.Wrapf(err, "failed to encode value") } if e.isMapNode(value) { value.AddColumn(e.indent) @@ -780,7 +780,7 @@ func (e *Encoder) encodeStruct(ctx context.Context, value reflect.Value, column case structField.AnchorName != "": anchorNode, err := e.encodeAnchor(structField.AnchorName, value, fieldValue, column) if err != nil { - return nil, errors.Wrapf(err, "failed to encode anchor") + return nil, internal.Wrapf(err, "failed to encode anchor") } value = anchorNode case structField.IsAutoAlias: @@ -846,7 +846,7 @@ func (e *Encoder) encodeStruct(ctx context.Context, value reflect.Value, column case structField.IsAutoAnchor: anchorNode, err := e.encodeAnchor(structField.RenderName, value, fieldValue, column) if err != nil { - return nil, errors.Wrapf(err, "failed to encode anchor") + return nil, internal.Wrapf(err, "failed to encode anchor") } value = anchorNode } @@ -860,7 +860,7 @@ func (e *Encoder) encodeStruct(ctx context.Context, value reflect.Value, column anchorNode.Value = node if e.anchorCallback != nil { if err := e.anchorCallback(anchorNode, value.Addr().Interface()); err != nil { - return nil, errors.Wrapf(err, "failed to marshal anchor") + return nil, internal.Wrapf(err, "failed to marshal anchor") } if snode, ok := anchorNode.Name.(*ast.StringNode); ok { anchorName = snode.Value diff --git a/error.go b/error.go index 163dcc55..7d28a41b 100644 --- a/error.go +++ b/error.go @@ -1,6 +1,8 @@ package yaml import ( + "errors" + "github.com/goccy/go-yaml/ast" "golang.org/x/xerrors" ) @@ -28,35 +30,35 @@ func ErrUnsupportedFootPositionType(node ast.Node) error { // IsInvalidQueryError whether err is ErrInvalidQuery or not. func IsInvalidQueryError(err error) bool { - return xerrors.Is(err, ErrInvalidQuery) + return errors.Is(err, ErrInvalidQuery) } // IsInvalidPathError whether err is ErrInvalidPath or not. func IsInvalidPathError(err error) bool { - return xerrors.Is(err, ErrInvalidPath) + return errors.Is(err, ErrInvalidPath) } // IsInvalidPathStringError whether err is ErrInvalidPathString or not. func IsInvalidPathStringError(err error) bool { - return xerrors.Is(err, ErrInvalidPathString) + return errors.Is(err, ErrInvalidPathString) } // IsNotFoundNodeError whether err is ErrNotFoundNode or not. func IsNotFoundNodeError(err error) bool { - return xerrors.Is(err, ErrNotFoundNode) + return errors.Is(err, ErrNotFoundNode) } // IsInvalidTokenTypeError whether err is ast.ErrInvalidTokenType or not. func IsInvalidTokenTypeError(err error) bool { - return xerrors.Is(err, ast.ErrInvalidTokenType) + return errors.Is(err, ast.ErrInvalidTokenType) } // IsInvalidAnchorNameError whether err is ast.ErrInvalidAnchorName or not. func IsInvalidAnchorNameError(err error) bool { - return xerrors.Is(err, ast.ErrInvalidAnchorName) + return errors.Is(err, ast.ErrInvalidAnchorName) } // IsInvalidAliasNameError whether err is ast.ErrInvalidAliasName or not. func IsInvalidAliasNameError(err error) bool { - return xerrors.Is(err, ast.ErrInvalidAliasName) + return errors.Is(err, ast.ErrInvalidAliasName) } diff --git a/go.mod b/go.mod index 4550ff37..4aa89680 100644 --- a/go.mod +++ b/go.mod @@ -7,7 +7,7 @@ require ( github.com/go-playground/validator/v10 v10.4.1 github.com/google/go-cmp v0.5.9 github.com/mattn/go-colorable v0.1.8 - golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 + golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 ) require ( diff --git a/go.sum b/go.sum index 7249df6b..f70ff676 100644 --- a/go.sum +++ b/go.sum @@ -37,8 +37,8 @@ golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE= -golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 h1:H2TDz8ibqkAF6YGhCdN3jS9O0/s90v0rJh3X/OLHEUk= +golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw= gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= diff --git a/internal/errors/error.go b/internal/error.go similarity index 99% rename from internal/errors/error.go rename to internal/error.go index 7f1ea9af..01af7f1b 100644 --- a/internal/errors/error.go +++ b/internal/error.go @@ -1,7 +1,8 @@ -package errors +package internal import ( "bytes" + "errors" "fmt" "reflect" @@ -83,7 +84,7 @@ func (e *wrapError) As(target interface{}) bool { } break } - return xerrors.As(err, target) + return errors.As(err, target) } func (e *wrapError) Unwrap() error { diff --git a/parser/parser.go b/parser/parser.go index 13ada50f..d7bbe507 100644 --- a/parser/parser.go +++ b/parser/parser.go @@ -6,7 +6,7 @@ import ( "strings" "github.com/goccy/go-yaml/ast" - "github.com/goccy/go-yaml/internal/errors" + "github.com/goccy/go-yaml/internal" "github.com/goccy/go-yaml/lexer" "github.com/goccy/go-yaml/token" "golang.org/x/xerrors" @@ -31,16 +31,16 @@ func (p *parser) parseMapping(ctx *context) (*ast.MappingNode, error) { value, err := p.parseMappingValue(ctx) if err != nil { - return nil, errors.Wrapf(err, "failed to parse mapping value in mapping node") + return nil, internal.Wrapf(err, "failed to parse mapping value in mapping node") } mvnode, ok := value.(*ast.MappingValueNode) if !ok { - return nil, errors.ErrSyntax("failed to parse flow mapping node", value.GetToken()) + return nil, internal.ErrSyntax("failed to parse flow mapping node", value.GetToken()) } node.Values = append(node.Values, mvnode) ctx.progress(1) } - return nil, errors.ErrSyntax("unterminated flow mapping", node.GetToken()) + return nil, internal.ErrSyntax("unterminated flow mapping", node.GetToken()) } func (p *parser) parseSequence(ctx *context) (*ast.SequenceNode, error) { @@ -59,7 +59,7 @@ func (p *parser) parseSequence(ctx *context) (*ast.SequenceNode, error) { value, err := p.parseToken(ctx.withIndex(uint(len(node.Values))), tk) if err != nil { - return nil, errors.Wrapf(err, "failed to parse sequence value in flow sequence node") + return nil, internal.Wrapf(err, "failed to parse sequence value in flow sequence node") } node.Values = append(node.Values, value) ctx.progress(1) @@ -94,13 +94,13 @@ func (p *parser) parseTag(ctx *context) (*ast.TagNode, error) { } case token.SequenceTag, token.SetTag: - err = errors.ErrSyntax(fmt.Sprintf("sorry, currently not supported %s tag", tagToken.Value), tagToken) + err = internal.ErrSyntax(fmt.Sprintf("sorry, currently not supported %s tag", tagToken.Value), tagToken) default: // custom tag value, err = p.parseToken(ctx, ctx.currentToken()) } if err != nil { - return nil, errors.Wrapf(err, "failed to parse tag value") + return nil, internal.Wrapf(err, "failed to parse tag value") } node.Value = value return node, nil @@ -127,7 +127,7 @@ func (p *parser) validateMapKey(tk *token.Token) error { } origin := p.removeLeftSideNewLineCharacter(tk.Origin) if p.existsNewLineCharacter(origin) { - return errors.ErrSyntax("unexpected key name", tk) + return internal.ErrSyntax("unexpected key name", tk) } return nil } @@ -141,7 +141,7 @@ func (p *parser) createNullToken(base *token.Token) *token.Token { func (p *parser) parseMapValue(ctx *context, key ast.MapKeyNode, colonToken *token.Token) (ast.Node, error) { node, err := p.createMapValueNode(ctx, key, colonToken) if err != nil { - return nil, errors.Wrapf(err, "failed to create map value node") + return nil, internal.Wrapf(err, "failed to create map value node") } if node != nil && node.GetPath() == "" { node.SetPath(ctx.path) @@ -206,7 +206,7 @@ func (p *parser) createMapValueNode(ctx *context, key ast.MapKeyNode, colonToken value, err := p.parseToken(ctx, ctx.currentToken()) if err != nil { - return nil, errors.Wrapf(err, "failed to parse mapping 'value' node") + return nil, internal.Wrapf(err, "failed to parse mapping 'value' node") } if comment != nil { value.SetComment(comment) @@ -225,7 +225,7 @@ func (p *parser) validateMapValue(ctx *context, key, value ast.Node) error { } ntk := ctx.nextToken() if ntk == nil || (ntk.Type != token.MappingValueType && ntk.Type != token.SequenceEntryType) { - return errors.ErrSyntax("could not found expected ':' token", value.GetToken()) + return internal.ErrSyntax("could not found expected ':' token", value.GetToken()) } return nil } @@ -233,21 +233,21 @@ func (p *parser) validateMapValue(ctx *context, key, value ast.Node) error { func (p *parser) parseMappingValue(ctx *context) (ast.Node, error) { key, err := p.parseMapKey(ctx) if err != nil { - return nil, errors.Wrapf(err, "failed to parse map key") + return nil, internal.Wrapf(err, "failed to parse map key") } keyText := key.GetToken().Value key.SetPath(ctx.withChild(keyText).path) if err := p.validateMapKey(key.GetToken()); err != nil { - return nil, errors.Wrapf(err, "validate mapping key error") + return nil, internal.Wrapf(err, "validate mapping key error") } ctx.progress(1) // progress to mapping value token tk := ctx.currentToken() // get mapping value token if tk == nil { - return nil, errors.ErrSyntax("unexpected map", key.GetToken()) + return nil, internal.ErrSyntax("unexpected map", key.GetToken()) } ctx.progress(1) // progress to value token if err := p.setSameLineCommentIfExists(ctx.withChild(keyText), key); err != nil { - return nil, errors.Wrapf(err, "failed to set same line comment to node") + return nil, internal.Wrapf(err, "failed to set same line comment to node") } if key.GetComment() != nil { // if current token is comment, GetComment() is not nil. @@ -257,10 +257,10 @@ func (p *parser) parseMappingValue(ctx *context) (ast.Node, error) { value, err := p.parseMapValue(ctx.withChild(keyText), key, tk) if err != nil { - return nil, errors.Wrapf(err, "failed to parse map value") + return nil, internal.Wrapf(err, "failed to parse map value") } if err := p.validateMapValue(ctx, key, value); err != nil { - return nil, errors.Wrapf(err, "failed to validate map value") + return nil, internal.Wrapf(err, "failed to validate map value") } mvnode := ast.MappingValue(tk, key, value) @@ -275,7 +275,7 @@ func (p *parser) parseMappingValue(ctx *context) (ast.Node, error) { ctx.progressIgnoreComment(1) value, err := p.parseToken(ctx, ctx.currentToken()) if err != nil { - return nil, errors.Wrapf(err, "failed to parse mapping node") + return nil, internal.Wrapf(err, "failed to parse mapping node") } switch value.Type() { case ast.MappingType: @@ -284,7 +284,7 @@ func (p *parser) parseMappingValue(ctx *context) (ast.Node, error) { for idx, v := range c.Values { if idx == 0 && comment != nil { if err := v.SetComment(comment); err != nil { - return nil, errors.Wrapf(err, "failed to set comment token to node") + return nil, internal.Wrapf(err, "failed to set comment token to node") } } node.Values = append(node.Values, v) @@ -328,7 +328,7 @@ func (p *parser) parseSequenceEntry(ctx *context) (*ast.SequenceNode, error) { ctx.progress(1) // skip sequence token tk = ctx.currentToken() if tk == nil { - return nil, errors.ErrSyntax("empty sequence entry", ctx.previousToken()) + return nil, internal.ErrSyntax("empty sequence entry", ctx.previousToken()) } var comment *ast.CommentGroupNode if tk.Type == token.CommentType { @@ -340,7 +340,7 @@ func (p *parser) parseSequenceEntry(ctx *context) (*ast.SequenceNode, error) { } value, err := p.parseToken(ctx.withIndex(uint(len(sequenceNode.Values))), ctx.currentToken()) if err != nil { - return nil, errors.Wrapf(err, "failed to parse sequence") + return nil, internal.Wrapf(err, "failed to parse sequence") } if comment != nil { comment.SetPath(ctx.withIndex(uint(len(sequenceNode.Values))).path) @@ -377,22 +377,22 @@ func (p *parser) parseAnchor(ctx *context) (*ast.AnchorNode, error) { anchor.SetPath(ctx.path) ntk := ctx.nextToken() if ntk == nil { - return nil, errors.ErrSyntax("unexpected anchor. anchor name is undefined", tk) + return nil, internal.ErrSyntax("unexpected anchor. anchor name is undefined", tk) } ctx.progress(1) // skip anchor token name, err := p.parseToken(ctx, ctx.currentToken()) if err != nil { - return nil, errors.Wrapf(err, "failed to parser anchor name node") + return nil, internal.Wrapf(err, "failed to parser anchor name node") } anchor.Name = name ntk = ctx.nextToken() if ntk == nil { - return nil, errors.ErrSyntax("unexpected anchor. anchor value is undefined", ctx.currentToken()) + return nil, internal.ErrSyntax("unexpected anchor. anchor value is undefined", ctx.currentToken()) } ctx.progress(1) value, err := p.parseToken(ctx, ctx.currentToken()) if err != nil { - return nil, errors.Wrapf(err, "failed to parser anchor name node") + return nil, internal.Wrapf(err, "failed to parser anchor name node") } anchor.Value = value return anchor, nil @@ -404,12 +404,12 @@ func (p *parser) parseAlias(ctx *context) (*ast.AliasNode, error) { alias.SetPath(ctx.path) ntk := ctx.nextToken() if ntk == nil { - return nil, errors.ErrSyntax("unexpected alias. alias name is undefined", tk) + return nil, internal.ErrSyntax("unexpected alias. alias name is undefined", tk) } ctx.progress(1) // skip alias token name, err := p.parseToken(ctx, ctx.currentToken()) if err != nil { - return nil, errors.Wrapf(err, "failed to parser alias name node") + return nil, internal.Wrapf(err, "failed to parser alias name node") } alias.Value = name return alias, nil @@ -426,7 +426,7 @@ func (p *parser) parseMapKey(ctx *context) (ast.MapKeyNode, error) { case token.MappingKeyType: return p.parseMappingKey(ctx) } - return nil, errors.ErrSyntax("unexpected mapping key", tk) + return nil, internal.ErrSyntax("unexpected mapping key", tk) } func (p *parser) parseStringValue(tk *token.Token) *ast.StringNode { @@ -448,7 +448,7 @@ func (p *parser) parseScalarValueWithComment(ctx *context, tk *token.Token) (ast if p.isSameLineComment(ctx.nextToken(), node) { ctx.progress(1) if err := p.setSameLineCommentIfExists(ctx, node); err != nil { - return nil, errors.Wrapf(err, "failed to set same line comment to node") + return nil, internal.Wrapf(err, "failed to set same line comment to node") } } return node, nil @@ -483,7 +483,7 @@ func (p *parser) parseDirective(ctx *context) (*ast.DirectiveNode, error) { ctx.progress(1) // skip directive token value, err := p.parseToken(ctx, ctx.currentToken()) if err != nil { - return nil, errors.Wrapf(err, "failed to parse directive value") + return nil, internal.Wrapf(err, "failed to parse directive value") } node.Value = value ctx.progress(1) @@ -491,10 +491,10 @@ func (p *parser) parseDirective(ctx *context) (*ast.DirectiveNode, error) { if tk == nil { // Since current token is nil, use the previous token to specify // the syntax error location. - return nil, errors.ErrSyntax("unexpected directive value. document not started", ctx.previousToken()) + return nil, internal.ErrSyntax("unexpected directive value. document not started", ctx.previousToken()) } if tk.Type != token.DocumentHeaderType { - return nil, errors.ErrSyntax("unexpected directive value. document not started", ctx.currentToken()) + return nil, internal.ErrSyntax("unexpected directive value. document not started", ctx.currentToken()) } return node, nil } @@ -509,17 +509,17 @@ func (p *parser) parseLiteral(ctx *context) (*ast.LiteralNode, error) { comment = p.parseCommentOnly(ctx) comment.SetPath(ctx.path) if err := node.SetComment(comment); err != nil { - return nil, errors.Wrapf(err, "failed to set comment to literal") + return nil, internal.Wrapf(err, "failed to set comment to literal") } tk = ctx.currentToken() } value, err := p.parseToken(ctx, tk) if err != nil { - return nil, errors.Wrapf(err, "failed to parse literal/folded value") + return nil, internal.Wrapf(err, "failed to parse literal/folded value") } snode, ok := value.(*ast.StringNode) if !ok { - return nil, errors.ErrSyntax("unexpected token. required string token", value.GetToken()) + return nil, internal.ErrSyntax("unexpected token. required string token", value.GetToken()) } node.Value = snode return node, nil @@ -543,7 +543,7 @@ func (p *parser) setSameLineCommentIfExists(ctx *context, node ast.Node) error { comment := ast.CommentGroup([]*token.Token{tk}) comment.SetPath(ctx.path) if err := node.SetComment(comment); err != nil { - return errors.Wrapf(err, "failed to set comment token to ast.Node") + return internal.Wrapf(err, "failed to set comment token to ast.Node") } return nil } @@ -553,7 +553,7 @@ func (p *parser) parseDocument(ctx *context) (*ast.DocumentNode, error) { ctx.progress(1) // skip document header token body, err := p.parseToken(ctx, ctx.currentToken()) if err != nil { - return nil, errors.Wrapf(err, "failed to parse document body") + return nil, internal.Wrapf(err, "failed to parse document body") } node := ast.Document(startTk, body) if ntk := ctx.nextToken(); ntk != nil && ntk.Type == token.DocumentEndType { @@ -603,14 +603,14 @@ func (p *parser) parseComment(ctx *context) (ast.Node, error) { group := p.parseCommentOnly(ctx) node, err := p.parseToken(ctx, ctx.currentToken()) if err != nil { - return nil, errors.Wrapf(err, "failed to parse node after comment") + return nil, internal.Wrapf(err, "failed to parse node after comment") } if node == nil { return group, nil } group.SetPath(node.GetPath()) if err := node.SetComment(group); err != nil { - return nil, errors.Wrapf(err, "failed to set comment token to node") + return nil, internal.Wrapf(err, "failed to set comment token to node") } return node, nil } @@ -622,7 +622,7 @@ func (p *parser) parseMappingKey(ctx *context) (*ast.MappingKeyNode, error) { ctx.progress(1) // skip mapping key token value, err := p.parseToken(ctx.withChild(keyTk.Value), ctx.currentToken()) if err != nil { - return nil, errors.Wrapf(err, "failed to parse map key") + return nil, internal.Wrapf(err, "failed to parse map key") } node.Value = value return node, nil @@ -631,7 +631,7 @@ func (p *parser) parseMappingKey(ctx *context) (*ast.MappingKeyNode, error) { func (p *parser) parseToken(ctx *context, tk *token.Token) (ast.Node, error) { node, err := p.createNodeFromToken(ctx, tk) if err != nil { - return nil, errors.Wrapf(err, "failed to create node from token") + return nil, internal.Wrapf(err, "failed to create node from token") } if node != nil && node.GetPath() == "" { node.SetPath(ctx.path) @@ -649,7 +649,7 @@ func (p *parser) createNodeFromToken(ctx *context, tk *token.Token) (ast.Node, e } node, err := p.parseScalarValueWithComment(ctx, tk) if err != nil { - return nil, errors.Wrapf(err, "failed to parse scalar value") + return nil, internal.Wrapf(err, "failed to parse scalar value") } if node != nil { return node, nil @@ -687,7 +687,7 @@ func (p *parser) parse(tokens token.Tokens, mode Mode) (*ast.File, error) { for ctx.next() { node, err := p.parseToken(ctx, ctx.currentToken()) if err != nil { - return nil, errors.Wrapf(err, "failed to parse") + return nil, internal.Wrapf(err, "failed to parse") } ctx.progressIgnoreComment(1) if node == nil { @@ -713,7 +713,7 @@ func ParseBytes(bytes []byte, mode Mode) (*ast.File, error) { tokens := lexer.Tokenize(string(bytes)) f, err := Parse(tokens, mode) if err != nil { - return nil, errors.Wrapf(err, "failed to parse") + return nil, internal.Wrapf(err, "failed to parse") } return f, nil } @@ -723,7 +723,7 @@ func Parse(tokens token.Tokens, mode Mode) (*ast.File, error) { var p parser f, err := p.parse(tokens, mode) if err != nil { - return nil, errors.Wrapf(err, "failed to parse") + return nil, internal.Wrapf(err, "failed to parse") } return f, nil } @@ -732,11 +732,11 @@ func Parse(tokens token.Tokens, mode Mode) (*ast.File, error) { func ParseFile(filename string, mode Mode) (*ast.File, error) { file, err := ioutil.ReadFile(filename) if err != nil { - return nil, errors.Wrapf(err, "failed to read file: %s", filename) + return nil, internal.Wrapf(err, "failed to read file: %s", filename) } f, err := ParseBytes(file, mode) if err != nil { - return nil, errors.Wrapf(err, "failed to parse") + return nil, internal.Wrapf(err, "failed to parse") } f.Name = filename return f, nil diff --git a/path.go b/path.go index 72554bd8..b93b7683 100644 --- a/path.go +++ b/path.go @@ -8,7 +8,7 @@ import ( "strings" "github.com/goccy/go-yaml/ast" - "github.com/goccy/go-yaml/internal/errors" + "github.com/goccy/go-yaml/internal" "github.com/goccy/go-yaml/parser" "github.com/goccy/go-yaml/printer" ) @@ -39,7 +39,7 @@ func PathString(s string) (*Path, error) { case '.': b, buf, c, err := parsePathDot(builder, buf, cursor) if err != nil { - return nil, errors.Wrapf(err, "failed to parse path of dot") + return nil, internal.Wrapf(err, "failed to parse path of dot") } length = len(buf) builder = b @@ -47,13 +47,13 @@ func PathString(s string) (*Path, error) { case '[': b, buf, c, err := parsePathIndex(builder, buf, cursor) if err != nil { - return nil, errors.Wrapf(err, "failed to parse path of index") + return nil, internal.Wrapf(err, "failed to parse path of index") } length = len(buf) builder = b cursor = c default: - return nil, errors.Wrapf(ErrInvalidPathString, "invalid path at %d", cursor) + return nil, internal.Wrapf(ErrInvalidPathString, "invalid path at %d", cursor) } } return builder.Build(), nil @@ -67,18 +67,18 @@ func parsePathRecursive(b *PathBuilder, buf []rune, cursor int) (*PathBuilder, [ c := buf[cursor] switch c { case '$': - return nil, nil, 0, errors.Wrapf(ErrInvalidPathString, "specified '$' after '..' character") + return nil, nil, 0, internal.Wrapf(ErrInvalidPathString, "specified '$' after '..' character") case '*': - return nil, nil, 0, errors.Wrapf(ErrInvalidPathString, "specified '*' after '..' character") + return nil, nil, 0, internal.Wrapf(ErrInvalidPathString, "specified '*' after '..' character") case '.', '[': goto end case ']': - return nil, nil, 0, errors.Wrapf(ErrInvalidPathString, "specified ']' after '..' character") + return nil, nil, 0, internal.Wrapf(ErrInvalidPathString, "specified ']' after '..' character") } } end: if start == cursor { - return nil, nil, 0, errors.Wrapf(ErrInvalidPathString, "not found recursive selector") + return nil, nil, 0, internal.Wrapf(ErrInvalidPathString, "not found recursive selector") } return b.Recursive(string(buf[start:cursor])), buf, cursor, nil } @@ -88,7 +88,7 @@ func parsePathDot(b *PathBuilder, buf []rune, cursor int) (*PathBuilder, []rune, if cursor+1 < length && buf[cursor+1] == '.' { b, buf, c, err := parsePathRecursive(b, buf, cursor) if err != nil { - return nil, nil, 0, errors.Wrapf(err, "failed to parse path of recursive") + return nil, nil, 0, internal.Wrapf(err, "failed to parse path of recursive") } return b, buf, c, nil } @@ -103,18 +103,18 @@ func parsePathDot(b *PathBuilder, buf []rune, cursor int) (*PathBuilder, []rune, c := buf[cursor] switch c { case '$': - return nil, nil, 0, errors.Wrapf(ErrInvalidPathString, "specified '$' after '.' character") + return nil, nil, 0, internal.Wrapf(ErrInvalidPathString, "specified '$' after '.' character") case '*': - return nil, nil, 0, errors.Wrapf(ErrInvalidPathString, "specified '*' after '.' character") + return nil, nil, 0, internal.Wrapf(ErrInvalidPathString, "specified '*' after '.' character") case '.', '[': goto end case ']': - return nil, nil, 0, errors.Wrapf(ErrInvalidPathString, "specified ']' after '.' character") + return nil, nil, 0, internal.Wrapf(ErrInvalidPathString, "specified ']' after '.' character") } } end: if start == cursor { - return nil, nil, 0, errors.Wrapf(ErrInvalidPathString, "cloud not find by empty key") + return nil, nil, 0, internal.Wrapf(ErrInvalidPathString, "cloud not find by empty key") } return b.child(string(buf[start:cursor])), buf, cursor, nil } @@ -136,21 +136,21 @@ func parseQuotedKey(b *PathBuilder, buf []rune, cursor int) (*PathBuilder, []run } end: if !foundEndDelim { - return nil, nil, 0, errors.Wrapf(ErrInvalidPathString, "could not find end delimiter for key") + return nil, nil, 0, internal.Wrapf(ErrInvalidPathString, "could not find end delimiter for key") } if start == cursor { - return nil, nil, 0, errors.Wrapf(ErrInvalidPathString, "could not find by empty key") + return nil, nil, 0, internal.Wrapf(ErrInvalidPathString, "could not find by empty key") } selector := buf[start:cursor] cursor++ if cursor < length { switch buf[cursor] { case '$': - return nil, nil, 0, errors.Wrapf(ErrInvalidPathString, "specified '$' after '.' character") + return nil, nil, 0, internal.Wrapf(ErrInvalidPathString, "specified '$' after '.' character") case '*': - return nil, nil, 0, errors.Wrapf(ErrInvalidPathString, "specified '*' after '.' character") + return nil, nil, 0, internal.Wrapf(ErrInvalidPathString, "specified '*' after '.' character") case ']': - return nil, nil, 0, errors.Wrapf(ErrInvalidPathString, "specified ']' after '.' character") + return nil, nil, 0, internal.Wrapf(ErrInvalidPathString, "specified ']' after '.' character") } } return b.child(string(selector)), buf, cursor, nil @@ -160,7 +160,7 @@ func parsePathIndex(b *PathBuilder, buf []rune, cursor int) (*PathBuilder, []run length := len(buf) cursor++ // skip '[' character if length <= cursor { - return nil, nil, 0, errors.Wrapf(ErrInvalidPathString, "unexpected end of YAML Path") + return nil, nil, 0, internal.Wrapf(ErrInvalidPathString, "unexpected end of YAML Path") } c := buf[cursor] switch c { @@ -176,7 +176,7 @@ func parsePathIndex(b *PathBuilder, buf []rune, cursor int) (*PathBuilder, []run break } if buf[cursor] != ']' { - return nil, nil, 0, errors.Wrapf(ErrInvalidPathString, "invalid character %s at %d", string(buf[cursor]), cursor) + return nil, nil, 0, internal.Wrapf(ErrInvalidPathString, "invalid character %s at %d", string(buf[cursor]), cursor) } numOrAll := string(buf[start:cursor]) if numOrAll == "*" { @@ -184,11 +184,11 @@ func parsePathIndex(b *PathBuilder, buf []rune, cursor int) (*PathBuilder, []run } num, err := strconv.ParseInt(numOrAll, 10, 64) if err != nil { - return nil, nil, 0, errors.Wrapf(err, "failed to parse number") + return nil, nil, 0, internal.Wrapf(err, "failed to parse number") } return b.Index(uint(num)), buf, cursor + 1, nil } - return nil, nil, 0, errors.Wrapf(ErrInvalidPathString, "invalid character %s at %d", c, cursor) + return nil, nil, 0, internal.Wrapf(ErrInvalidPathString, "invalid character %s at %d", c, cursor) } // Path represent YAMLPath ( like a JSONPath ). @@ -205,10 +205,10 @@ func (p *Path) String() string { func (p *Path) Read(r io.Reader, v interface{}) error { node, err := p.ReadNode(r) if err != nil { - return errors.Wrapf(err, "failed to read node") + return internal.Wrapf(err, "failed to read node") } if err := Unmarshal([]byte(node.String()), v); err != nil { - return errors.Wrapf(err, "failed to unmarshal") + return internal.Wrapf(err, "failed to unmarshal") } return nil } @@ -220,15 +220,15 @@ func (p *Path) ReadNode(r io.Reader) (ast.Node, error) { } var buf bytes.Buffer if _, err := io.Copy(&buf, r); err != nil { - return nil, errors.Wrapf(err, "failed to copy from reader") + return nil, internal.Wrapf(err, "failed to copy from reader") } f, err := parser.ParseBytes(buf.Bytes(), 0) if err != nil { - return nil, errors.Wrapf(err, "failed to parse yaml") + return nil, internal.Wrapf(err, "failed to parse yaml") } node, err := p.FilterFile(f) if err != nil { - return nil, errors.Wrapf(err, "failed to filter from ast.File") + return nil, internal.Wrapf(err, "failed to filter from ast.File") } return node, nil } @@ -237,10 +237,10 @@ func (p *Path) ReadNode(r io.Reader) (ast.Node, error) { func (p *Path) Filter(target, v interface{}) error { b, err := Marshal(target) if err != nil { - return errors.Wrapf(err, "failed to marshal target value") + return internal.Wrapf(err, "failed to marshal target value") } if err := p.Read(bytes.NewBuffer(b), v); err != nil { - return errors.Wrapf(err, "failed to read") + return internal.Wrapf(err, "failed to read") } return nil } @@ -250,20 +250,20 @@ func (p *Path) FilterFile(f *ast.File) (ast.Node, error) { for _, doc := range f.Docs { node, err := p.FilterNode(doc.Body) if err != nil { - return nil, errors.Wrapf(err, "failed to filter node by path ( %s )", p.node) + return nil, internal.Wrapf(err, "failed to filter node by path ( %s )", p.node) } if node != nil { return node, nil } } - return nil, errors.Wrapf(ErrNotFoundNode, "failed to find path ( %s )", p.node) + return nil, internal.Wrapf(ErrNotFoundNode, "failed to find path ( %s )", p.node) } // FilterNode filter from node by YAMLPath. func (p *Path) FilterNode(node ast.Node) (ast.Node, error) { n, err := p.node.filter(node) if err != nil { - return nil, errors.Wrapf(err, "failed to filter node by path ( %s )", p.node) + return nil, internal.Wrapf(err, "failed to filter node by path ( %s )", p.node) } return n, nil } @@ -272,14 +272,14 @@ func (p *Path) FilterNode(node ast.Node) (ast.Node, error) { func (p *Path) MergeFromReader(dst *ast.File, src io.Reader) error { var buf bytes.Buffer if _, err := io.Copy(&buf, src); err != nil { - return errors.Wrapf(err, "failed to copy from reader") + return internal.Wrapf(err, "failed to copy from reader") } file, err := parser.ParseBytes(buf.Bytes(), 0) if err != nil { - return errors.Wrapf(err, "failed to parse") + return internal.Wrapf(err, "failed to parse") } if err := p.MergeFromFile(dst, file); err != nil { - return errors.Wrapf(err, "failed to merge file") + return internal.Wrapf(err, "failed to merge file") } return nil } @@ -288,11 +288,11 @@ func (p *Path) MergeFromReader(dst *ast.File, src io.Reader) error { func (p *Path) MergeFromFile(dst *ast.File, src *ast.File) error { base, err := p.FilterFile(dst) if err != nil { - return errors.Wrapf(err, "failed to filter file") + return internal.Wrapf(err, "failed to filter file") } for _, doc := range src.Docs { if err := ast.Merge(base, doc); err != nil { - return errors.Wrapf(err, "failed to merge") + return internal.Wrapf(err, "failed to merge") } } return nil @@ -302,10 +302,10 @@ func (p *Path) MergeFromFile(dst *ast.File, src *ast.File) error { func (p *Path) MergeFromNode(dst *ast.File, src ast.Node) error { base, err := p.FilterFile(dst) if err != nil { - return errors.Wrapf(err, "failed to filter file") + return internal.Wrapf(err, "failed to filter file") } if err := ast.Merge(base, src); err != nil { - return errors.Wrapf(err, "failed to merge") + return internal.Wrapf(err, "failed to merge") } return nil } @@ -314,14 +314,14 @@ func (p *Path) MergeFromNode(dst *ast.File, src ast.Node) error { func (p *Path) ReplaceWithReader(dst *ast.File, src io.Reader) error { var buf bytes.Buffer if _, err := io.Copy(&buf, src); err != nil { - return errors.Wrapf(err, "failed to copy from reader") + return internal.Wrapf(err, "failed to copy from reader") } file, err := parser.ParseBytes(buf.Bytes(), 0) if err != nil { - return errors.Wrapf(err, "failed to parse") + return internal.Wrapf(err, "failed to parse") } if err := p.ReplaceWithFile(dst, file); err != nil { - return errors.Wrapf(err, "failed to replace file") + return internal.Wrapf(err, "failed to replace file") } return nil } @@ -330,7 +330,7 @@ func (p *Path) ReplaceWithReader(dst *ast.File, src io.Reader) error { func (p *Path) ReplaceWithFile(dst *ast.File, src *ast.File) error { for _, doc := range src.Docs { if err := p.ReplaceWithNode(dst, doc); err != nil { - return errors.Wrapf(err, "failed to replace file by path ( %s )", p.node) + return internal.Wrapf(err, "failed to replace file by path ( %s )", p.node) } } return nil @@ -343,7 +343,7 @@ func (p *Path) ReplaceWithNode(dst *ast.File, node ast.Node) error { node = node.(*ast.DocumentNode).Body } if err := p.node.replace(doc.Body, node); err != nil { - return errors.Wrapf(err, "failed to replace node by path ( %s )", p.node) + return internal.Wrapf(err, "failed to replace node by path ( %s )", p.node) } } return nil @@ -472,7 +472,7 @@ func (n *rootNode) filter(node ast.Node) (ast.Node, error) { } filtered, err := n.child.filter(node) if err != nil { - return nil, errors.Wrapf(err, "failed to filter") + return nil, internal.Wrapf(err, "failed to filter") } return filtered, nil } @@ -482,7 +482,7 @@ func (n *rootNode) replace(node ast.Node, target ast.Node) error { return nil } if err := n.child.replace(node, target); err != nil { - return errors.Wrapf(err, "failed to replace") + return internal.Wrapf(err, "failed to replace") } return nil } @@ -514,7 +514,7 @@ func (n *selectorNode) filter(node ast.Node) (ast.Node, error) { var err error key, err = strconv.Unquote(key) if err != nil { - return nil, errors.Wrapf(err, "failed to unquote") + return nil, internal.Wrapf(err, "failed to unquote") } case '\'': if len(key) > 1 && key[len(key)-1] == '\'' { @@ -528,7 +528,7 @@ func (n *selectorNode) filter(node ast.Node) (ast.Node, error) { } filtered, err := n.child.filter(value.Value) if err != nil { - return nil, errors.Wrapf(err, "failed to filter") + return nil, internal.Wrapf(err, "failed to filter") } return filtered, nil } @@ -542,12 +542,12 @@ func (n *selectorNode) filter(node ast.Node) (ast.Node, error) { } filtered, err := n.child.filter(value.Value) if err != nil { - return nil, errors.Wrapf(err, "failed to filter") + return nil, internal.Wrapf(err, "failed to filter") } return filtered, nil } default: - return nil, errors.Wrapf(ErrInvalidQuery, "expected node type is map or map value. but got %s", node.Type()) + return nil, internal.Wrapf(ErrInvalidQuery, "expected node type is map or map value. but got %s", node.Type()) } return nil, nil } @@ -559,11 +559,11 @@ func (n *selectorNode) replaceMapValue(value *ast.MappingValueNode, target ast.N } if n.child == nil { if err := value.Replace(target); err != nil { - return errors.Wrapf(err, "failed to replace") + return internal.Wrapf(err, "failed to replace") } } else { if err := n.child.replace(value.Value, target); err != nil { - return errors.Wrapf(err, "failed to replace") + return internal.Wrapf(err, "failed to replace") } } return nil @@ -574,16 +574,16 @@ func (n *selectorNode) replace(node ast.Node, target ast.Node) error { case ast.MappingType: for _, value := range node.(*ast.MappingNode).Values { if err := n.replaceMapValue(value, target); err != nil { - return errors.Wrapf(err, "failed to replace map value") + return internal.Wrapf(err, "failed to replace map value") } } case ast.MappingValueType: value := node.(*ast.MappingValueNode) if err := n.replaceMapValue(value, target); err != nil { - return errors.Wrapf(err, "failed to replace map value") + return internal.Wrapf(err, "failed to replace map value") } default: - return errors.Wrapf(ErrInvalidQuery, "expected node type is map or map value. but got %s", node.Type()) + return internal.Wrapf(ErrInvalidQuery, "expected node type is map or map value. but got %s", node.Type()) } return nil } @@ -612,11 +612,11 @@ func newIndexNode(selector uint) *indexNode { func (n *indexNode) filter(node ast.Node) (ast.Node, error) { if node.Type() != ast.SequenceType { - return nil, errors.Wrapf(ErrInvalidQuery, "expected sequence type node. but got %s", node.Type()) + return nil, internal.Wrapf(ErrInvalidQuery, "expected sequence type node. but got %s", node.Type()) } sequence := node.(*ast.SequenceNode) if n.selector >= uint(len(sequence.Values)) { - return nil, errors.Wrapf(ErrInvalidQuery, "expected index is %d. but got sequences has %d items", n.selector, sequence.Values) + return nil, internal.Wrapf(ErrInvalidQuery, "expected index is %d. but got sequences has %d items", n.selector, sequence.Values) } value := sequence.Values[n.selector] if n.child == nil { @@ -624,27 +624,27 @@ func (n *indexNode) filter(node ast.Node) (ast.Node, error) { } filtered, err := n.child.filter(value) if err != nil { - return nil, errors.Wrapf(err, "failed to filter") + return nil, internal.Wrapf(err, "failed to filter") } return filtered, nil } func (n *indexNode) replace(node ast.Node, target ast.Node) error { if node.Type() != ast.SequenceType { - return errors.Wrapf(ErrInvalidQuery, "expected sequence type node. but got %s", node.Type()) + return internal.Wrapf(ErrInvalidQuery, "expected sequence type node. but got %s", node.Type()) } sequence := node.(*ast.SequenceNode) if n.selector >= uint(len(sequence.Values)) { - return errors.Wrapf(ErrInvalidQuery, "expected index is %d. but got sequences has %d items", n.selector, sequence.Values) + return internal.Wrapf(ErrInvalidQuery, "expected index is %d. but got sequences has %d items", n.selector, sequence.Values) } if n.child == nil { if err := sequence.Replace(int(n.selector), target); err != nil { - return errors.Wrapf(err, "failed to replace") + return internal.Wrapf(err, "failed to replace") } return nil } if err := n.child.replace(sequence.Values[n.selector], target); err != nil { - return errors.Wrapf(err, "failed to replace") + return internal.Wrapf(err, "failed to replace") } return nil } @@ -677,7 +677,7 @@ func (n *indexAllNode) String() string { func (n *indexAllNode) filter(node ast.Node) (ast.Node, error) { if node.Type() != ast.SequenceType { - return nil, errors.Wrapf(ErrInvalidQuery, "expected sequence type node. but got %s", node.Type()) + return nil, internal.Wrapf(ErrInvalidQuery, "expected sequence type node. but got %s", node.Type()) } sequence := node.(*ast.SequenceNode) if n.child == nil { @@ -688,7 +688,7 @@ func (n *indexAllNode) filter(node ast.Node) (ast.Node, error) { for _, value := range sequence.Values { filtered, err := n.child.filter(value) if err != nil { - return nil, errors.Wrapf(err, "failed to filter") + return nil, internal.Wrapf(err, "failed to filter") } out.Values = append(out.Values, filtered) } @@ -697,20 +697,20 @@ func (n *indexAllNode) filter(node ast.Node) (ast.Node, error) { func (n *indexAllNode) replace(node ast.Node, target ast.Node) error { if node.Type() != ast.SequenceType { - return errors.Wrapf(ErrInvalidQuery, "expected sequence type node. but got %s", node.Type()) + return internal.Wrapf(ErrInvalidQuery, "expected sequence type node. but got %s", node.Type()) } sequence := node.(*ast.SequenceNode) if n.child == nil { for idx := range sequence.Values { if err := sequence.Replace(idx, target); err != nil { - return errors.Wrapf(err, "failed to replace") + return internal.Wrapf(err, "failed to replace") } } return nil } for _, value := range sequence.Values { if err := n.child.replace(value, target); err != nil { - return errors.Wrapf(err, "failed to replace") + return internal.Wrapf(err, "failed to replace") } } return nil @@ -743,7 +743,7 @@ func (n *recursiveNode) filterNode(node ast.Node) (*ast.SequenceNode, error) { for _, value := range typedNode.Values { seq, err := n.filterNode(value) if err != nil { - return nil, errors.Wrapf(err, "failed to filter") + return nil, internal.Wrapf(err, "failed to filter") } sequence.Values = append(sequence.Values, seq.Values...) } @@ -754,14 +754,14 @@ func (n *recursiveNode) filterNode(node ast.Node) (*ast.SequenceNode, error) { } seq, err := n.filterNode(typedNode.Value) if err != nil { - return nil, errors.Wrapf(err, "failed to filter") + return nil, internal.Wrapf(err, "failed to filter") } sequence.Values = append(sequence.Values, seq.Values...) case *ast.SequenceNode: for _, value := range typedNode.Values { seq, err := n.filterNode(value) if err != nil { - return nil, errors.Wrapf(err, "failed to filter") + return nil, internal.Wrapf(err, "failed to filter") } sequence.Values = append(sequence.Values, seq.Values...) } @@ -772,7 +772,7 @@ func (n *recursiveNode) filterNode(node ast.Node) (*ast.SequenceNode, error) { func (n *recursiveNode) filter(node ast.Node) (ast.Node, error) { sequence, err := n.filterNode(node) if err != nil { - return nil, errors.Wrapf(err, "failed to filter") + return nil, internal.Wrapf(err, "failed to filter") } sequence.Start = node.GetToken() return sequence, nil @@ -783,23 +783,23 @@ func (n *recursiveNode) replaceNode(node ast.Node, target ast.Node) error { case *ast.MappingNode: for _, value := range typedNode.Values { if err := n.replaceNode(value, target); err != nil { - return errors.Wrapf(err, "failed to replace") + return internal.Wrapf(err, "failed to replace") } } case *ast.MappingValueNode: key := typedNode.Key.GetToken().Value if n.selector == key { if err := typedNode.Replace(target); err != nil { - return errors.Wrapf(err, "failed to replace") + return internal.Wrapf(err, "failed to replace") } } if err := n.replaceNode(typedNode.Value, target); err != nil { - return errors.Wrapf(err, "failed to replace") + return internal.Wrapf(err, "failed to replace") } case *ast.SequenceNode: for _, value := range typedNode.Values { if err := n.replaceNode(value, target); err != nil { - return errors.Wrapf(err, "failed to replace") + return internal.Wrapf(err, "failed to replace") } } } @@ -808,7 +808,7 @@ func (n *recursiveNode) replaceNode(node ast.Node, target ast.Node) error { func (n *recursiveNode) replace(node ast.Node, target ast.Node) error { if err := n.replaceNode(node, target); err != nil { - return errors.Wrapf(err, "failed to replace") + return internal.Wrapf(err, "failed to replace") } return nil } diff --git a/yaml.go b/yaml.go index 25b1056f..2f7bdbcf 100644 --- a/yaml.go +++ b/yaml.go @@ -3,13 +3,13 @@ package yaml import ( "bytes" "context" + "errors" "io" "reflect" "sync" "github.com/goccy/go-yaml/ast" - "github.com/goccy/go-yaml/internal/errors" - "golang.org/x/xerrors" + "github.com/goccy/go-yaml/internal" ) // BytesMarshaler interface may be implemented by types to customize their @@ -138,7 +138,7 @@ func MarshalWithOptions(v interface{}, opts ...EncodeOption) ([]byte, error) { func MarshalContext(ctx context.Context, v interface{}, opts ...EncodeOption) ([]byte, error) { var buf bytes.Buffer if err := NewEncoder(&buf, opts...).EncodeContext(ctx, v); err != nil { - return nil, errors.Wrapf(err, "failed to marshal") + return nil, internal.Wrapf(err, "failed to marshal") } return buf.Bytes(), nil } @@ -148,7 +148,7 @@ func ValueToNode(v interface{}, opts ...EncodeOption) (ast.Node, error) { var buf bytes.Buffer node, err := NewEncoder(&buf, opts...).EncodeToNode(v) if err != nil { - return nil, errors.Wrapf(err, "failed to convert value to node") + return nil, internal.Wrapf(err, "failed to convert value to node") } return node, nil } @@ -192,7 +192,7 @@ func UnmarshalContext(ctx context.Context, data []byte, v interface{}, opts ...D if err == io.EOF { return nil } - return errors.Wrapf(err, "failed to unmarshal") + return internal.Wrapf(err, "failed to unmarshal") } return nil } @@ -201,7 +201,7 @@ func UnmarshalContext(ctx context.Context, data []byte, v interface{}, opts ...D func NodeToValue(node ast.Node, v interface{}, opts ...DecodeOption) error { var buf bytes.Buffer if err := NewDecoder(&buf, opts...).DecodeFromNode(node, v); err != nil { - return errors.Wrapf(err, "failed to convert node to value") + return internal.Wrapf(err, "failed to convert node to value") } return nil } @@ -213,10 +213,10 @@ func NodeToValue(node ast.Node, v interface{}, opts ...DecodeOption) error { // If the third argument `inclSource` is true, the error message will // contain snippets of the YAML source that was used. func FormatError(e error, colored, inclSource bool) string { - var pp errors.PrettyPrinter - if xerrors.As(e, &pp) { + var pp internal.PrettyPrinter + if errors.As(e, &pp) { var buf bytes.Buffer - pp.PrettyPrint(&errors.Sink{&buf}, colored, inclSource) + pp.PrettyPrint(&internal.Sink{&buf}, colored, inclSource) return buf.String() } @@ -227,11 +227,11 @@ func FormatError(e error, colored, inclSource bool) string { func YAMLToJSON(bytes []byte) ([]byte, error) { var v interface{} if err := UnmarshalWithOptions(bytes, &v, UseOrderedMap()); err != nil { - return nil, errors.Wrapf(err, "failed to unmarshal") + return nil, internal.Wrapf(err, "failed to unmarshal") } out, err := MarshalWithOptions(v, JSON()) if err != nil { - return nil, errors.Wrapf(err, "failed to marshal with json option") + return nil, internal.Wrapf(err, "failed to marshal with json option") } return out, nil } @@ -240,11 +240,11 @@ func YAMLToJSON(bytes []byte) ([]byte, error) { func JSONToYAML(bytes []byte) ([]byte, error) { var v interface{} if err := UnmarshalWithOptions(bytes, &v, UseOrderedMap()); err != nil { - return nil, errors.Wrapf(err, "failed to unmarshal from json bytes") + return nil, internal.Wrapf(err, "failed to unmarshal from json bytes") } out, err := Marshal(v) if err != nil { - return nil, errors.Wrapf(err, "failed to marshal") + return nil, internal.Wrapf(err, "failed to marshal") } return out, nil }