Merge pull request #73 from jennybuckley/anyof-atom

Support atoms with multiple types

Author: apelisse

merge/multiple_appliers_test.go

@@ -684,6 +684,120 @@ func TestMultipleAppliersNestedType(t *testing.T) {
 	}
 }
 
+func TestMultipleAppliersDeducedType(t *testing.T) {
+	tests := map[string]TestCase{
+		"multiple_appliers_recursive_map_deduced": {
+			Ops: []Operation{
+				Apply{
+					Manager: "apply-one",
+					Object: `
+						a:
+						  b:
+						c:
+						  d:
+					`,
+					APIVersion: "v1",
+				},
+				Apply{
+					Manager: "apply-two",
+					Object: `
+						a:
+						c:
+						  d:
+					`,
+					APIVersion: "v2",
+				},
+				Update{
+					Manager: "controller-one",
+					Object: `
+						a:
+						  b:
+						    c:
+						c:
+						  d:
+						    e:
+					`,
+					APIVersion: "v3",
+				},
+				Update{
+					Manager: "controller-two",
+					Object: `
+						a:
+						  b:
+						    c:
+						      d:
+						c:
+						  d:
+						    e:
+						      f:
+					`,
+					APIVersion: "v2",
+				},
+				Update{
+					Manager: "controller-one",
+					Object: `
+						a:
+						  b:
+						    c:
+						      d:
+						        e:
+						c:
+						  d:
+						    e:
+						      f:
+						        g:
+					`,
+					APIVersion: "v3",
+				},
+				Apply{
+					Manager:    "apply-one",
+					Object:     ``,
+					APIVersion: "v4",
+				},
+			},
+			Object: `
+				a:
+				c:
+				  d:
+				    e:
+				      f:
+				        g:
+			`,
+			Managed: fieldpath.ManagedFields{
+				"apply-two": &fieldpath.VersionedSet{
+					Set: _NS(
+						_P("a"),
+						_P("c"),
+						_P("c", "d"),
+					),
+					APIVersion: "v2",
+				},
+				"controller-one": &fieldpath.VersionedSet{
+					Set: _NS(
+						_P("c", "d", "e"),
+						_P("c", "d", "e", "f", "g"),
+					),
+					APIVersion: "v3",
+				},
+				"controller-two": &fieldpath.VersionedSet{
+					Set: _NS(
+						_P("c", "d", "e", "f"),
+					),
+					APIVersion: "v2",
+				},
+			},
+		},
+	}
+
+	for name, test := range tests {
+		t.Run(name, func(t *testing.T) {
+			if err := test.Test(typed.DeducedParseableType); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
 func TestMultipleAppliersRealConversion(t *testing.T) {
 	tests := map[string]TestCase{
 		"multiple_appliers_recursive_map_real_conversion": {

schema/elements.go

@@ -16,8 +16,6 @@ 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"`
@@ -45,13 +43,15 @@ type TypeRef struct {
 }
 
 // Atom represents the smallest possible pieces of the type system.
+// Each set field in the Atom represents a possible type for the object.
+// If none of the fields are set, any object will fail validation against the atom.
 type Atom struct {
-	// Exactly one of the below must be set.
-	*Scalar  `yaml:"scalar,omitempty"`
-	*Struct  `yaml:"struct,omitempty"`
-	*List    `yaml:"list,omitempty"`
-	*Map     `yaml:"map,omitempty"`
-	*Untyped `yaml:"untyped,omitempty"`
+	*Scalar `yaml:"scalar,omitempty"`
+	*List   `yaml:"list,omitempty"`
+
+	// At most, one of the below must be set, since both look the same when serialized
+	*Struct `yaml:"struct,omitempty"`
+	*Map    `yaml:"map,omitempty"`
 }
 
 // Scalar (AKA "primitive") represents a type which has a single value which is
@@ -67,20 +67,18 @@ const (
 )
 
 // ElementRelationship is an enum of the different possible relationships
-// between the elements of container types (maps, lists, structs, untyped).
+// between the elements of container types (maps, lists, structs).
 type ElementRelationship string
 
 const (
 	// Associative only applies to lists (see the documentation there).
 	Associative = ElementRelationship("associative")
-	// Atomic makes container types (lists, maps, structs, untyped) behave
-	// as scalars / leaf fields (which is the default for untyped data).
+	// Atomic makes container types (lists, maps, structs) behave
+	// as scalars / leaf fields
 	Atomic = ElementRelationship("atomic")
 	// 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.
@@ -179,50 +177,6 @@ type Map struct {
 	ElementRelationship ElementRelationship `yaml:"elementRelationship,omitempty"`
 }
 
-// Untyped represents types that allow arbitrary content. (Think: plugin
-// objects.)
-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)
-	// 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) {

schema/elements_test.go

@@ -53,7 +53,7 @@ func TestFindNamedType(t *testing.T) {
 func TestResolve(t *testing.T) {
 	existing := "existing"
 	notExisting := "not-existing"
-	a := Atom{Untyped: &Untyped{}}
+	a := Atom{List: &List{}}
 
 	tests := []struct {
 		testName       string