Rename "Interface" into "Unstructured"

Interface can mean too many things, while unstructured has this
kubernetes meaning of "map[string]interface{}" types of objects.

Author: Antoine Pelisse

internal/cli/operation.go

@@ -114,7 +114,7 @@ func (m merge) Execute(w io.Writer) error {
 		return err
 	}
 
-	yaml, err := yaml.Marshal(out.AsValue().Interface())
+	yaml, err := yaml.Marshal(out.AsValue().Unstructured())
 	if err != nil {
 		return err
 	}

merge/multiple_appliers_test.go

@@ -985,7 +985,7 @@ func (r repeatingConverter) Convert(v *typed.TypedValue, version fieldpath.APIVe
 	if err != nil {
 		return nil, missingVersionError
 	}
-	y, err := yaml.Marshal(v.AsValue().Interface())
+	y, err := yaml.Marshal(v.AsValue().Unstructured())
 	if err != nil {
 		return nil, err
 	}

typed/merge.go

@@ -58,10 +58,10 @@ type mergeRule func(w *mergingWalker)
 var (
 	ruleKeepRHS = mergeRule(func(w *mergingWalker) {
 		if w.rhs != nil {
-			v := w.rhs.Interface()
+			v := w.rhs.Unstructured()
 			w.out = &v
 		} else if w.lhs != nil {
-			v := w.lhs.Interface()
+			v := w.lhs.Unstructured()
 			w.out = &v
 		}
 	})

typed/remove.go

@@ -37,7 +37,7 @@ func removeItemsWithSchema(val value.Value, toRemove *fieldpath.Set, schema *sch
 }
 
 func (w *removingWalker) doScalar(t *schema.Scalar) ValidationErrors {
-	w.out = w.value.Interface()
+	w.out = w.value.Unstructured()
 	return nil
 }
 
@@ -61,7 +61,7 @@ func (w *removingWalker) doList(t *schema.List) (errs ValidationErrors) {
 		if subset := w.toRemove.WithPrefix(pe); !subset.Empty() {
 			item = removeItemsWithSchema(item, subset, w.schema, t.ElementType)
 		}
-		newItems = append(newItems, item.Interface())
+		newItems = append(newItems, item.Unstructured())
 	}
 	if len(newItems) > 0 {
 		w.out = newItems
@@ -97,7 +97,7 @@ func (w *removingWalker) doMap(t *schema.Map) ValidationErrors {
 		if subset := w.toRemove.WithPrefix(pe); !subset.Empty() {
 			val = removeItemsWithSchema(val, subset, w.schema, fieldType)
 		}
-		newMap[k] = val.Interface()
+		newMap[k] = val.Unstructured()
 		return true
 	})
 	if len(newMap) > 0 {

typed/typed.go

@@ -158,7 +158,7 @@ func (tv TypedValue) NormalizeUnions(new *TypedValue) (*TypedValue, error) {
 	var errs ValidationErrors
 	var normalizeFn = func(w *mergingWalker) {
 		if w.rhs != nil {
-			v := w.rhs.Interface()
+			v := w.rhs.Unstructured()
 			w.out = &v
 		}
 		if err := normalizeUnions(w); err != nil {
@@ -184,7 +184,7 @@ func (tv TypedValue) NormalizeUnionsApply(new *TypedValue) (*TypedValue, error)
 	var errs ValidationErrors
 	var normalizeFn = func(w *mergingWalker) {
 		if w.rhs != nil {
-			v := w.rhs.Interface()
+			v := w.rhs.Unstructured()
 			w.out = &v
 		}
 		if err := normalizeUnionsApply(w); err != nil {

typed/union.go

@@ -66,7 +66,7 @@ func normalizeUnionsApply(w *mergingWalker) error {
 		if err := newUnion(&union).NormalizeApply(old, w.rhs.Map(), out.Map()); err != nil {
 			return err
 		}
-		*w.out = out.Interface()
+		*w.out = out.Unstructured()
 	}
 	return nil
 }

value/listinterface.go renamed to value/listunstructured.go

@@ -16,12 +16,12 @@ limitations under the License.
 
 package value
 
-type listInterface []interface{}
+type listUnstructured []interface{}
 
-func (l listInterface) Length() int {
+func (l listUnstructured) Length() int {
 	return len(l)
 }
 
-func (l listInterface) At(i int) Value {
+func (l listUnstructured) At(i int) Value {
 	return NewValueInterface(l[i])
 }

value/mapinterface.go renamed to value/mapunstructured.go

@@ -16,25 +16,25 @@ limitations under the License.
 
 package value
 
-type mapInterface map[interface{}]interface{}
+type mapUnstructuredInterface map[interface{}]interface{}
 
-func (m mapInterface) Set(key string, val Value) {
-	m[key] = val.Interface()
+func (m mapUnstructuredInterface) Set(key string, val Value) {
+	m[key] = val.Unstructured()
 }
 
-func (m mapInterface) Get(key string) (Value, bool) {
+func (m mapUnstructuredInterface) Get(key string) (Value, bool) {
 	if v, ok := m[key]; !ok {
 		return nil, false
 	} else {
 		return NewValueInterface(v), true
 	}
 }
 
-func (m mapInterface) Delete(key string) {
+func (m mapUnstructuredInterface) Delete(key string) {
 	delete(m, key)
 }
 
-func (m mapInterface) Iterate(fn func(key string, value Value) bool) bool {
+func (m mapUnstructuredInterface) Iterate(fn func(key string, value Value) bool) bool {
 	for k, v := range m {
 		if ks, ok := k.(string); !ok {
 			continue
@@ -50,11 +50,11 @@ func (m mapInterface) Iterate(fn func(key string, value Value) bool) bool {
 	return true
 }
 
-func (m mapInterface) Length() int {
+func (m mapUnstructuredInterface) Length() int {
 	return len(m)
 }
 
-func (m mapInterface) Equals(other Map) bool {
+func (m mapUnstructuredInterface) Equals(other Map) bool {
 	if m.Length() != other.Length() {
 		return false
 	}
@@ -79,25 +79,25 @@ func (m mapInterface) Equals(other Map) bool {
 	return true
 }
 
-type mapString map[string]interface{}
+type mapUnstructuredString map[string]interface{}
 
-func (m mapString) Set(key string, val Value) {
-	m[key] = val.Interface()
+func (m mapUnstructuredString) Set(key string, val Value) {
+	m[key] = val.Unstructured()
 }
 
-func (m mapString) Get(key string) (Value, bool) {
+func (m mapUnstructuredString) Get(key string) (Value, bool) {
 	if v, ok := m[key]; !ok {
 		return nil, false
 	} else {
 		return NewValueInterface(v), true
 	}
 }
 
-func (m mapString) Delete(key string) {
+func (m mapUnstructuredString) Delete(key string) {
 	delete(m, key)
 }
 
-func (m mapString) Iterate(fn func(key string, value Value) bool) bool {
+func (m mapUnstructuredString) Iterate(fn func(key string, value Value) bool) bool {
 	for k, v := range m {
 		vv := NewValueInterface(v)
 		if !fn(k, vv) {
@@ -109,11 +109,11 @@ func (m mapString) Iterate(fn func(key string, value Value) bool) bool {
 	return true
 }
 
-func (m mapString) Length() int {
+func (m mapUnstructuredString) Length() int {
 	return len(m)
 }
 
-func (m mapString) Equals(other Map) bool {
+func (m mapUnstructuredString) Equals(other Map) bool {
 	if m.Length() != other.Length() {
 		return false
 	}

value/value.go

@@ -72,8 +72,8 @@ type Value interface {
 	// value shouldn't be used after this call.
 	Recycle()
 
-	// Converts the Value into an interface{}.
-	Interface() interface{}
+	// Converts the Value into an Unstructured interface{}.
+	Unstructured() interface{}
 }
 
 // FromJSON is a helper function for reading a JSON document.
@@ -115,7 +115,7 @@ func ReadJSONIter(iter *jsoniter.Iterator) (Value, error) {
 
 // WriteJSONStream writes a value into a JSON stream.
 func WriteJSONStream(v Value, stream *jsoniter.Stream) {
-	stream.WriteVal(v.Interface())
+	stream.WriteVal(v.Unstructured())
 }
 
 // Equals returns true iff the two values are equal.

value/valueinterface.go renamed to value/valueunstructured.go

@@ -23,23 +23,23 @@ import (
 
 var viPool = sync.Pool{
 	New: func() interface{} {
-		return &valueInterface{}
+		return &valueUnstructured{}
 	},
 }
 
 // NewValueInterface creates a Value backed by an "interface{}" type,
 // typically an unstructured object in Kubernetes world.
 func NewValueInterface(v interface{}) Value {
-	vi := viPool.Get().(*valueInterface)
+	vi := viPool.Get().(*valueUnstructured)
 	vi.Value = v
 	return Value(vi)
 }
 
-type valueInterface struct {
+type valueUnstructured struct {
 	Value interface{}
 }
 
-func (v valueInterface) IsMap() bool {
+func (v valueUnstructured) IsMap() bool {
 	if _, ok := v.Value.(map[string]interface{}); ok {
 		return true
 	}
@@ -49,32 +49,32 @@ func (v valueInterface) IsMap() bool {
 	return false
 }
 
-func (v valueInterface) Map() Map {
+func (v valueUnstructured) Map() Map {
 	if v.Value == nil {
 		return nil
 	}
 	switch t := v.Value.(type) {
 	case map[string]interface{}:
-		return mapString(t)
+		return mapUnstructuredString(t)
 	case map[interface{}]interface{}:
-		return mapInterface(t)
+		return mapUnstructuredInterface(t)
 	}
 	panic(fmt.Errorf("not a map: %#v", v))
 }
 
-func (v valueInterface) IsList() bool {
+func (v valueUnstructured) IsList() bool {
 	if v.Value == nil {
 		return false
 	}
 	_, ok := v.Value.([]interface{})
 	return ok
 }
 
-func (v valueInterface) List() List {
-	return listInterface(v.Value.([]interface{}))
+func (v valueUnstructured) List() List {
+	return listUnstructured(v.Value.([]interface{}))
 }
 
-func (v valueInterface) IsFloat() bool {
+func (v valueUnstructured) IsFloat() bool {
 	if v.Value == nil {
 		return false
 	} else if _, ok := v.Value.(float64); ok {
@@ -85,14 +85,14 @@ func (v valueInterface) IsFloat() bool {
 	return false
 }
 
-func (v valueInterface) Float() float64 {
+func (v valueUnstructured) Float() float64 {
 	if f, ok := v.Value.(float32); ok {
 		return float64(f)
 	}
 	return v.Value.(float64)
 }
 
-func (v valueInterface) IsInt() bool {
+func (v valueUnstructured) IsInt() bool {
 	if v.Value == nil {
 		return false
 	} else if _, ok := v.Value.(int); ok {
@@ -117,7 +117,7 @@ func (v valueInterface) IsInt() bool {
 	return false
 }
 
-func (v valueInterface) Int() int64 {
+func (v valueUnstructured) Int() int64 {
 	if i, ok := v.Value.(int); ok {
 		return int64(i)
 	} else if i, ok := v.Value.(int8); ok {
@@ -138,38 +138,38 @@ func (v valueInterface) Int() int64 {
 	return v.Value.(int64)
 }
 
-func (v valueInterface) IsString() bool {
+func (v valueUnstructured) IsString() bool {
 	if v.Value == nil {
 		return false
 	}
 	_, ok := v.Value.(string)
 	return ok
 }
 
-func (v valueInterface) String() string {
+func (v valueUnstructured) String() string {
 	return v.Value.(string)
 }
 
-func (v valueInterface) IsBool() bool {
+func (v valueUnstructured) IsBool() bool {
 	if v.Value == nil {
 		return false
 	}
 	_, ok := v.Value.(bool)
 	return ok
 }
 
-func (v valueInterface) Bool() bool {
+func (v valueUnstructured) Bool() bool {
 	return v.Value.(bool)
 }
 
-func (v valueInterface) IsNull() bool {
+func (v valueUnstructured) IsNull() bool {
 	return v.Value == nil
 }
 
-func (v *valueInterface) Recycle() {
+func (v *valueUnstructured) Recycle() {
 	viPool.Put(v)
 }
 
-func (v valueInterface) Interface() interface{} {
+func (v valueUnstructured) Unstructured() interface{} {
 	return v.Value
 }