Make deduced types use the same parser

Author: jennybuckley

merge/deduced_test.go

@@ -168,7 +168,7 @@ func TestDeduced(t *testing.T) {
 				},
 			},
 		},
-		"leaf_apply_twice_dangling": {
+		"leaf_apply_twice_remove": {
 			Ops: []Operation{
 				Apply{
 					Manager:    "default",
@@ -188,9 +188,7 @@ func TestDeduced(t *testing.T) {
 				},
 			},
 			Object: `
-				numeric: 1
 				string: "new string"
-				bool: false
 			`,
 			Managed: fieldpath.ManagedFields{
 				"default": &fieldpath.VersionedSet{
@@ -328,9 +326,7 @@ func TestDeduced(t *testing.T) {
 					Object:     ``,
 				},
 			},
-			Object: `
-				string: "string"
-			`,
+			Object:  ``,
 			Managed: fieldpath.ManagedFields{},
 		},
 		"apply_update_apply_nested": {
@@ -523,7 +519,7 @@ func TestDeduced(t *testing.T) {
 
 	for name, test := range tests {
 		t.Run(name, func(t *testing.T) {
-			if err := test.Test(typed.DeducedParseableType{}); err != nil {
+			if err := test.Test(typed.DeducedParseableType); err != nil {
 				t.Fatal(err)
 			}
 		})

merge/obsolete_versions_test.go

@@ -53,7 +53,7 @@ func TestObsoleteVersions(t *testing.T) {
 	}
 	state := fixture.State{
 		Updater: &merge.Updater{Converter: converter},
-		Parser:  typed.DeducedParseableType{},
+		Parser:  typed.DeducedParseableType,
 	}
 
 	if err := state.Update(typed.YAMLObject(`{"v1": 0}`), fieldpath.APIVersion("v1"), "v1"); err != nil {

schema/elements.go

@@ -16,6 +16,8 @@ limitations under the License.
 
 package schema
 
+import "sigs.k8s.io/structured-merge-diff/value"
+
 // Schema is a list of named types.
 type Schema struct {
 	Types []TypeDef `yaml:"types,omitempty"`
@@ -77,6 +79,8 @@ const (
 	// Separable means the items of the container type have no particular
 	// relationship (default behavior for maps and structs).
 	Separable = ElementRelationship("separable")
+	// Deduced only applies to untyped (see the documentation there).
+	Deduced = ElementRelationship("deduced")
 )
 
 // Struct represents a type which is composed of a number of different fields.
@@ -180,17 +184,45 @@ type Map struct {
 type Untyped struct {
 	// ElementRelationship states the relationship between the items, if
 	// container-typed data happens to be present here.
+	// * `deduced` implies that the behavior is based on the type of data.
+	//   Structs and maps are both treated as a `separable` Map with `deduced` Untyped elements.
+	//   Lists and Scalars are both treated as an `atomic` Untyped.
 	// * `atomic` implies that all elements depend on each other, and this
 	//   is effectively a scalar / leaf field; it doesn't make sense for
 	//   separate actors to set the elements.
 	// TODO: support "guess" (guesses at associative list keys)
-	// TODO: support "lookup" (calls a lookup function to figure out the
-	//       schema based on the data)
 	// The default behavior for untyped data is `atomic`; it's permitted to
 	// leave this unset to get the default behavior.
 	ElementRelationship ElementRelationship `yaml:"elementRelationship,omitempty"`
 }
 
+// DeduceType determines the behavior based on a value.
+func DeduceType(v *value.Value) TypeRef {
+	if v != nil && v.MapValue != nil {
+		return TypeRef{
+			Inlined: Atom{
+				Map: &Map{
+					ElementType: TypeRef{
+						Inlined: Atom{
+							Untyped: &Untyped{
+								ElementRelationship: Deduced,
+							},
+						},
+					},
+					ElementRelationship: Separable,
+				},
+			},
+		}
+	}
+	return TypeRef{
+		Inlined: Atom{
+			Untyped: &Untyped{
+				ElementRelationship: Atomic,
+			},
+		},
+	}
+}
+
 // FindNamedType is a convenience function that returns the referenced TypeDef,
 // if it exists, or (nil, false) if it doesn't.
 func (s Schema) FindNamedType(name string) (TypeDef, bool) {