Merge pull request #4 from yazgazan/adding-ignore-values

Adding --ignore-values

Author: yazgazan

Readme.md

@@ -28,6 +28,7 @@ Application Options:
       --indent=        indent string (default: "\t")
   -t, --show-types     show types
       --ignore-excess  ignore excess keys and arrey elements
+      --ignore-values  ignore scalar's values (only type is compared)
   -r, --report         output report format
 
 Help Options:
@@ -115,6 +116,17 @@ $ jaydiff --report --show-types --ignore-excess old.json new.json
 - .f: float64 42
 ```
 
+Ignore values (type must still match):
+
+```diff
+$ jaydiff --report --show-types --ignore-excess --ignore-values old.json new.json
+
+- .c.b: float64 23
++ .c.b: string 23
+- .e: []interface {} []
+- .f: float64 42
+```
+
 # Ideas
 
 - JayPatch

config.go

@@ -18,6 +18,7 @@ type config struct {
 	Ignore ignorePatterns `long:"ignore" short:"i" description:"paths to ignore (glob)"`
 	output
 	IgnoreExcess bool `long:"ignore-excess" description:"ignore excess keys and arrey elements"`
+	IgnoreValues bool `long:"ignore-values" description:"ignore scalar's values (only type is compared)"`
 	OutputReport bool `long:"report" short:"r" description:"output report format"`
 }
 

diff/diff.go

@@ -88,7 +88,7 @@ func (t Type) String() string {
 	return "invalid type"
 }
 
-// IsExcess can be used in a WalkFn to find values missing from the LHS
+// IsExcess returns true if d represent value missing from the LHS (in a map or an array)
 func IsExcess(d Differ) bool {
 	switch d.(type) {
 	default:
@@ -100,7 +100,7 @@ func IsExcess(d Differ) bool {
 	}
 }
 
-// IsMissing can be used in a WalkFn to find values missing from the RHS
+// IsMissing returns true if d represent value missing from the RHS (in a map or an array)
 func IsMissing(d Differ) bool {
 	switch d.(type) {
 	default:
@@ -112,23 +112,58 @@ func IsMissing(d Differ) bool {
 	}
 }
 
+// IsScalar returns true of d is a diff between two values that can be compared (int, float64, string, ...)
+func IsScalar(d Differ) bool {
+	_, ok := d.(scalar)
+
+	return ok
+}
+
+// IsTypes returns true if d is a diff between two values of different types that cannot be compared
+func IsTypes(d Differ) bool {
+	_, ok := d.(types)
+
+	return ok
+}
+
+// IsIgnore returns true if d is a diff created by NewIgnore
+func IsIgnore(d Differ) bool {
+	_, ok := d.(ignore)
+
+	return ok
+}
+
+// IsMap returns true if d is a diff between towo maps
+func IsMap(d Differ) bool {
+	_, ok := d.(mapDiff)
+
+	return ok
+}
+
+// IsSlice returns true if d is a diff between towo slices
+func IsSlice(d Differ) bool {
+	_, ok := d.(slice)
+
+	return ok
+}
+
 type visited struct {
-	LHS []uintptr
-	RHS []uintptr
+	lhs []uintptr
+	rhs []uintptr
 }
 
 func (v *visited) add(lhs, rhs reflect.Value) error {
 	if canAddr(lhs) {
-		if inPointers(v.LHS, lhs) {
+		if inPointers(v.lhs, lhs) {
 			return ErrCyclic
 		}
-		v.LHS = append(v.LHS, lhs.Pointer())
+		v.lhs = append(v.lhs, lhs.Pointer())
 	}
 	if canAddr(rhs) {
-		if inPointers(v.RHS, rhs) {
+		if inPointers(v.rhs, rhs) {
 			return ErrCyclic
 		}
-		v.RHS = append(v.RHS, rhs.Pointer())
+		v.rhs = append(v.rhs, rhs.Pointer())
 	}
 
 	return nil

diff/diff_test.go

@@ -502,3 +502,58 @@ func testStrings(context string, t *testing.T, test stringTest, ss []string, ind
 		}
 	}
 }
+
+func TestIsScalar(t *testing.T) {
+	d, err := Diff(42, 23)
+	if err != nil {
+		t.Errorf("Diff(42, 23): unexpected error: %s", err)
+		return
+	}
+	if !IsScalar(d) {
+		t.Error("IsScalar(Diff(42, 23)) = false, expected true")
+	}
+}
+
+func TestIsTypes(t *testing.T) {
+	d, err := Diff(42, []string{"hop"})
+	if err != nil {
+		t.Errorf("Diff(42, \"hop\"): unexpected error: %s", err)
+		return
+	}
+	if !IsTypes(d) {
+		t.Error("IsTypes(Diff(42, \"hop\")) = false, expected true")
+	}
+}
+
+func TestIsIgnore(t *testing.T) {
+	d, err := Ignore()
+	if err != nil {
+		t.Errorf("Ignore(): unexpected error: %s", err)
+		return
+	}
+	if !IsIgnore(d) {
+		t.Error("IsIgnore(Ignore()) = false, expected true")
+	}
+}
+
+func TestIsMap(t *testing.T) {
+	d, err := Diff(map[int]bool{0: true, 1: false}, map[int]bool{0: false, 1: true})
+	if err != nil {
+		t.Errorf("Diff(map[int]bool, map[int]bool): unexpected error: %s", err)
+		return
+	}
+	if !IsMap(d) {
+		t.Error("IsMap(Diff(map[int]bool, map[int]bool)) = false, expected true")
+	}
+}
+
+func TestIsSlice(t *testing.T) {
+	d, err := Diff([]int{0, 1}, []int{2, 3})
+	if err != nil {
+		t.Errorf("Diff([]int, []int): unexpected error: %s", err)
+		return
+	}
+	if !IsSlice(d) {
+		t.Error("IsSlice(Diff(map{...}, map{...})) = false, expected true")
+	}
+}

generate_readme_examples.sh

@@ -38,4 +38,12 @@ $ jaydiff --report --show-types --ignore-excess old.json new.json
 $(./jaydiff --report --ignore-excess --indent='    ' --show-types test_files/lhs.json test_files/rhs.json)
 $(echo '```')
 
+Ignore values (type must still match):
+
+$(echo '```diff')
+$ jaydiff --report --show-types --ignore-excess --ignore-values old.json new.json
+
+$(./jaydiff --report --ignore-excess --ignore-values --indent='    ' --show-types test_files/lhs.json test_files/rhs.json)
+$(echo '```')
+
 EOF

main.go

@@ -30,7 +30,7 @@ func main() {
 		os.Exit(statusDiffError)
 	}
 
-	d, err = pruneIgnore(d, conf.IgnoreExcess, conf.Ignore)
+	d, err = pruneIgnore(d, conf.IgnoreExcess, conf.IgnoreValues, conf.Ignore)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "Error: ignoring failed: %s", err)
 		os.Exit(statusDiffError)
@@ -53,7 +53,7 @@ func main() {
 	}
 }
 
-func pruneIgnore(d diff.Differ, ingoreExcess bool, ignore ignorePatterns) (diff.Differ, error) {
+func pruneIgnore(d diff.Differ, ingoreExcess, ignoreValues bool, ignore ignorePatterns) (diff.Differ, error) {
 	return diff.Walk(d, func(parent diff.Differ, d diff.Differ, path string) (diff.Differ, error) {
 		if ignore.Match(path) {
 			return diff.Ignore()
@@ -63,6 +63,10 @@ func pruneIgnore(d diff.Differ, ingoreExcess bool, ignore ignorePatterns) (diff.
 			return diff.Ignore()
 		}
 
+		if ignoreValues && diff.IsScalar(d) && d.Diff() == diff.ContentDiffer {
+			return diff.Ignore()
+		}
+
 		return nil, nil
 	})
 }