Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:27
📄 copy.go package awsutil import ( "io" "reflect" "time" ) // Copy deeply copies a src structure to dst. Useful for copying request and // response structures. // // Can copy between structs of different type, but will only copy fields which // are assignable, and exist in both structs. Fields which are not assignable, // or do not exist in both structs are ignored. func Copy(dst, src interface{}) { dstval := reflect.ValueOf(dst) if !dstval.IsValid() { panic("Copy dst cannot be nil") } rcopy(dstval, reflect.ValueOf(src), true) } // CopyOf returns a copy of src while also allocating the memory for dst. // src must be a pointer type or this operation will fail. func CopyOf(src interface{}) (dst interface{}) { dsti := reflect.New(reflect.TypeOf(src).Elem()) dst = dsti.Interface() rcopy(dsti, reflect.ValueOf(src), true) return } // rcopy performs a recursive copy of values from the source to destination. // // root is used to skip certain aspects of the copy which are not valid // for the root node of a object. func rcopy(dst, src reflect.Value, root bool) { if !src.IsValid() { return } switch src.Kind() { case reflect.Ptr: if _, ok := src.Interface().(io.Reader); ok { if dst.Kind() == reflect.Ptr && dst.Elem().CanSet() { dst.Elem().Set(src) } else if dst.CanSet() { dst.Set(src) } } else { e := src.Type().Elem() if dst.CanSet() && !src.IsNil() { if _, ok := src.Interface().(*time.Time); !ok { dst.Set(reflect.New(e)) } else { tempValue := reflect.New(e) tempValue.Elem().Set(src.Elem()) // Sets time.Time's unexported values dst.Set(tempValue) } } if src.Elem().IsValid() { // Keep the current root state since the depth hasn't changed rcopy(dst.Elem(), src.Elem(), root) } } case reflect.Struct: t := dst.Type() for i := 0; i < t.NumField(); i++ { name := t.Field(i).Name srcVal := src.FieldByName(name) dstVal := dst.FieldByName(name) if srcVal.IsValid() && dstVal.CanSet() { rcopy(dstVal, srcVal, false) } } case reflect.Slice: if src.IsNil() { break } s := reflect.MakeSlice(src.Type(), src.Len(), src.Cap()) dst.Set(s) for i := 0; i < src.Len(); i++ { rcopy(dst.Index(i), src.Index(i), false) } case reflect.Map: if src.IsNil() { break } s := reflect.MakeMap(src.Type()) dst.Set(s) for _, k := range src.MapKeys() { v := src.MapIndex(k) v2 := reflect.New(v.Type()).Elem() rcopy(v2, v, false) dst.SetMapIndex(k, v2) } default: // Assign the value if possible. If its not assignable, the value would // need to be converted and the impact of that may be unexpected, or is // not compatible with the dst type. if src.Type().AssignableTo(dst.Type()) { dst.Set(src) } } }	2.71 KB	2025-05-25 12:27
📄 copy_test.go package awsutil_test import ( "bytes" "fmt" "io" "io/ioutil" "reflect" "testing" "time" "github.com/aws/aws-sdk-go/aws/awsutil" ) func ExampleCopy() { type Foo struct { A int B []string } // Create the initial value str1 := "hello" str2 := "bye bye" f1 := &Foo{A: 1, B: []string{&str1, &str2}} // Do the copy var f2 Foo awsutil.Copy(&f2, f1) // Print the result fmt.Println(awsutil.Prettify(f2)) // Output: // { // A: 1, // B: ["hello","bye bye"] // } } func TestCopy1(t testing.T) { type Bar struct { a int B int c int D int } type Foo struct { A int B []string C map[string]int D time.Time E Bar } // Create the initial value str1 := "hello" str2 := "bye bye" int1 := 1 int2 := 2 intPtr1 := 1 intPtr2 := 2 now := time.Now() f1 := &Foo{ A: 1, B: []string{&str1, &str2}, C: map[string]int{ "A": &int1, "B": &int2, }, D: &now, E: &Bar{ &intPtr1, &intPtr2, 2, 3, }, } // Do the copy var f2 Foo awsutil.Copy(&f2, f1) // Values are equal if v1, v2 := f2.A, f1.A; v1 != v2 { t.Errorf("expected values to be equivalent but received %v and %v", v1, v2) } if v1, v2 := f2.B, f1.B; !reflect.DeepEqual(v1, v2) { t.Errorf("expected values to be equivalent but received %v and %v", v1, v2) } if v1, v2 := f2.C, f1.C; !reflect.DeepEqual(v1, v2) { t.Errorf("expected values to be equivalent but received %v and %v", v1, v2) } if v1, v2 := f2.D, f1.D; !v1.Equal(v2) { t.Errorf("expected values to be equivalent but received %v and %v", v1, v2) } if v1, v2 := f2.E.B, f1.E.B; !reflect.DeepEqual(v1, v2) { t.Errorf("expected values to be equivalent but received %v and %v", v1, v2) } if v1, v2 := f2.E.D, f1.E.D; v1 != v2 { t.Errorf("expected values to be equivalent but received %v and %v", v1, v2) } // But pointers are not! str3 := "nothello" int3 := 57 f2.A = 100 f2.B[0] = str3 f2.C["B"] = int3 f2.D = time.Now() f2.E.a = &int3 f2.E.B = int3 f2.E.c = 5 f2.E.D = 5 if v1, v2 := f2.A, f1.A; v1 == v2 { t.Errorf("expected values to be not equivalent, but received %v", v1) } if v1, v2 := f2.B, f1.B; reflect.DeepEqual(v1, v2) { t.Errorf("expected values to be not equivalent, but received %v", v1) } if v1, v2 := f2.C, f1.C; reflect.DeepEqual(v1, v2) { t.Errorf("expected values to be not equivalent, but received %v", v1) } if v1, v2 := f2.D, f1.D; v1 == v2 { t.Errorf("expected values to be not equivalent, but received %v", v1) } if v1, v2 := f2.E.a, f1.E.a; v1 == v2 { t.Errorf("expected values to be not equivalent, but received %v", v1) } if v1, v2 := f2.E.B, f1.E.B; v1 == v2 { t.Errorf("expected values to be not equivalent, but received %v", v1) } if v1, v2 := f2.E.c, f1.E.c; v1 == v2 { t.Errorf("expected values to be not equivalent, but received %v", v1) } if v1, v2 := f2.E.D, f1.E.D; v1 == v2 { t.Errorf("expected values to be not equivalent, but received %v", v1) } } func TestCopyNestedWithUnexported(t testing.T) { type Bar struct { a int B int } type Foo struct { A string B Bar } f1 := &Foo{A: "string", B: Bar{a: 1, B: 2}} var f2 Foo awsutil.Copy(&f2, f1) // Values match if v1, v2 := f2.A, f1.A; v1 != v2 { t.Errorf("expected values to be equivalent but received %v and %v", v1, v2) } if v1, v2 := f2.B, f1.B; v1 == v2 { t.Errorf("expected values to be not equivalent, but received %v", v1) } if v1, v2 := f2.B.a, f1.B.a; v1 == v2 { t.Errorf("expected values to be not equivalent, but received %v", v1) } if v1, v2 := f2.B.B, f2.B.B; v1 != v2 { t.Errorf("expected values to be equivalent but received %v and %v", v1, v2) } } func TestCopyIgnoreNilMembers(t testing.T) { type Foo struct { A string B []string C map[string]string } f := &Foo{} if v1 := f.A; v1 != nil { t.Errorf("expected nil, but received %v", v1) } if v1 := f.B; v1 != nil { t.Errorf("expected nil, but received %v", v1) } if v1 := f.C; v1 != nil { t.Errorf("expected nil, but received %v", v1) } var f2 Foo awsutil.Copy(&f2, f) if v1 := f2.A; v1 != nil { t.Errorf("expected nil, but received %v", v1) } if v1 := f2.B; v1 != nil { t.Errorf("expected nil, but received %v", v1) } if v1 := f2.C; v1 != nil { t.Errorf("expected nil, but received %v", v1) } fcopy := awsutil.CopyOf(f) f3 := fcopy.(Foo) if v1 := f3.A; v1 != nil { t.Errorf("expected nil, but received %v", v1) } if v1 := f3.B; v1 != nil { t.Errorf("expected nil, but received %v", v1) } if v1 := f3.C; v1 != nil { t.Errorf("expected nil, but received %v", v1) } } func TestCopyPrimitive(t testing.T) { str := "hello" var s string awsutil.Copy(&s, &str) if v1, v2 := "hello", s; v1 != v2 { t.Errorf("expected values to be equivalent but received %v and %v", v1, v2) } } func TestCopyNil(t testing.T) { var s string awsutil.Copy(&s, nil) if v1, v2 := "", s; v1 != v2 { t.Errorf("expected values to be equivalent but received %v and %v", v1, v2) } } func TestCopyReader(t testing.T) { var buf io.Reader = bytes.NewReader([]byte("hello world")) var r io.Reader awsutil.Copy(&r, buf) b, err := ioutil.ReadAll(r) if err != nil { t.Errorf("expected no error, but received %v", err) } if v1, v2 := []byte("hello world"), b; !bytes.Equal(v1, v2) { t.Errorf("expected values to be equivalent but received %v and %v", v1, v2) } // empty bytes because this is not a deep copy b, err = ioutil.ReadAll(buf) if err != nil { t.Errorf("expected no error, but received %v", err) } if v1, v2 := []byte(""), b; !bytes.Equal(v1, v2) { t.Errorf("expected values to be equivalent but received %v and %v", v1, v2) } } func TestCopyDifferentStructs(t testing.T) { type SrcFoo struct { A int B []string C map[string]int SrcUnique string SameNameDiffType int unexportedPtr int ExportedPtr int } type DstFoo struct { A int B []string C map[string]int DstUnique int SameNameDiffType string unexportedPtr int ExportedPtr int } // Create the initial value str1 := "hello" str2 := "bye bye" int1 := 1 int2 := 2 f1 := &SrcFoo{ A: 1, B: []string{&str1, &str2}, C: map[string]int{ "A": &int1, "B": &int2, }, SrcUnique: "unique", SameNameDiffType: 1, unexportedPtr: &int1, ExportedPtr: &int2, } // Do the copy var f2 DstFoo awsutil.Copy(&f2, f1) // Values are equal if v1, v2 := f2.A, f1.A; v1 != v2 { t.Errorf("expected values to be equivalent but received %v and %v", v1, v2) } if v1, v2 := f2.B, f1.B; !reflect.DeepEqual(v1, v2) { t.Errorf("expected values to be equivalent but received %v and %v", v1, v2) } if v1, v2 := f2.C, f1.C; !reflect.DeepEqual(v1, v2) { t.Errorf("expected values to be equivalent but received %v and %v", v1, v2) } if v1, v2 := "unique", f1.SrcUnique; v1 != v2 { t.Errorf("expected values to be equivalent but received %v and %v", v1, v2) } if v1, v2 := 1, f1.SameNameDiffType; v1 != v2 { t.Errorf("expected values to be equivalent but received %v and %v", v1, v2) } if v1, v2 := 0, f2.DstUnique; v1 != v2 { t.Errorf("expected values to be equivalent but received %v and %v", v1, v2) } if v1, v2 := "", f2.SameNameDiffType; v1 != v2 { t.Errorf("expected values to be equivalent but received %v and %v", v1, v2) } if v1, v2 := int1, f1.unexportedPtr; v1 != v2 { t.Errorf("expected values to be equivalent but received %v and %v", v1, v2) } if v1 := f2.unexportedPtr; v1 != nil { t.Errorf("expected nil, but received %v", v1) } if v1, v2 := int2, f1.ExportedPtr; v1 != v2 { t.Errorf("expected values to be equivalent but received %v and %v", v1, v2) } if v1, v2 := int2, f2.ExportedPtr; v1 != v2 { t.Errorf("expected values to be equivalent but received %v and %v", v1, v2) } } func ExampleCopyOf() { type Foo struct { A int B []string } // Create the initial value str1 := "hello" str2 := "bye bye" f1 := &Foo{A: 1, B: []string{&str1, &str2}} // Do the copy v := awsutil.CopyOf(f1) var f2 Foo = v.(*Foo) // Print the result fmt.Println(awsutil.Prettify(f2)) // Output: // { // A: 1, // B: ["hello","bye bye"] // } }	8.07 KB	2025-05-25 12:27
📄 equal.go package awsutil import ( "reflect" ) // DeepEqual returns if the two values are deeply equal like reflect.DeepEqual. // In addition to this, this method will also dereference the input values if // possible so the DeepEqual performed will not fail if one parameter is a // pointer and the other is not. // // DeepEqual will not perform indirection of nested values of the input parameters. func DeepEqual(a, b interface{}) bool { ra := reflect.Indirect(reflect.ValueOf(a)) rb := reflect.Indirect(reflect.ValueOf(b)) if raValid, rbValid := ra.IsValid(), rb.IsValid(); !raValid && !rbValid { // If the elements are both nil, and of the same type they are equal // If they are of different types they are not equal return reflect.TypeOf(a) == reflect.TypeOf(b) } else if raValid != rbValid { // Both values must be valid to be equal return false } return reflect.DeepEqual(ra.Interface(), rb.Interface()) }	925 B	2025-05-25 12:27
📄 equal_test.go package awsutil_test import ( "testing" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/awsutil" ) func TestDeepEqual(t testing.T) { cases := []struct { a, b interface{} equal bool }{ {"a", "a", true}, {"a", "b", false}, {"a", aws.String(""), false}, {"a", nil, false}, {"a", aws.String("a"), true}, {(bool)(nil), (bool)(nil), true}, {(bool)(nil), (*string)(nil), false}, {nil, nil, true}, } for i, c := range cases { if awsutil.DeepEqual(c.a, c.b) != c.equal { t.Errorf("%d, a:%v b:%v, %t", i, c.a, c.b, c.equal) } } }	579 B	2025-05-25 12:27
📄 path_value.go 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{}) { rvals := rValuesAtPath(i, path, true, false, v == 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 { dstVal.Set(srcVal) } }	5.25 KB	2025-05-25 12:27
📄 path_value_test.go package awsutil_test import ( "strings" "testing" "github.com/aws/aws-sdk-go/aws/awsutil" ) type Struct struct { A []Struct z []Struct B Struct D Struct C string E map[string]string } var data = Struct{ A: []Struct{{C: "value1"}, {C: "value2"}, {C: "value3"}}, z: []Struct{{C: "value1"}, {C: "value2"}, {C: "value3"}}, B: &Struct{B: &Struct{C: "terminal"}, D: &Struct{C: "terminal2"}}, C: "initial", } var data2 = Struct{A: []Struct{ {A: []Struct{{C: "1"}, {C: "1"}, {C: "1"}, {C: "1"}, {C: "1"}}}, {A: []Struct{{C: "2"}, {C: "2"}, {C: "2"}, {C: "2"}, {C: "2"}}}, }} func TestValueAtPathSuccess(t testing.T) { var testCases = []struct { expect []interface{} data interface{} path string }{ {[]interface{}{"initial"}, data, "C"}, {[]interface{}{"value1"}, data, "A[0].C"}, {[]interface{}{"value2"}, data, "A[1].C"}, {[]interface{}{"value3"}, data, "A[2].C"}, {[]interface{}{"value3"}, data, "a[2].c"}, {[]interface{}{"value3"}, data, "A[-1].C"}, {[]interface{}{"value1", "value2", "value3"}, data, "A[].C"}, {[]interface{}{"terminal"}, data, "B . B . C"}, {[]interface{}{"initial"}, data, "A.D.X \|\| C"}, {[]interface{}{"initial"}, data, "A[0].B \|\| C"}, {[]interface{}{ Struct{A: []Struct{{C: "1"}, {C: "1"}, {C: "1"}, {C: "1"}, {C: "1"}}}, Struct{A: []Struct{{C: "2"}, {C: "2"}, {C: "2"}, {C: "2"}, {C: "2"}}}, }, data2, "A"}, } for i, c := range testCases { v, err := awsutil.ValuesAtPath(c.data, c.path) if err != nil { t.Errorf("case %v, expected no error, %v", i, c.path) } if e, a := c.expect, v; !awsutil.DeepEqual(e, a) { t.Errorf("case %v, %v", i, c.path) } } } func TestValueAtPathFailure(t testing.T) { var testCases = []struct { expect []interface{} errContains string data interface{} path string }{ {nil, "", data, "C.x"}, {nil, "SyntaxError: Invalid token: tDot", data, ".x"}, {nil, "", data, "X.Y.Z"}, {nil, "", data, "A[100].C"}, {nil, "", data, "A[3].C"}, {nil, "", data, "B.B.C.Z"}, {nil, "", data, "z[-1].C"}, {nil, "", nil, "A.B.C"}, {[]interface{}{}, "", Struct{}, "A"}, {nil, "", data, "A[0].B.C"}, {nil, "", data, "D"}, } for i, c := range testCases { v, err := awsutil.ValuesAtPath(c.data, c.path) if c.errContains != "" { if !strings.Contains(err.Error(), c.errContains) { t.Errorf("case %v, expected error, %v", i, c.path) } continue } else { if err != nil { t.Errorf("case %v, expected no error, %v", i, c.path) } } if e, a := c.expect, v; !awsutil.DeepEqual(e, a) { t.Errorf("case %v, %v", i, c.path) } } } func TestSetValueAtPathSuccess(t testing.T) { var s Struct awsutil.SetValueAtPath(&s, "C", "test1") awsutil.SetValueAtPath(&s, "B.B.C", "test2") awsutil.SetValueAtPath(&s, "B.D.C", "test3") if e, a := "test1", s.C; e != a { t.Errorf("expected %v, but received %v", e, a) } if e, a := "test2", s.B.B.C; e != a { t.Errorf("expected %v, but received %v", e, a) } if e, a := "test3", s.B.D.C; e != a { t.Errorf("expected %v, but received %v", e, a) } awsutil.SetValueAtPath(&s, "B..C", "test0") if e, a := "test0", s.B.B.C; e != a { t.Errorf("expected %v, but received %v", e, a) } if e, a := "test0", s.B.D.C; e != a { t.Errorf("expected %v, but received %v", e, a) } var s2 Struct awsutil.SetValueAtPath(&s2, "b.b.c", "test0") if e, a := "test0", s2.B.B.C; e != a { t.Errorf("expected %v, but received %v", e, a) } awsutil.SetValueAtPath(&s2, "A", []Struct{{}}) if e, a := []Struct{{}}, s2.A; !awsutil.DeepEqual(e, a) { t.Errorf("expected %v, but received %v", e, a) } str := "foo" s3 := Struct{} awsutil.SetValueAtPath(&s3, "b.b.c", str) if e, a := "foo", s3.B.B.C; e != a { t.Errorf("expected %v, but received %v", e, a) } s3 = Struct{B: &Struct{B: &Struct{C: str}}} awsutil.SetValueAtPath(&s3, "b.b.c", nil) if e, a := "", s3.B.B.C; e != a { t.Errorf("expected %v, but received %v", e, a) } s3 = Struct{} awsutil.SetValueAtPath(&s3, "b.b.c", nil) if e, a := "", s3.B.B.C; e != a { t.Errorf("expected %v, but received %v", e, a) } s3 = Struct{} awsutil.SetValueAtPath(&s3, "b.b.c", &str) if e, a := "foo", s3.B.B.C; e != a { t.Errorf("expected %v, but received %v", e, a) } var s4 struct{ Name string } awsutil.SetValueAtPath(&s4, "Name", str) if e, a := str, s4.Name; e != a { t.Errorf("expected %v, but received %v", e, a) } s4 = struct{ Name string }{} awsutil.SetValueAtPath(&s4, "Name", nil) if e, a := (string)(nil), s4.Name; e != a { t.Errorf("expected %v, but received %v", e, a) } s4 = struct{ Name string }{Name: &str} awsutil.SetValueAtPath(&s4, "Name", nil) if e, a := (string)(nil), s4.Name; e != a { t.Errorf("expected %v, but received %v", e, a) } s4 = struct{ Name string }{} awsutil.SetValueAtPath(&s4, "Name", &str) if e, a := str, s4.Name; e != a { t.Errorf("expected %v, but received %v", e, a) } }	4.82 KB	2025-05-25 12:27
📄 prettify.go package awsutil import ( "bytes" "fmt" "io" "reflect" "strings" ) // Prettify returns the string representation of a value. func Prettify(i interface{}) string { var buf bytes.Buffer prettify(reflect.ValueOf(i), 0, &buf) return buf.String() } // prettify will recursively walk value v to build a textual // representation of the value. func prettify(v reflect.Value, indent int, buf *bytes.Buffer) { for v.Kind() == reflect.Ptr { v = v.Elem() } switch v.Kind() { case reflect.Struct: strtype := v.Type().String() if strtype == "time.Time" { fmt.Fprintf(buf, "%s", v.Interface()) break } else if strings.HasPrefix(strtype, "io.") { buf.WriteString("<buffer>") break } buf.WriteString("{\n") names := []string{} for i := 0; i < v.Type().NumField(); i++ { name := v.Type().Field(i).Name f := v.Field(i) if name[0:1] == strings.ToLower(name[0:1]) { continue // ignore unexported fields } if (f.Kind() == reflect.Ptr \|\| f.Kind() == reflect.Slice \|\| f.Kind() == reflect.Map) && f.IsNil() { continue // ignore unset fields } names = append(names, name) } for i, n := range names { val := v.FieldByName(n) ft, ok := v.Type().FieldByName(n) if !ok { panic(fmt.Sprintf("expected to find field %v on type %v, but was not found", n, v.Type())) } buf.WriteString(strings.Repeat(" ", indent+2)) buf.WriteString(n + ": ") if tag := ft.Tag.Get("sensitive"); tag == "true" { buf.WriteString("<sensitive>") } else { prettify(val, indent+2, buf) } if i < len(names)-1 { buf.WriteString(",\n") } } buf.WriteString("\n" + strings.Repeat(" ", indent) + "}") case reflect.Slice: strtype := v.Type().String() if strtype == "[]uint8" { fmt.Fprintf(buf, "<binary> len %d", v.Len()) break } nl, id, id2 := "", "", "" if v.Len() > 3 { nl, id, id2 = "\n", strings.Repeat(" ", indent), strings.Repeat(" ", indent+2) } buf.WriteString("[" + nl) for i := 0; i < v.Len(); i++ { buf.WriteString(id2) prettify(v.Index(i), indent+2, buf) if i < v.Len()-1 { buf.WriteString("," + nl) } } buf.WriteString(nl + id + "]") case reflect.Map: buf.WriteString("{\n") for i, k := range v.MapKeys() { buf.WriteString(strings.Repeat(" ", indent+2)) buf.WriteString(k.String() + ": ") prettify(v.MapIndex(k), indent+2, buf) if i < v.Len()-1 { buf.WriteString(",\n") } } buf.WriteString("\n" + strings.Repeat(" ", indent) + "}") default: if !v.IsValid() { fmt.Fprint(buf, "<invalid value>") return } format := "%v" switch v.Interface().(type) { case string: format = "%q" case io.ReadSeeker, io.Reader: format = "buffer(%p)" } fmt.Fprintf(buf, format, v.Interface()) } }	2.7 KB	2025-05-25 12:27
📄 prettify_test.go //go:build go1.7 // +build go1.7 package awsutil import ( "testing" "github.com/aws/aws-sdk-go/aws" ) type testPrettifyStruct struct { Field1 string Field2 string Field3 []byte `sensitive:"true"` Value []string } func TestPrettify(t testing.T) { cases := map[string]struct { Value interface{} Expect string }{ "general": { Value: testPrettifyStruct{ Field1: "abc123", Field2: aws.String("abc123"), Field3: []byte("don't show me"), Value: []string{ aws.String("first"), aws.String("second"), }, }, Expect: `{ Field1: "abc123", Field2: "abc123", Field3: <sensitive>, Value: ["first","second"], }`, }, } for d, c := range cases { t.Run(d, func(t *testing.T) { actual := StringValue(c.Value) if e, a := c.Expect, actual; e != a { t.Errorf("expect:\n%v\nactual:\n%v\n", e, a) } }) } }	876 B	2025-05-25 12:27
📄 string_value.go package awsutil import ( "bytes" "fmt" "reflect" "strings" ) // StringValue returns the string representation of a value. // // Deprecated: Use Prettify instead. func StringValue(i interface{}) string { var buf bytes.Buffer stringValue(reflect.ValueOf(i), 0, &buf) return buf.String() } func stringValue(v reflect.Value, indent int, buf *bytes.Buffer) { for v.Kind() == reflect.Ptr { v = v.Elem() } switch v.Kind() { case reflect.Struct: buf.WriteString("{\n") for i := 0; i < v.Type().NumField(); i++ { ft := v.Type().Field(i) fv := v.Field(i) if ft.Name[0:1] == strings.ToLower(ft.Name[0:1]) { continue // ignore unexported fields } if (fv.Kind() == reflect.Ptr \|\| fv.Kind() == reflect.Slice) && fv.IsNil() { continue // ignore unset fields } buf.WriteString(strings.Repeat(" ", indent+2)) buf.WriteString(ft.Name + ": ") if tag := ft.Tag.Get("sensitive"); tag == "true" { buf.WriteString("<sensitive>") } else { stringValue(fv, indent+2, buf) } buf.WriteString(",\n") } buf.WriteString("\n" + strings.Repeat(" ", indent) + "}") case reflect.Slice: nl, id, id2 := "", "", "" if v.Len() > 3 { nl, id, id2 = "\n", strings.Repeat(" ", indent), strings.Repeat(" ", indent+2) } buf.WriteString("[" + nl) for i := 0; i < v.Len(); i++ { buf.WriteString(id2) stringValue(v.Index(i), indent+2, buf) if i < v.Len()-1 { buf.WriteString("," + nl) } } buf.WriteString(nl + id + "]") case reflect.Map: buf.WriteString("{\n") for i, k := range v.MapKeys() { buf.WriteString(strings.Repeat(" ", indent+2)) buf.WriteString(k.String() + ": ") stringValue(v.MapIndex(k), indent+2, buf) if i < v.Len()-1 { buf.WriteString(",\n") } } buf.WriteString("\n" + strings.Repeat(" ", indent) + "}") default: format := "%v" switch v.Interface().(type) { case string: format = "%q" } fmt.Fprintf(buf, format, v.Interface()) } }	1.92 KB	2025-05-25 12:27
📄 string_value_test.go //go:build go1.7 // +build go1.7 package awsutil import ( "testing" "github.com/aws/aws-sdk-go/aws" ) type testStruct struct { Field1 string Field2 string Field3 []byte `sensitive:"true"` Value []string } func TestStringValue(t testing.T) { cases := map[string]struct { Value interface{} Expect string }{ "general": { Value: testStruct{ Field1: "abc123", Field2: aws.String("abc123"), Field3: []byte("don't show me"), Value: []string{ aws.String("first"), aws.String("second"), }, }, Expect: `{ Field1: "abc123", Field2: "abc123", Field3: <sensitive>, Value: ["first","second"], }`, }, } for d, c := range cases { t.Run(d, func(t *testing.T) { actual := StringValue(c.Value) if e, a := c.Expect, actual; e != a { t.Errorf("expect:\n%v\nactual:\n%v\n", e, a) } }) } }	863 B	2025-05-25 12:27

Terminal