Make TypedValue into an interface

This will make it easier to have another TypedValue for deduced type
that don't have to share the exact same logic, for merging and building
the set.

Author: apelisse

internal/fixture/state.go

@@ -29,7 +29,7 @@ import (
 // State of the current test in terms of live object. One can check at
 // any time that Live and Managers match the expectations.
 type State struct {
-	Live     *typed.TypedValue
+	Live     typed.TypedValue
 	Parser   typed.ParseableType
 	Managers fieldpath.ManagedFields
 	Updater  *merge.Updater
@@ -91,7 +91,7 @@ func (s *State) checkInit() error {
 		if err != nil {
 			return fmt.Errorf("failed to create new empty object: %v", err)
 		}
-		s.Live = &obj
+		s.Live = obj
 	}
 	return nil
 }
@@ -103,11 +103,11 @@ func (s *State) Update(obj typed.YAMLObject, version fieldpath.APIVersion, manag
 		return err
 	}
 	tv, err := s.Parser.FromYAML(obj)
-	managers, err := s.Updater.Update(*s.Live, tv, version, s.Managers, manager)
+	managers, err := s.Updater.Update(s.Live, tv, version, s.Managers, manager)
 	if err != nil {
 		return err
 	}
-	s.Live = &tv
+	s.Live = tv
 	s.Managers = managers
 
 	return nil
@@ -123,11 +123,11 @@ func (s *State) Apply(obj typed.YAMLObject, version fieldpath.APIVersion, manage
 	if err != nil {
 		return err
 	}
-	new, managers, err := s.Updater.Apply(*s.Live, tv, version, s.Managers, manager, force)
+	new, managers, err := s.Updater.Apply(s.Live, tv, version, s.Managers, manager, force)
 	if err != nil {
 		return err
 	}
-	s.Live = &new
+	s.Live = new
 	s.Managers = managers
 
 	return nil

merge/update.go

@@ -127,18 +127,18 @@ func (s *Updater) Update(liveObject, newObject typed.TypedValue, version fieldpa
 func (s *Updater) Apply(liveObject, configObject typed.TypedValue, version fieldpath.APIVersion, managers fieldpath.ManagedFields, manager string, force bool) (typed.TypedValue, fieldpath.ManagedFields, error) {
 	newObject, err := liveObject.Merge(configObject)
 	if err != nil {
-		return typed.TypedValue{}, fieldpath.ManagedFields{}, fmt.Errorf("failed to merge config: %v", err)
+		return nil, fieldpath.ManagedFields{}, fmt.Errorf("failed to merge config: %v", err)
 	}
 	managers, err = s.update(liveObject, newObject, version, managers, manager, force)
 	if err != nil {
-		return typed.TypedValue{}, fieldpath.ManagedFields{}, err
+		return nil, fieldpath.ManagedFields{}, err
 	}
 
 	// TODO: Remove unconflicting removed fields
 
 	set, err := configObject.ToFieldSet()
 	if err != nil {
-		return typed.TypedValue{}, fieldpath.ManagedFields{}, fmt.Errorf("failed to get field set: %v", err)
+		return nil, fieldpath.ManagedFields{}, fmt.Errorf("failed to get field set: %v", err)
 	}
 	managers[manager] = &fieldpath.VersionedSet{
 		Set:        set,

typed/parser.go

@@ -100,7 +100,7 @@ func (p *parseableType) IsValid() bool {
 func (p *parseableType) FromYAML(object YAMLObject) (TypedValue, error) {
 	v, err := value.FromYAML([]byte(object))
 	if err != nil {
-		return TypedValue{}, err
+		return nil, err
 	}
 	return AsTyped(v, &p.parser.Schema, p.typename)
 }
@@ -110,7 +110,7 @@ func (p *parseableType) FromYAML(object YAMLObject) (TypedValue, error) {
 func (p *parseableType) FromUnstructured(in interface{}) (TypedValue, error) {
 	v, err := value.FromUnstructured(in)
 	if err != nil {
-		return TypedValue{}, err
+		return nil, err
 	}
 	return AsTyped(v, &p.parser.Schema, p.typename)
 }
@@ -131,7 +131,7 @@ func (p DeducedParseableType) IsValid() bool {
 func (p DeducedParseableType) FromYAML(object YAMLObject) (TypedValue, error) {
 	v, err := value.FromYAML([]byte(object))
 	if err != nil {
-		return TypedValue{}, err
+		return nil, err
 	}
 	return AsTypedDeduced(v), nil
 }
@@ -141,7 +141,7 @@ func (p DeducedParseableType) FromYAML(object YAMLObject) (TypedValue, error) {
 func (p DeducedParseableType) FromUnstructured(in interface{}) (TypedValue, error) {
 	v, err := value.FromUnstructured(in)
 	if err != nil {
-		return TypedValue{}, err
+		return nil, err
 	}
 	return AsTypedDeduced(v), nil
 }

typed/typed.go

@@ -25,55 +25,85 @@ import (
 	"sigs.k8s.io/structured-merge-diff/value"
 )
 
-// TypedValue is a value of some specific type.
-type TypedValue struct {
-	value   value.Value
-	typeRef schema.TypeRef
-	schema  *schema.Schema
+// TypedValue is a value with an associated type.
+type TypedValue interface {
+	// AsValue removes the type from the TypedValue and only keeps the value.
+	AsValue() *value.Value
+	// Validate returns an error with a list of every spec violation.
+	Validate() error
+	// ToFieldSet creates a set containing every leaf field mentioned, or
+	// validation errors, if any were encountered.
+	ToFieldSet() (*fieldpath.Set, error)
+	// Merge returns the result of merging tv and pso ("partially specified
+	// object") together. Of note:
+	//  * No fields can be removed by this operation.
+	//  * If both tv and pso specify a given leaf field, the result will keep pso's
+	//    value.
+	//  * Container typed elements will have their items ordered:
+	//    * like tv, if pso doesn't change anything in the container
+	//    * like pso, if pso does change something in the container.
+	// tv and pso must both be of the same type (their Schema and TypeRef must
+	// match), or an error will be returned. Validation errors will be returned if
+	// the objects don't conform to the schema.
+	Merge(pso TypedValue) (TypedValue, error)
+	// Compare compares the two objects. See the comments on the `Comparison`
+	// struct for details on the return value.
+	//
+	// tv and rhs must both be of the same type (their Schema and TypeRef must
+	// match), or an error will be returned. Validation errors will be returned if
+	// the objects don't conform to the schema.
+	Compare(rhs TypedValue) (c *Comparison, err error)
 }
 
 // AsTyped accepts a value and a type and returns a TypedValue. 'v' must have
 // type 'typeName' in the schema. An error is returned if the v doesn't conform
 // to the schema.
 func AsTyped(v value.Value, s *schema.Schema, typeName string) (TypedValue, error) {
-	tv := TypedValue{
+	tv := typedValue{
 		value:   v,
 		typeRef: schema.TypeRef{NamedType: &typeName},
 		schema:  s,
 	}
 	if err := tv.Validate(); err != nil {
-		return TypedValue{}, err
+		return nil, err
 	}
 	return tv, nil
 }
 
-// AsTypedDeduced is going to generate it's own type definition based on
-// the content of the object. This is useful for CRDs that don't have a
-// validation field.
-func AsTypedDeduced(v value.Value) TypedValue {
-	return TypedValue{
-		value: v,
-		typeRef: schema.TypeRefFromValue(v),
-		schema: nil,
+// AsTypeUnvalidated is just like AsTyped, but doesn't validate that the type
+// conforms to the schema, for cases where that has already been checked or
+// where you're going to call a method that validates as a side-effect (like
+// ToFieldSet).
+func AsTypedUnvalidated(v value.Value, s *schema.Schema, typeName string) TypedValue {
+	tv := typedValue{
+		value:   v,
+		typeRef: schema.TypeRef{NamedType: &typeName},
+		schema:  s,
 	}
+	return tv
+}
+
+// typedValue is a value of some specific type.
+type typedValue struct {
+	value   value.Value
+	typeRef schema.TypeRef
+	schema  *schema.Schema
 }
 
-// AsValue removes the type from the TypedValue and only keeps the value.
-func (tv TypedValue) AsValue() *value.Value {
+var _ TypedValue = typedValue{}
+
+func (tv typedValue) AsValue() *value.Value {
 	return &tv.value
 }
 
-// Validate returns an error with a list of every spec violation.
-func (tv TypedValue) Validate() error {
+func (tv typedValue) Validate() error {
 	if errs := tv.walker().validate(); len(errs) != 0 {
 		return errs
 	}
 	return nil
 }
 
-// ToFieldSet creates a set containing every leaf field mentioned in tv, or
-// validation errors, if any were encountered.
-func (tv TypedValue) ToFieldSet() (*fieldpath.Set, error) {
+func (tv typedValue) ToFieldSet() (*fieldpath.Set, error) {
 	s := fieldpath.NewSet()
 	w := tv.walker()
 	w.leafFieldCallback = func(p fieldpath.Path) { s.Insert(p) }
@@ -83,73 +113,27 @@ func (tv TypedValue) ToFieldSet() (*fieldpath.Set, error) {
 	return s, nil
 }
 
-// Merge returns the result of merging tv and pso ("partially specified
-// object") together. Of note:
-//  * No fields can be removed by this operation.
-//  * If both tv and pso specify a given leaf field, the result will keep pso's
-//    value.
-//  * Container typed elements will have their items ordered:
-//    * like tv, if pso doesn't change anything in the container
-//    * like pso, if pso does change something in the container.
-// tv and pso must both be of the same type (their Schema and TypeRef must
-// match), or an error will be returned. Validation errors will be returned if
-// the objects don't conform to the schema.
-func (tv TypedValue) Merge(pso TypedValue) (TypedValue, error) {
-	return merge(tv, pso, ruleKeepRHS, nil)
-}
-
-// Comparison is the return value of a TypedValue.Compare() operation.
-//
-// No field will appear in more than one of the three fieldsets. If all of the
-// fieldsets are empty, then the objects must have been equal.
-type Comparison struct {
-	// Merged is the result of merging the two objects, as explained in the
-	// comments on TypedValue.Merge().
-	Merged TypedValue
-
-	// Removed contains any fields removed by rhs (the right-hand-side
-	// object in the comparison).
-	Removed *fieldpath.Set
-	// Modified contains fields present in both objects but different.
-	Modified *fieldpath.Set
-	// Added contains any fields added by rhs.
-	Added *fieldpath.Set
-}
-
-// IsSame returns true if the comparison returned no changes (the two
-// compared objects are similar).
-func (c *Comparison) IsSame() bool {
-	return c.Removed.Empty() && c.Modified.Empty() && c.Added.Empty()
-}
-
-// String returns a human readable version of the comparison.
-func (c *Comparison) String() string {
-	str := fmt.Sprintf("- Merged Object:\n%v\n", c.Merged.AsValue())
-	if !c.Modified.Empty() {
-		str += fmt.Sprintf("- Modified Fields:\n%v\n", c.Modified)
-	}
-	if !c.Added.Empty() {
-		str += fmt.Sprintf("- Added Fields:\n%v\n", c.Added)
+func (tv typedValue) Merge(pso TypedValue) (TypedValue, error) {
+	tpso, ok := pso.(typedValue)
+	if !ok {
+		return nil, errorFormatter{}.
+			errorf("can't merge typedValue with %T", pso)
 	}
-	if !c.Removed.Empty() {
-		str += fmt.Sprintf("- Removed Fields:\n%v\n", c.Removed)
-	}
-	return str
+	return merge(tv, tpso, ruleKeepRHS, nil)
 }
 
-// Compare compares the two objects. See the comments on the `Comparison`
-// struct for details on the return value.
-//
-// tv and rhs must both be of the same type (their Schema and TypeRef must
-// match), or an error will be returned. Validation errors will be returned if
-// the objects don't conform to the schema.
-func (tv TypedValue) Compare(rhs TypedValue) (c *Comparison, err error) {
+func (tv typedValue) Compare(rhs TypedValue) (c *Comparison, err error) {
+	trhs, ok := rhs.(typedValue)
+	if !ok {
+		return nil, errorFormatter{}.
+			errorf("can't compare typedValue with %T", rhs)
+	}
 	c = &Comparison{
 		Removed:  fieldpath.NewSet(),
 		Modified: fieldpath.NewSet(),
 		Added:    fieldpath.NewSet(),
 	}
-	c.Merged, err = merge(tv, rhs, func(w *mergingWalker) {
+	c.Merged, err = merge(tv, trhs, func(w *mergingWalker) {
 		if w.lhs == nil {
 			c.Added.Insert(w.path)
 		} else if w.rhs == nil {
@@ -175,13 +159,13 @@ func (tv TypedValue) Compare(rhs TypedValue) (c *Comparison, err error) {
 	return c, nil
 }
 
-func merge(lhs, rhs TypedValue, rule, postRule mergeRule) (TypedValue, error) {
+func merge(lhs, rhs typedValue, rule, postRule mergeRule) (TypedValue, error) {
 	if lhs.schema != rhs.schema {
-		return TypedValue{}, errorFormatter{}.
+		return nil, errorFormatter{}.
 			errorf("expected objects with types from the same schema")
 	}
 	if !reflect.DeepEqual(lhs.typeRef, rhs.typeRef) {
-		return TypedValue{}, errorFormatter{}.
+		return nil, errorFormatter{}.
 			errorf("expected objects of the same type, but got %v and %v", lhs.typeRef, rhs.typeRef)
 	}
 
@@ -195,10 +179,10 @@ func merge(lhs, rhs TypedValue, rule, postRule mergeRule) (TypedValue, error) {
 	}
 	errs := mw.merge()
 	if len(errs) > 0 {
-		return TypedValue{}, errs
+		return nil, errs
 	}
 
-	out := TypedValue{
+	out := typedValue{
 		schema:  lhs.schema,
 		typeRef: lhs.typeRef,
 	}
@@ -210,15 +194,41 @@ func merge(lhs, rhs TypedValue, rule, postRule mergeRule) (TypedValue, error) {
 	return out, nil
 }
 
-// AsTypeUnvalidated is just like WithType, but doesn't validate that the type
-// conforms to the schema, for cases where that has already been checked or
-// where you're going to call a method that validates as a side-effect (like
-// ToFieldSet).
-func AsTypedUnvalidated(v value.Value, s *schema.Schema, typeName string) TypedValue {
-	tv := TypedValue{
-		value:   v,
-		typeRef: schema.TypeRef{NamedType: &typeName},
-		schema:  s,
+// Comparison is the return value of a TypedValue.Compare() operation.
+//
+// No field will appear in more than one of the three fieldsets. If all of the
+// fieldsets are empty, then the objects must have been equal.
+type Comparison struct {
+	// Merged is the result of merging the two objects, as explained in the
+	// comments on TypedValue.Merge().
+	Merged TypedValue
+
+	// Removed contains any fields removed by rhs (the right-hand-side
+	// object in the comparison).
+	Removed *fieldpath.Set
+	// Modified contains fields present in both objects but different.
+	Modified *fieldpath.Set
+	// Added contains any fields added by rhs.
+	Added *fieldpath.Set
+}
+
+// IsSame returns true if the comparison returned no changes (the two
+// compared objects are similar).
+func (c *Comparison) IsSame() bool {
+	return c.Removed.Empty() && c.Modified.Empty() && c.Added.Empty()
+}
+
+// String returns a human readable version of the comparison.
+func (c *Comparison) String() string {
+	str := fmt.Sprintf("- Merged Object:\n%v\n", c.Merged.AsValue())
+	if !c.Modified.Empty() {
+		str += fmt.Sprintf("- Modified Fields:\n%v\n", c.Modified)
 	}
-	return tv
+	if !c.Added.Empty() {
+		str += fmt.Sprintf("- Added Fields:\n%v\n", c.Added)
+	}
+	if !c.Removed.Empty() {
+		str += fmt.Sprintf("- Removed Fields:\n%v\n", c.Removed)
+	}
+	return str
 }

typed/validate.go

@@ -22,7 +22,7 @@ import (
 	"sigs.k8s.io/structured-merge-diff/value"
 )
 
-func (tv TypedValue) walker() *validatingObjectWalker {
+func (tv typedValue) walker() *validatingObjectWalker {
 	return &validatingObjectWalker{
 		value:   tv.value,
 		schema:  tv.schema,