mirror of
https://github.com/letic/terraform-provider-google.git
synced 2024-09-07 01:26:43 +00:00
![Paddy](/assets/img/avatar_default.png)
Switch to using Go modules. This migrates our vendor.json to use Go 1.11's modules system, and replaces the vendor folder with the output of go mod vendor. The vendored code should remain basically the same; I believe some tree shaking of packages and support scripts/licenses/READMEs/etc. happened. This also fixes Travis and our Makefile to no longer use govendor.
183 lines
5.0 KiB
Go
183 lines
5.0 KiB
Go
package cty
|
|
|
|
// Walk visits all of the values in a possibly-complex structure, calling
|
|
// a given function for each value.
|
|
//
|
|
// For example, given a list of strings the callback would first be called
|
|
// with the whole list and then called once for each element of the list.
|
|
//
|
|
// The callback function may prevent recursive visits to child values by
|
|
// returning false. The callback function my halt the walk altogether by
|
|
// returning a non-nil error. If the returned error is about the element
|
|
// currently being visited, it is recommended to use the provided path
|
|
// value to produce a PathError describing that context.
|
|
//
|
|
// The path passed to the given function may not be used after that function
|
|
// returns, since its backing array is re-used for other calls.
|
|
func Walk(val Value, cb func(Path, Value) (bool, error)) error {
|
|
var path Path
|
|
return walk(path, val, cb)
|
|
}
|
|
|
|
func walk(path Path, val Value, cb func(Path, Value) (bool, error)) error {
|
|
deeper, err := cb(path, val)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !deeper {
|
|
return nil
|
|
}
|
|
|
|
if val.IsNull() || !val.IsKnown() {
|
|
// Can't recurse into null or unknown values, regardless of type
|
|
return nil
|
|
}
|
|
|
|
ty := val.Type()
|
|
switch {
|
|
case ty.IsObjectType():
|
|
for it := val.ElementIterator(); it.Next(); {
|
|
nameVal, av := it.Element()
|
|
path := append(path, GetAttrStep{
|
|
Name: nameVal.AsString(),
|
|
})
|
|
err := walk(path, av, cb)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
case val.CanIterateElements():
|
|
for it := val.ElementIterator(); it.Next(); {
|
|
kv, ev := it.Element()
|
|
path := append(path, IndexStep{
|
|
Key: kv,
|
|
})
|
|
err := walk(path, ev, cb)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Transform visits all of the values in a possibly-complex structure,
|
|
// calling a given function for each value which has an opportunity to
|
|
// replace that value.
|
|
//
|
|
// Unlike Walk, Transform visits child nodes first, so for a list of strings
|
|
// it would first visit the strings and then the _new_ list constructed
|
|
// from the transformed values of the list items.
|
|
//
|
|
// This is useful for creating the effect of being able to make deep mutations
|
|
// to a value even though values are immutable. However, it's the responsibility
|
|
// of the given function to preserve expected invariants, such as homogenity of
|
|
// element types in collections; this function can panic if such invariants
|
|
// are violated, just as if new values were constructed directly using the
|
|
// value constructor functions. An easy way to preserve invariants is to
|
|
// ensure that the transform function never changes the value type.
|
|
//
|
|
// The callback function my halt the walk altogether by
|
|
// returning a non-nil error. If the returned error is about the element
|
|
// currently being visited, it is recommended to use the provided path
|
|
// value to produce a PathError describing that context.
|
|
//
|
|
// The path passed to the given function may not be used after that function
|
|
// returns, since its backing array is re-used for other calls.
|
|
func Transform(val Value, cb func(Path, Value) (Value, error)) (Value, error) {
|
|
var path Path
|
|
return transform(path, val, cb)
|
|
}
|
|
|
|
func transform(path Path, val Value, cb func(Path, Value) (Value, error)) (Value, error) {
|
|
ty := val.Type()
|
|
var newVal Value
|
|
|
|
switch {
|
|
|
|
case val.IsNull() || !val.IsKnown():
|
|
// Can't recurse into null or unknown values, regardless of type
|
|
newVal = val
|
|
|
|
case ty.IsListType() || ty.IsSetType() || ty.IsTupleType():
|
|
l := val.LengthInt()
|
|
switch l {
|
|
case 0:
|
|
// No deep transform for an empty sequence
|
|
newVal = val
|
|
default:
|
|
elems := make([]Value, 0, l)
|
|
for it := val.ElementIterator(); it.Next(); {
|
|
kv, ev := it.Element()
|
|
path := append(path, IndexStep{
|
|
Key: kv,
|
|
})
|
|
newEv, err := transform(path, ev, cb)
|
|
if err != nil {
|
|
return DynamicVal, err
|
|
}
|
|
elems = append(elems, newEv)
|
|
}
|
|
switch {
|
|
case ty.IsListType():
|
|
newVal = ListVal(elems)
|
|
case ty.IsSetType():
|
|
newVal = SetVal(elems)
|
|
case ty.IsTupleType():
|
|
newVal = TupleVal(elems)
|
|
default:
|
|
panic("unknown sequence type") // should never happen because of the case we are in
|
|
}
|
|
}
|
|
|
|
case ty.IsMapType():
|
|
l := val.LengthInt()
|
|
switch l {
|
|
case 0:
|
|
// No deep transform for an empty map
|
|
newVal = val
|
|
default:
|
|
elems := make(map[string]Value)
|
|
for it := val.ElementIterator(); it.Next(); {
|
|
kv, ev := it.Element()
|
|
path := append(path, IndexStep{
|
|
Key: kv,
|
|
})
|
|
newEv, err := transform(path, ev, cb)
|
|
if err != nil {
|
|
return DynamicVal, err
|
|
}
|
|
elems[kv.AsString()] = newEv
|
|
}
|
|
newVal = MapVal(elems)
|
|
}
|
|
|
|
case ty.IsObjectType():
|
|
switch {
|
|
case ty.Equals(EmptyObject):
|
|
// No deep transform for an empty object
|
|
newVal = val
|
|
default:
|
|
atys := ty.AttributeTypes()
|
|
newAVs := make(map[string]Value)
|
|
for name := range atys {
|
|
av := val.GetAttr(name)
|
|
path := append(path, GetAttrStep{
|
|
Name: name,
|
|
})
|
|
newAV, err := transform(path, av, cb)
|
|
if err != nil {
|
|
return DynamicVal, err
|
|
}
|
|
newAVs[name] = newAV
|
|
}
|
|
newVal = ObjectVal(newAVs)
|
|
}
|
|
|
|
default:
|
|
newVal = val
|
|
}
|
|
|
|
return cb(path, newVal)
|
|
}
|