From af6d4c09b166ca09726e9fd4adff20af20e78ba7 Mon Sep 17 00:00:00 2001 From: Antoine Pelisse Date: Mon, 23 Dec 2019 16:25:21 -0800 Subject: [PATCH 1/7] Change import for release-v2 branch to v2 --- fieldpath/element.go | 2 +- fieldpath/element_test.go | 2 +- fieldpath/fromvalue.go | 2 +- fieldpath/fromvalue_test.go | 2 +- fieldpath/managers_test.go | 2 +- fieldpath/path.go | 2 +- fieldpath/path_test.go | 2 +- fieldpath/pathelementmap.go | 2 +- fieldpath/pathelementmap_test.go | 2 +- fieldpath/serialize-pe.go | 2 +- fieldpath/set_test.go | 2 +- go.mod | 4 +++- internal/cli/operation.go | 2 +- internal/cli/options.go | 2 +- internal/fixture/state.go | 6 +++--- internal/fixture/state_test.go | 2 +- merge/conflict.go | 2 +- merge/conflict_test.go | 6 +++--- merge/deduced_test.go | 8 ++++---- merge/key_test.go | 6 +++--- merge/leaf_test.go | 8 ++++---- merge/multiple_appliers_test.go | 8 ++++---- merge/nested_test.go | 6 +++--- merge/obsolete_versions_test.go | 8 ++++---- merge/preserve_unknown_test.go | 6 +++--- merge/real_test.go | 4 ++-- merge/set_test.go | 6 +++--- merge/union_test.go | 8 ++++---- merge/update.go | 4 ++-- smd/main.go | 2 +- typed/deduced_test.go | 2 +- typed/helpers.go | 6 +++--- typed/merge.go | 6 +++--- typed/merge_test.go | 2 +- typed/parser.go | 4 ++-- typed/parser_test.go | 2 +- typed/remove.go | 6 +++--- typed/symdiff_test.go | 4 ++-- typed/toset_test.go | 6 +++--- typed/typed.go | 6 +++--- typed/union.go | 4 ++-- typed/union_test.go | 2 +- typed/validate.go | 6 +++--- typed/validate_test.go | 4 ++-- 44 files changed, 91 insertions(+), 89 deletions(-) diff --git a/fieldpath/element.go b/fieldpath/element.go index 841558a6..c471241a 100644 --- a/fieldpath/element.go +++ b/fieldpath/element.go @@ -21,7 +21,7 @@ import ( "sort" "strings" - "sigs.k8s.io/structured-merge-diff/value" + "sigs.k8s.io/structured-merge-diff/v2/value" ) // PathElement describes how to select a child field given a containing object. diff --git a/fieldpath/element_test.go b/fieldpath/element_test.go index 34554817..9231136a 100644 --- a/fieldpath/element_test.go +++ b/fieldpath/element_test.go @@ -19,7 +19,7 @@ package fieldpath import ( "testing" - "sigs.k8s.io/structured-merge-diff/value" + "sigs.k8s.io/structured-merge-diff/v2/value" ) func TestPathElementSet(t *testing.T) { diff --git a/fieldpath/fromvalue.go b/fieldpath/fromvalue.go index 3f9eaf63..c0e76fa4 100644 --- a/fieldpath/fromvalue.go +++ b/fieldpath/fromvalue.go @@ -17,7 +17,7 @@ limitations under the License. package fieldpath import ( - "sigs.k8s.io/structured-merge-diff/value" + "sigs.k8s.io/structured-merge-diff/v2/value" ) // SetFromValue creates a set containing every leaf field mentioned in v. diff --git a/fieldpath/fromvalue_test.go b/fieldpath/fromvalue_test.go index 0c705e75..b89f1007 100644 --- a/fieldpath/fromvalue_test.go +++ b/fieldpath/fromvalue_test.go @@ -19,7 +19,7 @@ package fieldpath import ( "testing" - "sigs.k8s.io/structured-merge-diff/value" + "sigs.k8s.io/structured-merge-diff/v2/value" ) func TestFromValue(t *testing.T) { diff --git a/fieldpath/managers_test.go b/fieldpath/managers_test.go index 22619465..18acce62 100644 --- a/fieldpath/managers_test.go +++ b/fieldpath/managers_test.go @@ -21,7 +21,7 @@ import ( "reflect" "testing" - "sigs.k8s.io/structured-merge-diff/fieldpath" + "sigs.k8s.io/structured-merge-diff/v2/fieldpath" ) var ( diff --git a/fieldpath/path.go b/fieldpath/path.go index bdf6ce90..4ccf2a5e 100644 --- a/fieldpath/path.go +++ b/fieldpath/path.go @@ -20,7 +20,7 @@ import ( "fmt" "strings" - "sigs.k8s.io/structured-merge-diff/value" + "sigs.k8s.io/structured-merge-diff/v2/value" ) // Path describes how to select a potentially deeply-nested child field given a diff --git a/fieldpath/path_test.go b/fieldpath/path_test.go index 877ce7e6..5e7ffc29 100644 --- a/fieldpath/path_test.go +++ b/fieldpath/path_test.go @@ -19,7 +19,7 @@ package fieldpath import ( "testing" - "sigs.k8s.io/structured-merge-diff/value" + "sigs.k8s.io/structured-merge-diff/v2/value" ) func TestPathString(t *testing.T) { diff --git a/fieldpath/pathelementmap.go b/fieldpath/pathelementmap.go index f35089a1..4625b274 100644 --- a/fieldpath/pathelementmap.go +++ b/fieldpath/pathelementmap.go @@ -19,7 +19,7 @@ package fieldpath import ( "sort" - "sigs.k8s.io/structured-merge-diff/value" + "sigs.k8s.io/structured-merge-diff/v2/value" ) // PathElementValueMap is a map from PathElement to value.Value. diff --git a/fieldpath/pathelementmap_test.go b/fieldpath/pathelementmap_test.go index 51fa72f3..b90e183b 100644 --- a/fieldpath/pathelementmap_test.go +++ b/fieldpath/pathelementmap_test.go @@ -19,7 +19,7 @@ package fieldpath import ( "testing" - "sigs.k8s.io/structured-merge-diff/value" + "sigs.k8s.io/structured-merge-diff/v2/value" ) func TestPathElementValueMap(t *testing.T) { diff --git a/fieldpath/serialize-pe.go b/fieldpath/serialize-pe.go index e491fce1..3095177d 100644 --- a/fieldpath/serialize-pe.go +++ b/fieldpath/serialize-pe.go @@ -24,7 +24,7 @@ import ( "strings" jsoniter "github.com/json-iterator/go" - "sigs.k8s.io/structured-merge-diff/value" + "sigs.k8s.io/structured-merge-diff/v2/value" ) var ErrUnknownPathElementType = errors.New("unknown path element type") diff --git a/fieldpath/set_test.go b/fieldpath/set_test.go index f5605063..0d1336d9 100644 --- a/fieldpath/set_test.go +++ b/fieldpath/set_test.go @@ -22,7 +22,7 @@ import ( "math/rand" "testing" - "sigs.k8s.io/structured-merge-diff/value" + "sigs.k8s.io/structured-merge-diff/v2/value" ) type randomPathAlphabet []PathElement diff --git a/go.mod b/go.mod index 28f977d3..00ac0307 100644 --- a/go.mod +++ b/go.mod @@ -1,4 +1,4 @@ -module sigs.k8s.io/structured-merge-diff +module sigs.k8s.io/structured-merge-diff/v2 require gopkg.in/yaml.v2 v2.2.1 @@ -9,3 +9,5 @@ require ( github.com/modern-go/reflect2 v1.0.1 // indirect github.com/stretchr/testify v1.3.0 // indirect ) + +go 1.13 diff --git a/internal/cli/operation.go b/internal/cli/operation.go index 9f8052cb..f0049f5c 100644 --- a/internal/cli/operation.go +++ b/internal/cli/operation.go @@ -21,7 +21,7 @@ import ( "io" "io/ioutil" - "sigs.k8s.io/structured-merge-diff/typed" + "sigs.k8s.io/structured-merge-diff/v2/typed" ) type Operation interface { diff --git a/internal/cli/options.go b/internal/cli/options.go index 3b2e9201..d371f86b 100644 --- a/internal/cli/options.go +++ b/internal/cli/options.go @@ -24,7 +24,7 @@ import ( "io/ioutil" "os" - "sigs.k8s.io/structured-merge-diff/typed" + "sigs.k8s.io/structured-merge-diff/v2/typed" ) var ( diff --git a/internal/fixture/state.go b/internal/fixture/state.go index 4bc96f31..2c4c3090 100644 --- a/internal/fixture/state.go +++ b/internal/fixture/state.go @@ -20,9 +20,9 @@ import ( "bytes" "fmt" - "sigs.k8s.io/structured-merge-diff/fieldpath" - "sigs.k8s.io/structured-merge-diff/merge" - "sigs.k8s.io/structured-merge-diff/typed" + "sigs.k8s.io/structured-merge-diff/v2/fieldpath" + "sigs.k8s.io/structured-merge-diff/v2/merge" + "sigs.k8s.io/structured-merge-diff/v2/typed" ) // State of the current test in terms of live object. One can check at diff --git a/internal/fixture/state_test.go b/internal/fixture/state_test.go index 67323343..16a4889f 100644 --- a/internal/fixture/state_test.go +++ b/internal/fixture/state_test.go @@ -20,7 +20,7 @@ import ( "fmt" "testing" - "sigs.k8s.io/structured-merge-diff/typed" + "sigs.k8s.io/structured-merge-diff/v2/typed" ) func TestFixTabs(t *testing.T) { diff --git a/merge/conflict.go b/merge/conflict.go index 34477f7d..5c271601 100644 --- a/merge/conflict.go +++ b/merge/conflict.go @@ -21,7 +21,7 @@ import ( "sort" "strings" - "sigs.k8s.io/structured-merge-diff/fieldpath" + "sigs.k8s.io/structured-merge-diff/v2/fieldpath" ) // Conflict is a conflict on a specific field with the current manager of diff --git a/merge/conflict_test.go b/merge/conflict_test.go index 925a8f06..c7f258db 100644 --- a/merge/conflict_test.go +++ b/merge/conflict_test.go @@ -19,9 +19,9 @@ package merge_test import ( "testing" - "sigs.k8s.io/structured-merge-diff/fieldpath" - "sigs.k8s.io/structured-merge-diff/merge" - "sigs.k8s.io/structured-merge-diff/value" + "sigs.k8s.io/structured-merge-diff/v2/fieldpath" + "sigs.k8s.io/structured-merge-diff/v2/merge" + "sigs.k8s.io/structured-merge-diff/v2/value" ) var ( diff --git a/merge/deduced_test.go b/merge/deduced_test.go index 0be622d9..5c8620f2 100644 --- a/merge/deduced_test.go +++ b/merge/deduced_test.go @@ -19,10 +19,10 @@ package merge_test import ( "testing" - "sigs.k8s.io/structured-merge-diff/fieldpath" - . "sigs.k8s.io/structured-merge-diff/internal/fixture" - "sigs.k8s.io/structured-merge-diff/merge" - "sigs.k8s.io/structured-merge-diff/typed" + "sigs.k8s.io/structured-merge-diff/v2/fieldpath" + . "sigs.k8s.io/structured-merge-diff/v2/internal/fixture" + "sigs.k8s.io/structured-merge-diff/v2/merge" + "sigs.k8s.io/structured-merge-diff/v2/typed" ) func TestDeduced(t *testing.T) { diff --git a/merge/key_test.go b/merge/key_test.go index cef9e296..3f6a1b66 100644 --- a/merge/key_test.go +++ b/merge/key_test.go @@ -19,9 +19,9 @@ package merge_test import ( "testing" - "sigs.k8s.io/structured-merge-diff/fieldpath" - . "sigs.k8s.io/structured-merge-diff/internal/fixture" - "sigs.k8s.io/structured-merge-diff/typed" + "sigs.k8s.io/structured-merge-diff/v2/fieldpath" + . "sigs.k8s.io/structured-merge-diff/v2/internal/fixture" + "sigs.k8s.io/structured-merge-diff/v2/typed" ) var associativeListParser = func() typed.ParseableType { diff --git a/merge/leaf_test.go b/merge/leaf_test.go index fc502b7f..134291ad 100644 --- a/merge/leaf_test.go +++ b/merge/leaf_test.go @@ -19,10 +19,10 @@ package merge_test import ( "testing" - "sigs.k8s.io/structured-merge-diff/fieldpath" - . "sigs.k8s.io/structured-merge-diff/internal/fixture" - "sigs.k8s.io/structured-merge-diff/merge" - "sigs.k8s.io/structured-merge-diff/typed" + "sigs.k8s.io/structured-merge-diff/v2/fieldpath" + . "sigs.k8s.io/structured-merge-diff/v2/internal/fixture" + "sigs.k8s.io/structured-merge-diff/v2/merge" + "sigs.k8s.io/structured-merge-diff/v2/typed" ) var leafFieldsParser = func() typed.ParseableType { diff --git a/merge/multiple_appliers_test.go b/merge/multiple_appliers_test.go index 588a650f..677d70a8 100644 --- a/merge/multiple_appliers_test.go +++ b/merge/multiple_appliers_test.go @@ -22,10 +22,10 @@ import ( "strings" "testing" - "sigs.k8s.io/structured-merge-diff/fieldpath" - . "sigs.k8s.io/structured-merge-diff/internal/fixture" - "sigs.k8s.io/structured-merge-diff/merge" - "sigs.k8s.io/structured-merge-diff/typed" + "sigs.k8s.io/structured-merge-diff/v2/fieldpath" + . "sigs.k8s.io/structured-merge-diff/v2/internal/fixture" + "sigs.k8s.io/structured-merge-diff/v2/merge" + "sigs.k8s.io/structured-merge-diff/v2/typed" ) func TestMultipleAppliersSet(t *testing.T) { diff --git a/merge/nested_test.go b/merge/nested_test.go index 7a952dfe..f1f89660 100644 --- a/merge/nested_test.go +++ b/merge/nested_test.go @@ -19,9 +19,9 @@ package merge_test import ( "testing" - "sigs.k8s.io/structured-merge-diff/fieldpath" - . "sigs.k8s.io/structured-merge-diff/internal/fixture" - "sigs.k8s.io/structured-merge-diff/typed" + "sigs.k8s.io/structured-merge-diff/v2/fieldpath" + . "sigs.k8s.io/structured-merge-diff/v2/internal/fixture" + "sigs.k8s.io/structured-merge-diff/v2/typed" ) var nestedTypeParser = func() typed.ParseableType { diff --git a/merge/obsolete_versions_test.go b/merge/obsolete_versions_test.go index 40e222d5..16101ec5 100644 --- a/merge/obsolete_versions_test.go +++ b/merge/obsolete_versions_test.go @@ -20,10 +20,10 @@ import ( "fmt" "testing" - "sigs.k8s.io/structured-merge-diff/fieldpath" - "sigs.k8s.io/structured-merge-diff/internal/fixture" - "sigs.k8s.io/structured-merge-diff/merge" - "sigs.k8s.io/structured-merge-diff/typed" + "sigs.k8s.io/structured-merge-diff/v2/fieldpath" + "sigs.k8s.io/structured-merge-diff/v2/internal/fixture" + "sigs.k8s.io/structured-merge-diff/v2/merge" + "sigs.k8s.io/structured-merge-diff/v2/typed" ) // specificVersionConverter doesn't convert and return the exact same diff --git a/merge/preserve_unknown_test.go b/merge/preserve_unknown_test.go index 6259c6d0..ff7ac930 100644 --- a/merge/preserve_unknown_test.go +++ b/merge/preserve_unknown_test.go @@ -19,9 +19,9 @@ package merge_test import ( "testing" - "sigs.k8s.io/structured-merge-diff/fieldpath" - . "sigs.k8s.io/structured-merge-diff/internal/fixture" - "sigs.k8s.io/structured-merge-diff/typed" + "sigs.k8s.io/structured-merge-diff/v2/fieldpath" + . "sigs.k8s.io/structured-merge-diff/v2/internal/fixture" + "sigs.k8s.io/structured-merge-diff/v2/typed" ) var preserveUnknownParser = func() typed.ParseableType { diff --git a/merge/real_test.go b/merge/real_test.go index 1124c223..7480cb4d 100644 --- a/merge/real_test.go +++ b/merge/real_test.go @@ -22,8 +22,8 @@ import ( "strings" "testing" - . "sigs.k8s.io/structured-merge-diff/internal/fixture" - "sigs.k8s.io/structured-merge-diff/typed" + . "sigs.k8s.io/structured-merge-diff/v2/internal/fixture" + "sigs.k8s.io/structured-merge-diff/v2/typed" ) func testdata(file string) string { diff --git a/merge/set_test.go b/merge/set_test.go index d44b5645..de326997 100644 --- a/merge/set_test.go +++ b/merge/set_test.go @@ -19,9 +19,9 @@ package merge_test import ( "testing" - "sigs.k8s.io/structured-merge-diff/fieldpath" - . "sigs.k8s.io/structured-merge-diff/internal/fixture" - "sigs.k8s.io/structured-merge-diff/typed" + "sigs.k8s.io/structured-merge-diff/v2/fieldpath" + . "sigs.k8s.io/structured-merge-diff/v2/internal/fixture" + "sigs.k8s.io/structured-merge-diff/v2/typed" ) var setFieldsParser = func() typed.ParseableType { diff --git a/merge/union_test.go b/merge/union_test.go index 1c933cc7..ce299865 100644 --- a/merge/union_test.go +++ b/merge/union_test.go @@ -19,10 +19,10 @@ package merge_test import ( "testing" - "sigs.k8s.io/structured-merge-diff/fieldpath" - . "sigs.k8s.io/structured-merge-diff/internal/fixture" - "sigs.k8s.io/structured-merge-diff/merge" - "sigs.k8s.io/structured-merge-diff/typed" + "sigs.k8s.io/structured-merge-diff/v2/fieldpath" + . "sigs.k8s.io/structured-merge-diff/v2/internal/fixture" + "sigs.k8s.io/structured-merge-diff/v2/merge" + "sigs.k8s.io/structured-merge-diff/v2/typed" ) var unionFieldsParser = func() typed.ParseableType { diff --git a/merge/update.go b/merge/update.go index 75d59907..d4de64b2 100644 --- a/merge/update.go +++ b/merge/update.go @@ -16,8 +16,8 @@ package merge import ( "fmt" - "sigs.k8s.io/structured-merge-diff/fieldpath" - "sigs.k8s.io/structured-merge-diff/typed" + "sigs.k8s.io/structured-merge-diff/v2/fieldpath" + "sigs.k8s.io/structured-merge-diff/v2/typed" ) // Converter is an interface to the conversion logic. The converter diff --git a/smd/main.go b/smd/main.go index 611dbeb9..2d2dd257 100644 --- a/smd/main.go +++ b/smd/main.go @@ -22,7 +22,7 @@ import ( "flag" "log" - "sigs.k8s.io/structured-merge-diff/internal/cli" + "sigs.k8s.io/structured-merge-diff/v2/internal/cli" ) func main() { diff --git a/typed/deduced_test.go b/typed/deduced_test.go index 1c06d92b..77b44349 100644 --- a/typed/deduced_test.go +++ b/typed/deduced_test.go @@ -21,7 +21,7 @@ import ( "reflect" "testing" - "sigs.k8s.io/structured-merge-diff/typed" + "sigs.k8s.io/structured-merge-diff/v2/typed" ) func TestValidateDeducedType(t *testing.T) { diff --git a/typed/helpers.go b/typed/helpers.go index 0911ce0b..a2303df3 100644 --- a/typed/helpers.go +++ b/typed/helpers.go @@ -21,9 +21,9 @@ import ( "fmt" "strings" - "sigs.k8s.io/structured-merge-diff/fieldpath" - "sigs.k8s.io/structured-merge-diff/schema" - "sigs.k8s.io/structured-merge-diff/value" + "sigs.k8s.io/structured-merge-diff/v2/fieldpath" + "sigs.k8s.io/structured-merge-diff/v2/schema" + "sigs.k8s.io/structured-merge-diff/v2/value" ) // ValidationError reports an error about a particular field diff --git a/typed/merge.go b/typed/merge.go index bb92f84b..8581125c 100644 --- a/typed/merge.go +++ b/typed/merge.go @@ -17,9 +17,9 @@ limitations under the License. package typed import ( - "sigs.k8s.io/structured-merge-diff/fieldpath" - "sigs.k8s.io/structured-merge-diff/schema" - "sigs.k8s.io/structured-merge-diff/value" + "sigs.k8s.io/structured-merge-diff/v2/fieldpath" + "sigs.k8s.io/structured-merge-diff/v2/schema" + "sigs.k8s.io/structured-merge-diff/v2/value" ) type mergingWalker struct { diff --git a/typed/merge_test.go b/typed/merge_test.go index c83c5619..2745c58e 100644 --- a/typed/merge_test.go +++ b/typed/merge_test.go @@ -21,7 +21,7 @@ import ( "reflect" "testing" - "sigs.k8s.io/structured-merge-diff/typed" + "sigs.k8s.io/structured-merge-diff/v2/typed" ) type mergeTestCase struct { diff --git a/typed/parser.go b/typed/parser.go index 2e36857b..5ade977e 100644 --- a/typed/parser.go +++ b/typed/parser.go @@ -20,8 +20,8 @@ import ( "fmt" yaml "gopkg.in/yaml.v2" - "sigs.k8s.io/structured-merge-diff/schema" - "sigs.k8s.io/structured-merge-diff/value" + "sigs.k8s.io/structured-merge-diff/v2/schema" + "sigs.k8s.io/structured-merge-diff/v2/value" ) // YAMLObject is an object encoded in YAML. diff --git a/typed/parser_test.go b/typed/parser_test.go index 89fbd183..f8ba90e3 100644 --- a/typed/parser_test.go +++ b/typed/parser_test.go @@ -23,7 +23,7 @@ import ( "testing" yaml "gopkg.in/yaml.v2" - "sigs.k8s.io/structured-merge-diff/typed" + "sigs.k8s.io/structured-merge-diff/v2/typed" ) func testdata(file string) string { diff --git a/typed/remove.go b/typed/remove.go index a6b74841..64fe8648 100644 --- a/typed/remove.go +++ b/typed/remove.go @@ -14,9 +14,9 @@ limitations under the License. package typed import ( - "sigs.k8s.io/structured-merge-diff/fieldpath" - "sigs.k8s.io/structured-merge-diff/schema" - "sigs.k8s.io/structured-merge-diff/value" + "sigs.k8s.io/structured-merge-diff/v2/fieldpath" + "sigs.k8s.io/structured-merge-diff/v2/schema" + "sigs.k8s.io/structured-merge-diff/v2/value" ) type removingWalker struct { diff --git a/typed/symdiff_test.go b/typed/symdiff_test.go index 4a7841fe..6528d204 100644 --- a/typed/symdiff_test.go +++ b/typed/symdiff_test.go @@ -20,8 +20,8 @@ import ( "fmt" "testing" - "sigs.k8s.io/structured-merge-diff/fieldpath" - "sigs.k8s.io/structured-merge-diff/typed" + "sigs.k8s.io/structured-merge-diff/v2/fieldpath" + "sigs.k8s.io/structured-merge-diff/v2/typed" ) type symdiffTestCase struct { diff --git a/typed/toset_test.go b/typed/toset_test.go index d565b323..2222485f 100644 --- a/typed/toset_test.go +++ b/typed/toset_test.go @@ -20,9 +20,9 @@ import ( "fmt" "testing" - "sigs.k8s.io/structured-merge-diff/fieldpath" - "sigs.k8s.io/structured-merge-diff/typed" - "sigs.k8s.io/structured-merge-diff/value" + "sigs.k8s.io/structured-merge-diff/v2/fieldpath" + "sigs.k8s.io/structured-merge-diff/v2/typed" + "sigs.k8s.io/structured-merge-diff/v2/value" ) type objSetPair struct { diff --git a/typed/typed.go b/typed/typed.go index 9c61b845..c90f8225 100644 --- a/typed/typed.go +++ b/typed/typed.go @@ -21,9 +21,9 @@ import ( "strings" "sync" - "sigs.k8s.io/structured-merge-diff/fieldpath" - "sigs.k8s.io/structured-merge-diff/schema" - "sigs.k8s.io/structured-merge-diff/value" + "sigs.k8s.io/structured-merge-diff/v2/fieldpath" + "sigs.k8s.io/structured-merge-diff/v2/schema" + "sigs.k8s.io/structured-merge-diff/v2/value" ) // AsTyped accepts a value and a type and returns a TypedValue. 'v' must have diff --git a/typed/union.go b/typed/union.go index c4a012ee..838b39f6 100644 --- a/typed/union.go +++ b/typed/union.go @@ -20,8 +20,8 @@ import ( "fmt" "strings" - "sigs.k8s.io/structured-merge-diff/schema" - "sigs.k8s.io/structured-merge-diff/value" + "sigs.k8s.io/structured-merge-diff/v2/schema" + "sigs.k8s.io/structured-merge-diff/v2/value" ) func normalizeUnions(w *mergingWalker) error { diff --git a/typed/union_test.go b/typed/union_test.go index dc621b6c..e862dff6 100644 --- a/typed/union_test.go +++ b/typed/union_test.go @@ -19,7 +19,7 @@ package typed_test import ( "testing" - "sigs.k8s.io/structured-merge-diff/typed" + "sigs.k8s.io/structured-merge-diff/v2/typed" ) var unionParser = func() typed.ParseableType { diff --git a/typed/validate.go b/typed/validate.go index 338c0583..837bbcf3 100644 --- a/typed/validate.go +++ b/typed/validate.go @@ -19,9 +19,9 @@ package typed import ( "sync" - "sigs.k8s.io/structured-merge-diff/fieldpath" - "sigs.k8s.io/structured-merge-diff/schema" - "sigs.k8s.io/structured-merge-diff/value" + "sigs.k8s.io/structured-merge-diff/v2/fieldpath" + "sigs.k8s.io/structured-merge-diff/v2/schema" + "sigs.k8s.io/structured-merge-diff/v2/value" ) var vPool = sync.Pool{ diff --git a/typed/validate_test.go b/typed/validate_test.go index d720ebd7..b9bbaa5f 100644 --- a/typed/validate_test.go +++ b/typed/validate_test.go @@ -20,8 +20,8 @@ import ( "fmt" "testing" - "sigs.k8s.io/structured-merge-diff/schema" - "sigs.k8s.io/structured-merge-diff/typed" + "sigs.k8s.io/structured-merge-diff/v2/schema" + "sigs.k8s.io/structured-merge-diff/v2/typed" ) type validationTestCase struct { From fc972c0604093510a5801ab3e38586a9691e2e16 Mon Sep 17 00:00:00 2001 From: jennybuckley Date: Tue, 3 Dec 2019 17:39:34 -0800 Subject: [PATCH 2/7] Fix useless error message 'invalid atom' --- typed/helpers.go | 28 +++++++++++++++++++--------- typed/validate.go | 6 +++++- typed/validate_test.go | 6 ++++++ 3 files changed, 30 insertions(+), 10 deletions(-) diff --git a/typed/helpers.go b/typed/helpers.go index a2303df3..8388135b 100644 --- a/typed/helpers.go +++ b/typed/helpers.go @@ -114,17 +114,27 @@ func resolveSchema(s *schema.Schema, tr schema.TypeRef, v *value.Value, ah atomH return handleAtom(a, tr, ah) } -func deduceAtom(a schema.Atom, v *value.Value) schema.Atom { +// deduceAtom determines which of the possible types in atom 'atom' applies to value 'val'. +// If val is of a type allowed by atom, return a copy of atom with all other types set to nil. +// if val is nil, or is not of a type allowed by atom, just return the original atom, +// and validation will fail at a later stage. (with a more useful error) +func deduceAtom(atom schema.Atom, val *value.Value) schema.Atom { switch { - case v == nil: - case v.FloatValue != nil, v.IntValue != nil, v.StringValue != nil, v.BooleanValue != nil: - return schema.Atom{Scalar: a.Scalar} - case v.ListValue != nil: - return schema.Atom{List: a.List} - case v.MapValue != nil: - return schema.Atom{Map: a.Map} + case val == nil: + case val.FloatValue != nil, val.IntValue != nil, val.StringValue != nil, val.BooleanValue != nil: + if atom.Scalar != nil { + return schema.Atom{Scalar: atom.Scalar} + } + case val.ListValue != nil: + if atom.List != nil { + return schema.Atom{List: atom.List} + } + case val.MapValue != nil: + if atom.Map != nil { + return schema.Atom{Map: atom.Map} + } } - return a + return atom } func handleAtom(a schema.Atom, tr schema.TypeRef, ah atomHandler) ValidationErrors { diff --git a/typed/validate.go b/typed/validate.go index 837bbcf3..a581fc7e 100644 --- a/typed/validate.go +++ b/typed/validate.go @@ -198,7 +198,11 @@ func (v *validatingObjectWalker) visitMapItems(t *schema.Map, m *value.Map) (err } else { v2 := v.prepareDescent(pe, t.ElementType) v2.value = item.Value - errs = append(errs, v2.validate()...) + if (t.ElementType == schema.TypeRef{}) { + errs = append(errs, v2.errorf("field not declared in schema")...) + } else { + errs = append(errs, v2.validate()...) + } v2.doNode() v.finishDescent(v2) } diff --git a/typed/validate_test.go b/typed/validate_test.go index b9bbaa5f..d7a21b8c 100644 --- a/typed/validate_test.go +++ b/typed/validate_test.go @@ -18,6 +18,7 @@ package typed_test import ( "fmt" + "strings" "testing" "sigs.k8s.io/structured-merge-diff/v2/schema" @@ -216,6 +217,8 @@ var validationCases = []validationTestCase{{ invalidObjects: []typed.YAMLObject{ `{"key":true,"value":1}`, `{"list":{"key":true,"value":1}}`, + `{"list":true}`, + `true`, `{"list":[{"key":true,"value":1}]}`, `{"list":[{"key":[],"value":1}]}`, `{"list":[{"key":{},"value":1}]}`, @@ -261,6 +264,9 @@ func (tt validationTestCase) test(t *testing.T) { if err == nil { t.Errorf("Object should fail: %v\n%v", err, iv) } + if strings.Contains(err.Error(), "invalid atom") { + t.Errorf("Error should be useful, but got: %v\n%v", err, iv) + } }) } } From 2e2bf9794102dae40dc75dab94d3e77428392bd9 Mon Sep 17 00:00:00 2001 From: jennybuckley Date: Wed, 4 Dec 2019 11:59:14 -0800 Subject: [PATCH 3/7] Add test for null/{} behavior of deduced types --- typed/symdiff_test.go | 238 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 238 insertions(+) diff --git a/typed/symdiff_test.go b/typed/symdiff_test.go index 6528d204..5d3fd48a 100644 --- a/typed/symdiff_test.go +++ b/typed/symdiff_test.go @@ -299,6 +299,244 @@ var symdiffCases = []symdiffTestCase{{ modified: _NS(), added: _NS(_P("a", "b")), }}, +}, { + name: "untyped deduced", + rootTypeName: "__untyped_deduced_", + schema: `types: +- name: __untyped_atomic_ + scalar: untyped + list: + elementType: + namedType: __untyped_atomic_ + elementRelationship: atomic + map: + elementType: + namedType: __untyped_atomic_ + elementRelationship: atomic +- name: __untyped_deduced_ + scalar: untyped + list: + elementType: + namedType: __untyped_atomic_ + elementRelationship: atomic + map: + elementType: + namedType: __untyped_deduced_ + elementRelationship: separable +`, + quints: []symdiffQuint{{ + lhs: `{"a":{}}}`, + rhs: `{"a":{"b":{}}}`, + removed: _NS(), + modified: _NS(), + added: _NS(_P("a", "b")), + }, { + lhs: `{"a":null}`, + rhs: `{"a":{"b":{}}}`, + removed: _NS(), + modified: _NS(), + added: _NS(_P("a", "b")), + }, { + lhs: `{"a":{"b":{}}}`, + rhs: `{"a":{}}}`, + removed: _NS(_P("a", "b")), + modified: _NS(), + added: _NS(), + }, { + lhs: `{"a":{"b":{}}}`, + rhs: `{"a":null}`, + removed: _NS(_P("a", "b")), + modified: _NS(), + added: _NS(), + }, { + lhs: `{"a":[]}`, + rhs: `{"a":["b"]}`, + removed: _NS(), + modified: _NS(_P("a")), + added: _NS(), + }, { + lhs: `{"a":null}`, + rhs: `{"a":["b"]}`, + removed: _NS(), + modified: _NS(_P("a")), + added: _NS(), + }, { + lhs: `{"a":["b"]}`, + rhs: `{"a":[]}`, + removed: _NS(), + modified: _NS(_P("a")), + added: _NS(), + }, { + lhs: `{"a":["b"]}`, + rhs: `{"a":null}`, + removed: _NS(), + modified: _NS(_P("a")), + added: _NS(), + }, { + lhs: `{"a":null}`, + rhs: `{"a":"b"}`, + removed: _NS(), + modified: _NS(_P("a")), + added: _NS(), + }, { + lhs: `{"a":"b"}`, + rhs: `{"a":null}`, + removed: _NS(), + modified: _NS(_P("a")), + added: _NS(), + }, { + lhs: `{"a":{"b":{}}}`, + rhs: `{"a":["b"]}}`, + removed: _NS(_P("a", "b")), + modified: _NS(_P("a")), + added: _NS(), + }, { + lhs: `{"a":["b"]}}`, + rhs: `{"a":{"b":{}}}`, + removed: _NS(), + modified: _NS(_P("a")), + added: _NS(_P("a", "b")), + }, { + lhs: `{"a":{"b":{}}}`, + rhs: `{"a":"b"}`, + removed: _NS(_P("a", "b")), + modified: _NS(_P("a")), + added: _NS(), + }, { + lhs: `{"a":"b"}`, + rhs: `{"a":{"b":{}}}`, + removed: _NS(), + modified: _NS(_P("a")), + added: _NS(_P("a", "b")), + }, { + lhs: `{"a":["b"]}}`, + rhs: `{"a":"b"}`, + removed: _NS(), + modified: _NS(_P("a")), + added: _NS(), + }, { + lhs: `{"a":"b"}`, + rhs: `{"a":["b"]}}`, + removed: _NS(), + modified: _NS(_P("a")), + added: _NS(), + }}, +}, { + name: "untyped separable", + rootTypeName: "__untyped_separable_", + schema: `types: +- name: __untyped_separable_ + scalar: untyped + list: + elementType: + namedType: __untyped_separable_ + elementRelationship: associative + map: + elementType: + namedType: __untyped_separable_ + elementRelationship: separable +`, + quints: []symdiffQuint{{ + lhs: `{"a":{}}}`, + rhs: `{"a":{"b":{}}}`, + removed: _NS(), + modified: _NS(), + added: _NS(_P("a", "b")), + }, { + lhs: `{"a":null}`, + rhs: `{"a":{"b":{}}}`, + removed: _NS(), + modified: _NS(), + added: _NS(_P("a", "b")), + }, { + lhs: `{"a":{"b":{}}}`, + rhs: `{"a":{}}}`, + removed: _NS(_P("a", "b")), + modified: _NS(), + added: _NS(), + }, { + lhs: `{"a":{"b":{}}}`, + rhs: `{"a":null}`, + removed: _NS(_P("a", "b")), + modified: _NS(), + added: _NS(), + }, { + lhs: `{"a":[]}`, + rhs: `{"a":["b"]}`, + removed: _NS(), + modified: _NS(), + added: _NS(_P("a", _SV("b"))), + }, { + lhs: `{"a":null}`, + rhs: `{"a":["b"]}`, + removed: _NS(), + // TODO: result should be the same as the previous case + // nothing shoule be modified here. + modified: _NS(_P("a")), + added: _NS(_P("a", _SV("b"))), + }, { + lhs: `{"a":["b"]}`, + rhs: `{"a":[]}`, + removed: _NS(_P("a", _SV("b"))), + modified: _NS(), + added: _NS(), + }, { + lhs: `{"a":["b"]}`, + rhs: `{"a":null}`, + removed: _NS(_P("a", _SV("b"))), + // TODO: result should be the same as the previous case + // nothing shoule be modified here. + modified: _NS(_P("a")), + added: _NS(), + }, { + lhs: `{"a":null}`, + rhs: `{"a":"b"}`, + removed: _NS(), + modified: _NS(_P("a")), + added: _NS(), + }, { + lhs: `{"a":"b"}`, + rhs: `{"a":null}`, + removed: _NS(), + modified: _NS(_P("a")), + added: _NS(), + }, { + lhs: `{"a":{"b":{}}}`, + rhs: `{"a":["b"]}}`, + removed: _NS(_P("a", "b")), + modified: _NS(), + added: _NS(_P("a", _SV("b"))), + }, { + lhs: `{"a":["b"]}}`, + rhs: `{"a":{"b":{}}}`, + removed: _NS(_P("a", _SV("b"))), + modified: _NS(), + added: _NS(_P("a", "b")), + }, { + lhs: `{"a":{"b":{}}}`, + rhs: `{"a":"b"}`, + removed: _NS(_P("a", "b")), + modified: _NS(_P("a")), + added: _NS(), + }, { + lhs: `{"a":"b"}`, + rhs: `{"a":{"b":{}}}`, + removed: _NS(), + modified: _NS(_P("a")), + added: _NS(_P("a", "b")), + }, { + lhs: `{"a":["b"]}}`, + rhs: `{"a":"b"}`, + removed: _NS(_P("a", _SV("b"))), + modified: _NS(_P("a")), + added: _NS(), + }, { + lhs: `{"a":"b"}`, + rhs: `{"a":["b"]}}`, + removed: _NS(), + modified: _NS(_P("a")), + added: _NS(_P("a", _SV("b"))), + }}, }, { name: "struct grab bag", rootTypeName: "myStruct", From e7214fcd5ad4f8886cde8171ac36800b2cb78c08 Mon Sep 17 00:00:00 2001 From: Antoine Pelisse Date: Thu, 5 Mar 2020 08:58:45 -0800 Subject: [PATCH 4/7] merge: Apply returns nil object if unchanged We need to know when the apply operation isn't changing the object, so that we can update the timestamp of the operation. The simplest way to do so it to return nil. --- internal/fixture/state.go | 5 +++-- merge/update.go | 8 ++++++-- 2 files changed, 9 insertions(+), 4 deletions(-) diff --git a/internal/fixture/state.go b/internal/fixture/state.go index 2c4c3090..0b1b0f35 100644 --- a/internal/fixture/state.go +++ b/internal/fixture/state.go @@ -121,9 +121,10 @@ func (s *State) ApplyObject(tv *typed.TypedValue, version fieldpath.APIVersion, if err != nil { return err } - s.Live = new s.Managers = managers - + if new != nil { + s.Live = new + } return nil } diff --git a/merge/update.go b/merge/update.go index d4de64b2..7065aeec 100644 --- a/merge/update.go +++ b/merge/update.go @@ -148,7 +148,8 @@ func (s *Updater) Update(liveObject, newObject *typed.TypedValue, version fieldp // Apply should be called when Apply is run, given the current object as // well as the configuration that is applied. This will merge the object -// and return it. +// and return it. If the object hasn't changed, nil is returned (the +// managers can still have changed though). func (s *Updater) Apply(liveObject, configObject *typed.TypedValue, version fieldpath.APIVersion, managers fieldpath.ManagedFields, manager string, force bool) (*typed.TypedValue, fieldpath.ManagedFields, error) { managers = shallowCopyManagers(managers) var err error @@ -178,10 +179,13 @@ func (s *Updater) Apply(liveObject, configObject *typed.TypedValue, version fiel if err != nil { return nil, fieldpath.ManagedFields{}, fmt.Errorf("failed to prune fields: %v", err) } - managers, _, err = s.update(liveObject, newObject, version, managers, manager, force) + managers, compare, err := s.update(liveObject, newObject, version, managers, manager, force) if err != nil { return nil, fieldpath.ManagedFields{}, err } + if compare.IsSame() { + newObject = nil + } return newObject, managers, nil } From c4f7e542c2d3b176ab703d37ecb6d4fb101f122d Mon Sep 17 00:00:00 2001 From: Antoine Pelisse Date: Thu, 5 Mar 2020 10:46:30 -0800 Subject: [PATCH 5/7] fieldpath.ManagedFields: Add Equals method --- fieldpath/managers.go | 22 +++++++ fieldpath/managers_test.go | 122 ++++++++++++++++++++++++++++++++++++- 2 files changed, 143 insertions(+), 1 deletion(-) diff --git a/fieldpath/managers.go b/fieldpath/managers.go index 25d5f0ad..863bb1ee 100644 --- a/fieldpath/managers.go +++ b/fieldpath/managers.go @@ -53,6 +53,28 @@ func (v versionedSet) Applied() bool { // what version). type ManagedFields map[string]VersionedSet +// Equals returns true if the two managedfields are the same, false +// otherwise. +func (lhs ManagedFields) Equals(rhs ManagedFields) bool { + if len(lhs) != len(rhs) { + return false + } + + for manager, left := range lhs { + right, ok := rhs[manager] + if !ok { + return false + } + if left.APIVersion() != right.APIVersion() || left.Applied() != right.Applied() { + return false + } + if !left.Set().Equals(right.Set()) { + return false + } + } + return true +} + // Difference returns a symmetric difference between two Managers. If a // given user's entry has version X in lhs and version Y in rhs, then // the return value for that user will be from rhs. If the difference for diff --git a/fieldpath/managers_test.go b/fieldpath/managers_test.go index 18acce62..1884576d 100644 --- a/fieldpath/managers_test.go +++ b/fieldpath/managers_test.go @@ -30,7 +30,7 @@ var ( _P = fieldpath.MakePathOrDie ) -func TestManagersDifference(t *testing.T) { +func TestManagersEquals(t *testing.T) { tests := []struct { name string lhs fieldpath.ManagedFields @@ -164,3 +164,123 @@ func TestManagersDifference(t *testing.T) { }) } } + +func TestManagersDifference(t *testing.T) { + tests := []struct { + name string + lhs fieldpath.ManagedFields + rhs fieldpath.ManagedFields + equal bool + }{ + { + name: "Empty sets", + equal: true, + }, + { + name: "Same everything", + lhs: fieldpath.ManagedFields{ + "one": fieldpath.NewVersionedSet( + _NS(_P("numeric"), _P("string"), _P("bool")), + "v1", + false, + ), + }, + rhs: fieldpath.ManagedFields{ + "one": fieldpath.NewVersionedSet( + _NS(_P("numeric"), _P("string"), _P("bool")), + "v1", + false, + ), + }, + equal: true, + }, + { + name: "Empty RHS", + lhs: fieldpath.ManagedFields{ + "default": fieldpath.NewVersionedSet( + _NS(_P("numeric"), _P("string"), _P("bool")), + "v1", + false, + ), + }, + equal: false, + }, + { + name: "Empty LHS", + rhs: fieldpath.ManagedFields{ + "default": fieldpath.NewVersionedSet( + _NS(_P("numeric"), _P("string"), _P("bool")), + "v1", + false, + ), + }, + equal: false, + }, + { + name: "Different managers", + lhs: fieldpath.ManagedFields{ + "one": fieldpath.NewVersionedSet( + _NS(_P("numeric"), _P("string"), _P("bool")), + "v1", + false, + ), + }, + rhs: fieldpath.ManagedFields{ + "two": fieldpath.NewVersionedSet( + _NS(_P("numeric"), _P("string"), _P("bool")), + "v1", + false, + ), + }, + equal: false, + }, + { + name: "Same manager, different version", + lhs: fieldpath.ManagedFields{ + "one": fieldpath.NewVersionedSet( + _NS(_P("numeric"), _P("string"), _P("integer")), + "v1", + false, + ), + }, + rhs: fieldpath.ManagedFields{ + "one": fieldpath.NewVersionedSet( + _NS(_P("numeric"), _P("string"), _P("bool")), + "v2", + false, + ), + }, + equal: false, + }, + { + name: "Set difference", + lhs: fieldpath.ManagedFields{ + "one": fieldpath.NewVersionedSet( + _NS(_P("numeric"), _P("string")), + "v1", + false, + ), + }, + rhs: fieldpath.ManagedFields{ + "one": fieldpath.NewVersionedSet( + _NS(_P("string"), _P("bool")), + "v1", + false, + ), + }, + equal: false, + }, + } + + for _, test := range tests { + t.Run(fmt.Sprintf(test.name), func(t *testing.T) { + equal := test.lhs.Equals(test.rhs) + if test.equal && !equal { + difference := test.lhs.Difference(test.rhs) + t.Errorf("should be equal, but are different: %v", difference) + } else if !test.equal && equal { + t.Errorf("should not be equal, but they are") + } + }) + } +} From 1cd02c33ad8b0004d9f8295fba6573deac72b916 Mon Sep 17 00:00:00 2001 From: Antoine Pelisse Date: Thu, 5 Mar 2020 11:30:41 -0800 Subject: [PATCH 6/7] ManagedFields: Implement Copy method --- fieldpath/managers.go | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/fieldpath/managers.go b/fieldpath/managers.go index 863bb1ee..95438e06 100644 --- a/fieldpath/managers.go +++ b/fieldpath/managers.go @@ -75,6 +75,15 @@ func (lhs ManagedFields) Equals(rhs ManagedFields) bool { return true } +// Copy the list, this is mostly a shallow copy. +func (lhs ManagedFields) Copy() ManagedFields { + copy := ManagedFields{} + for manager, set := range lhs { + copy[manager] = set + } + return copy +} + // Difference returns a symmetric difference between two Managers. If a // given user's entry has version X in lhs and version Y in rhs, then // the return value for that user will be from rhs. If the difference for From 65095a84f797456644cdfe714d32685aa1c8fe02 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kevin=20Wiesm=C3=BCller?= Date: Wed, 8 Jan 2020 22:01:29 +0100 Subject: [PATCH 7/7] make schema.Equals pointer receivers for Map and Schema This fixes data races caused by copied mutexes change schema types to pointers Revert "change schema types to pointers" This reverts commit 92e30db8ad4fd87bf44953358d8e95a37e1c99d8. change equals methods to pointer receivers --- schema/elements_test.go | 2 +- schema/equals.go | 68 +++++++++++++++++++++++++++++------------ schema/equals_test.go | 36 +++++++++++----------- typed/merge.go | 2 +- typed/typed.go | 2 +- 5 files changed, 69 insertions(+), 41 deletions(-) diff --git a/schema/elements_test.go b/schema/elements_test.go index d6c46ed1..c4eca6ef 100644 --- a/schema/elements_test.go +++ b/schema/elements_test.go @@ -40,7 +40,7 @@ func TestFindNamedType(t *testing.T) { Types: tt.defs, } td, exist := s.FindNamedType(tt.namedType) - if !td.Equals(tt.expectTypeDef) { + if !td.Equals(&tt.expectTypeDef) { t.Errorf("expected TypeDef %v, got %v", tt.expectTypeDef, td) } if exist != tt.expectExist { diff --git a/schema/equals.go b/schema/equals.go index 271aed3c..464d47de 100644 --- a/schema/equals.go +++ b/schema/equals.go @@ -17,12 +17,16 @@ limitations under the License. package schema // Equals returns true iff the two Schemas are equal. -func (a Schema) Equals(b Schema) bool { +func (a *Schema) Equals(b *Schema) bool { + if a == nil || b == nil { + return a == nil && b == nil + } + if len(a.Types) != len(b.Types) { return false } for i := range a.Types { - if !a.Types[i].Equals(b.Types[i]) { + if !a.Types[i].Equals(&b.Types[i]) { return false } } @@ -33,7 +37,10 @@ func (a Schema) Equals(b Schema) bool { // // Note that two typerefs that have an equivalent type but where one is // inlined and the other is named, are not considered equal. -func (a TypeRef) Equals(b TypeRef) bool { +func (a *TypeRef) Equals(b *TypeRef) bool { + if a == nil || b == nil { + return a == nil && b == nil + } if (a.NamedType == nil) != (b.NamedType == nil) { return false } @@ -43,19 +50,25 @@ func (a TypeRef) Equals(b TypeRef) bool { } //return true } - return a.Inlined.Equals(b.Inlined) + return a.Inlined.Equals(&b.Inlined) } // Equals returns true iff the two TypeDefs are equal. -func (a TypeDef) Equals(b TypeDef) bool { +func (a *TypeDef) Equals(b *TypeDef) bool { + if a == nil || b == nil { + return a == nil && b == nil + } if a.Name != b.Name { return false } - return a.Atom.Equals(b.Atom) + return a.Atom.Equals(&b.Atom) } // Equals returns true iff the two Atoms are equal. -func (a Atom) Equals(b Atom) bool { +func (a *Atom) Equals(b *Atom) bool { + if a == nil || b == nil { + return a == nil && b == nil + } if (a.Scalar == nil) != (b.Scalar == nil) { return false } @@ -69,16 +82,19 @@ func (a Atom) Equals(b Atom) bool { case a.Scalar != nil: return *a.Scalar == *b.Scalar case a.List != nil: - return a.List.Equals(*b.List) + return a.List.Equals(b.List) case a.Map != nil: - return a.Map.Equals(*b.Map) + return a.Map.Equals(b.Map) } return true } // Equals returns true iff the two Maps are equal. -func (a Map) Equals(b Map) bool { - if !a.ElementType.Equals(b.ElementType) { +func (a *Map) Equals(b *Map) bool { + if a == nil || b == nil { + return a == nil && b == nil + } + if !a.ElementType.Equals(&b.ElementType) { return false } if a.ElementRelationship != b.ElementRelationship { @@ -88,7 +104,7 @@ func (a Map) Equals(b Map) bool { return false } for i := range a.Fields { - if !a.Fields[i].Equals(b.Fields[i]) { + if !a.Fields[i].Equals(&b.Fields[i]) { return false } } @@ -96,7 +112,7 @@ func (a Map) Equals(b Map) bool { return false } for i := range a.Unions { - if !a.Unions[i].Equals(b.Unions[i]) { + if !a.Unions[i].Equals(&b.Unions[i]) { return false } } @@ -104,7 +120,10 @@ func (a Map) Equals(b Map) bool { } // Equals returns true iff the two Unions are equal. -func (a Union) Equals(b Union) bool { +func (a *Union) Equals(b *Union) bool { + if a == nil || b == nil { + return a == nil && b == nil + } if (a.Discriminator == nil) != (b.Discriminator == nil) { return false } @@ -120,7 +139,7 @@ func (a Union) Equals(b Union) bool { return false } for i := range a.Fields { - if !a.Fields[i].Equals(b.Fields[i]) { + if !a.Fields[i].Equals(&b.Fields[i]) { return false } } @@ -128,7 +147,10 @@ func (a Union) Equals(b Union) bool { } // Equals returns true iff the two UnionFields are equal. -func (a UnionField) Equals(b UnionField) bool { +func (a *UnionField) Equals(b *UnionField) bool { + if a == nil || b == nil { + return a == nil && b == nil + } if a.FieldName != b.FieldName { return false } @@ -139,16 +161,22 @@ func (a UnionField) Equals(b UnionField) bool { } // Equals returns true iff the two StructFields are equal. -func (a StructField) Equals(b StructField) bool { +func (a *StructField) Equals(b *StructField) bool { + if a == nil || b == nil { + return a == nil && b == nil + } if a.Name != b.Name { return false } - return a.Type.Equals(b.Type) + return a.Type.Equals(&b.Type) } // Equals returns true iff the two Lists are equal. -func (a List) Equals(b List) bool { - if !a.ElementType.Equals(b.ElementType) { +func (a *List) Equals(b *List) bool { + if a == nil || b == nil { + return a == nil && b == nil + } + if !a.ElementType.Equals(&b.ElementType) { return false } if a.ElementRelationship != b.ElementRelationship { diff --git a/schema/equals_test.go b/schema/equals_test.go index 49f3fff6..a496ea3b 100644 --- a/schema/equals_test.go +++ b/schema/equals_test.go @@ -61,43 +61,43 @@ func TestEquals(t *testing.T) { // add new fields without fixing the Equals function and this test. funcs := []interface{}{ func(x Schema) bool { - if !x.Equals(x) { + if !x.Equals(&x) { return false } var y Schema y.Types = x.Types - return x.Equals(y) == reflect.DeepEqual(x, y) + return x.Equals(&y) == reflect.DeepEqual(&x, &y) }, func(x TypeDef) bool { - if !x.Equals(x) { + if !x.Equals(&x) { return false } var y TypeDef y.Name = x.Name y.Atom = x.Atom - return x.Equals(y) == reflect.DeepEqual(x, y) + return x.Equals(&y) == reflect.DeepEqual(x, y) }, func(x TypeRef) bool { - if !x.Equals(x) { + if !x.Equals(&x) { return false } var y TypeRef y.NamedType = x.NamedType y.Inlined = x.Inlined - return x.Equals(y) == reflect.DeepEqual(x, y) + return x.Equals(&y) == reflect.DeepEqual(x, y) }, func(x Atom) bool { - if !x.Equals(x) { + if !x.Equals(&x) { return false } var y Atom y.Scalar = x.Scalar y.List = x.List y.Map = x.Map - return x.Equals(y) == reflect.DeepEqual(x, y) + return x.Equals(&y) == reflect.DeepEqual(x, y) }, func(x Map) bool { - if !x.Equals(x) { + if !x.Equals(&x) { return false } var y Map @@ -105,45 +105,45 @@ func TestEquals(t *testing.T) { y.ElementRelationship = x.ElementRelationship y.Fields = x.Fields y.Unions = x.Unions - return x.Equals(y) == reflect.DeepEqual(x, y) + return x.Equals(&y) == reflect.DeepEqual(&x, &y) }, func(x Union) bool { - if !x.Equals(x) { + if !x.Equals(&x) { return false } var y Union y.Discriminator = x.Discriminator y.DeduceInvalidDiscriminator = x.DeduceInvalidDiscriminator y.Fields = x.Fields - return x.Equals(y) == reflect.DeepEqual(x, y) + return x.Equals(&y) == reflect.DeepEqual(x, y) }, func(x UnionField) bool { - if !x.Equals(x) { + if !x.Equals(&x) { return false } var y UnionField y.DiscriminatorValue = x.DiscriminatorValue y.FieldName = x.FieldName - return x.Equals(y) == reflect.DeepEqual(x, y) + return x.Equals(&y) == reflect.DeepEqual(x, y) }, func(x StructField) bool { - if !x.Equals(x) { + if !x.Equals(&x) { return false } var y StructField y.Name = x.Name y.Type = x.Type - return x.Equals(y) == reflect.DeepEqual(x, y) + return x.Equals(&y) == reflect.DeepEqual(x, y) }, func(x List) bool { - if !x.Equals(x) { + if !x.Equals(&x) { return false } var y List y.ElementType = x.ElementType y.ElementRelationship = x.ElementRelationship y.Keys = x.Keys - return x.Equals(y) == reflect.DeepEqual(x, y) + return x.Equals(&y) == reflect.DeepEqual(x, y) }, } for i, f := range funcs { diff --git a/typed/merge.go b/typed/merge.go index 8581125c..2584b4f3 100644 --- a/typed/merge.go +++ b/typed/merge.go @@ -76,7 +76,7 @@ func (w *mergingWalker) merge() (errs ValidationErrors) { alhs := deduceAtom(a, w.lhs) arhs := deduceAtom(a, w.rhs) - if alhs.Equals(arhs) { + if alhs.Equals(&arhs) { errs = append(errs, handleAtom(arhs, w.typeRef, w)...) } else { w2 := *w diff --git a/typed/typed.go b/typed/typed.go index c90f8225..51af1e9a 100644 --- a/typed/typed.go +++ b/typed/typed.go @@ -219,7 +219,7 @@ func merge(lhs, rhs *TypedValue, rule, postRule mergeRule) (*TypedValue, error) return nil, errorFormatter{}. errorf("expected objects with types from the same schema") } - if !lhs.typeRef.Equals(rhs.typeRef) { + if !lhs.typeRef.Equals(&rhs.typeRef) { return nil, errorFormatter{}. errorf("expected objects of the same type, but got %v and %v", lhs.typeRef, rhs.typeRef) }