-
Notifications
You must be signed in to change notification settings - Fork 634
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Revert "remove unused jmespath dependency from main module (#2707)"
This reverts commit adab0de.
- Loading branch information
Showing
5 changed files
with
431 additions
and
1 deletion.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,8 @@ | ||
{ | ||
"id": "afdba36c-1405-4811-8432-8213876aa1f0", | ||
"type": "dependency", | ||
"description": "Temporarily reinstate removed go-jmespath dependency.", | ||
"modules": [ | ||
"." | ||
] | ||
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -1,5 +1,8 @@ | ||
module github.com/aws/aws-sdk-go-v2 | ||
|
||
require github.com/aws/smithy-go v1.20.3 | ||
require ( | ||
github.com/aws/smithy-go v1.20.3 | ||
github.com/jmespath/go-jmespath v0.4.0 | ||
) | ||
|
||
go 1.20 |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -1,2 +1,14 @@ | ||
github.com/aws/smithy-go v1.20.3 h1:ryHwveWzPV5BIof6fyDvor6V3iUL7nTfiTKXHiW05nE= | ||
github.com/aws/smithy-go v1.20.3/go.mod h1:krry+ya/rV9RDcV/Q16kpu6ypI4K2czasz0NC3qS14E= | ||
github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= | ||
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= | ||
github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg= | ||
github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo= | ||
github.com/jmespath/go-jmespath/internal/testify v1.5.1 h1:shLQSRRSCCPj3f2gpwzGwWFoC7ycTf1rcQZHOlsJ6N8= | ||
github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U= | ||
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= | ||
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= | ||
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= | ||
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= | ||
gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10= | ||
gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,225 @@ | ||
package awsutil | ||
|
||
import ( | ||
"reflect" | ||
"regexp" | ||
"strconv" | ||
"strings" | ||
|
||
"github.com/jmespath/go-jmespath" | ||
) | ||
|
||
var indexRe = regexp.MustCompile(`(.+)\[(-?\d+)?\]$`) | ||
|
||
// rValuesAtPath returns a slice of values found in value v. The values | ||
// in v are explored recursively so all nested values are collected. | ||
func rValuesAtPath(v interface{}, path string, createPath, caseSensitive, nilTerm bool) []reflect.Value { | ||
pathparts := strings.Split(path, "||") | ||
if len(pathparts) > 1 { | ||
for _, pathpart := range pathparts { | ||
vals := rValuesAtPath(v, pathpart, createPath, caseSensitive, nilTerm) | ||
if len(vals) > 0 { | ||
return vals | ||
} | ||
} | ||
return nil | ||
} | ||
|
||
values := []reflect.Value{reflect.Indirect(reflect.ValueOf(v))} | ||
components := strings.Split(path, ".") | ||
for len(values) > 0 && len(components) > 0 { | ||
var index *int64 | ||
var indexStar bool | ||
c := strings.TrimSpace(components[0]) | ||
if c == "" { // no actual component, illegal syntax | ||
return nil | ||
} else if caseSensitive && c != "*" && strings.ToLower(c[0:1]) == c[0:1] { | ||
// TODO normalize case for user | ||
return nil // don't support unexported fields | ||
} | ||
|
||
// parse this component | ||
if m := indexRe.FindStringSubmatch(c); m != nil { | ||
c = m[1] | ||
if m[2] == "" { | ||
index = nil | ||
indexStar = true | ||
} else { | ||
i, _ := strconv.ParseInt(m[2], 10, 32) | ||
index = &i | ||
indexStar = false | ||
} | ||
} | ||
|
||
nextvals := []reflect.Value{} | ||
for _, value := range values { | ||
// pull component name out of struct member | ||
if value.Kind() != reflect.Struct { | ||
continue | ||
} | ||
|
||
if c == "*" { // pull all members | ||
for i := 0; i < value.NumField(); i++ { | ||
if f := reflect.Indirect(value.Field(i)); f.IsValid() { | ||
nextvals = append(nextvals, f) | ||
} | ||
} | ||
continue | ||
} | ||
|
||
value = value.FieldByNameFunc(func(name string) bool { | ||
if c == name { | ||
return true | ||
} else if !caseSensitive && strings.EqualFold(name, c) { | ||
return true | ||
} | ||
return false | ||
}) | ||
|
||
if nilTerm && value.Kind() == reflect.Ptr && len(components[1:]) == 0 { | ||
if !value.IsNil() { | ||
value.Set(reflect.Zero(value.Type())) | ||
} | ||
return []reflect.Value{value} | ||
} | ||
|
||
if createPath && value.Kind() == reflect.Ptr && value.IsNil() { | ||
// TODO if the value is the terminus it should not be created | ||
// if the value to be set to its position is nil. | ||
value.Set(reflect.New(value.Type().Elem())) | ||
value = value.Elem() | ||
} else { | ||
value = reflect.Indirect(value) | ||
} | ||
|
||
if value.Kind() == reflect.Slice || value.Kind() == reflect.Map { | ||
if !createPath && value.IsNil() { | ||
value = reflect.ValueOf(nil) | ||
} | ||
} | ||
|
||
if value.IsValid() { | ||
nextvals = append(nextvals, value) | ||
} | ||
} | ||
values = nextvals | ||
|
||
if indexStar || index != nil { | ||
nextvals = []reflect.Value{} | ||
for _, valItem := range values { | ||
value := reflect.Indirect(valItem) | ||
if value.Kind() != reflect.Slice { | ||
continue | ||
} | ||
|
||
if indexStar { // grab all indices | ||
for i := 0; i < value.Len(); i++ { | ||
idx := reflect.Indirect(value.Index(i)) | ||
if idx.IsValid() { | ||
nextvals = append(nextvals, idx) | ||
} | ||
} | ||
continue | ||
} | ||
|
||
// pull out index | ||
i := int(*index) | ||
if i >= value.Len() { // check out of bounds | ||
if createPath { | ||
// TODO resize slice | ||
} else { | ||
continue | ||
} | ||
} else if i < 0 { // support negative indexing | ||
i = value.Len() + i | ||
} | ||
value = reflect.Indirect(value.Index(i)) | ||
|
||
if value.Kind() == reflect.Slice || value.Kind() == reflect.Map { | ||
if !createPath && value.IsNil() { | ||
value = reflect.ValueOf(nil) | ||
} | ||
} | ||
|
||
if value.IsValid() { | ||
nextvals = append(nextvals, value) | ||
} | ||
} | ||
values = nextvals | ||
} | ||
|
||
components = components[1:] | ||
} | ||
return values | ||
} | ||
|
||
// ValuesAtPath returns a list of values at the case insensitive lexical | ||
// path inside of a structure. | ||
func ValuesAtPath(i interface{}, path string) ([]interface{}, error) { | ||
result, err := jmespath.Search(path, i) | ||
if err != nil { | ||
return nil, err | ||
} | ||
|
||
v := reflect.ValueOf(result) | ||
if !v.IsValid() || (v.Kind() == reflect.Ptr && v.IsNil()) { | ||
return nil, nil | ||
} | ||
if s, ok := result.([]interface{}); ok { | ||
return s, err | ||
} | ||
if v.Kind() == reflect.Map && v.Len() == 0 { | ||
return nil, nil | ||
} | ||
if v.Kind() == reflect.Slice { | ||
out := make([]interface{}, v.Len()) | ||
for i := 0; i < v.Len(); i++ { | ||
out[i] = v.Index(i).Interface() | ||
} | ||
return out, nil | ||
} | ||
|
||
return []interface{}{result}, nil | ||
} | ||
|
||
// SetValueAtPath sets a value at the case insensitive lexical path inside | ||
// of a structure. | ||
func SetValueAtPath(i interface{}, path string, v interface{}) { | ||
if rvals := rValuesAtPath(i, path, true, false, v == nil); rvals != nil { | ||
for _, rval := range rvals { | ||
if rval.Kind() == reflect.Ptr && rval.IsNil() { | ||
continue | ||
} | ||
setValue(rval, v) | ||
} | ||
} | ||
} | ||
|
||
func setValue(dstVal reflect.Value, src interface{}) { | ||
if dstVal.Kind() == reflect.Ptr { | ||
dstVal = reflect.Indirect(dstVal) | ||
} | ||
srcVal := reflect.ValueOf(src) | ||
|
||
if !srcVal.IsValid() { // src is literal nil | ||
if dstVal.CanAddr() { | ||
// Convert to pointer so that pointer's value can be nil'ed | ||
// dstVal = dstVal.Addr() | ||
} | ||
dstVal.Set(reflect.Zero(dstVal.Type())) | ||
|
||
} else if srcVal.Kind() == reflect.Ptr { | ||
if srcVal.IsNil() { | ||
srcVal = reflect.Zero(dstVal.Type()) | ||
} else { | ||
srcVal = reflect.ValueOf(src).Elem() | ||
} | ||
dstVal.Set(srcVal) | ||
} else { | ||
if dstVal.Kind() == reflect.String { | ||
dstVal.SetString(srcVal.String()) | ||
} else { | ||
dstVal.Set(srcVal) | ||
} | ||
} | ||
} |
Oops, something went wrong.