json-deep-compare 0.0.1 → 0.1.0

data/lib/json-deep-compare.rb

@@ -1,114 +1,201 @@
 module JsonDeepCompare
-  VERSION = '0.0.1'
+  VERSION = '0.1.0'
+
+  class DocumentComparison
+    def initialize(lval, rval, options = {})
+      if exclusions = options[:exclusions]
+        options[:exclusions] = [exclusions] unless exclusions.is_a?(Array)
+      else
+        options[:exclusions] = []
+      end
+      @root_comparisons = []
+      @root_comparisons << NodeComparison.new(lval, rval, ":root", options)
+      @root_comparisons << NodeComparison.new(rval, lval, ":root", options)
+    end
+
+    def difference_messages
+      ldiffs = @root_comparisons.first.differences
+      rdiffs = @root_comparisons.last.differences
+      differences = ldiffs.dup
+      ldiff_selectors = ldiffs.map { |ldiff| ldiff.selector }
+      rdiffs.each do |rdiff|
+        unless ldiff_selectors.include?(rdiff.selector)
+          differences << rdiff.reverse
+        end
+      end
+      differences = differences.sort_by &:selector
+      differences.map(&:message).join("\n")
+    end
+
+    def equal?
+      @root_comparisons.all?(&:equal?)
+    end
+  end
 
   class NodeComparison
     ExcerptPadding = 15
-    attr_reader :left_value, :right_value, :selector
+    attr_reader :lval, :rval, :selector
 
-    def initialize(left_value, right_value, options = {})
-      @left_value, @right_value = left_value, right_value             
-      @selector = options[:selector] || ':root'
-      @exclusions = options[:exclusions]
-      @exclusions = [@exclusions] unless @exclusions.is_a?(Array)
+    def initialize(lval, rval, selector, options = {})
+      @lval, @rval, @selector, @options = lval, rval, selector, options
       @children = []
-      if left_value.is_a?(Hash)
-        if right_value.is_a?(Hash)
-          left_value.each do |key, left_sub_value|
+      if lval.is_a?(Hash)
+        if rval.is_a?(Hash)
+          lval.each do |key, left_sub_value|
             @children << NodeComparison.new(
-              left_sub_value, right_value[key], 
-              selector: "#{selector} > .#{key}", exclusions: @exclusions
+              left_sub_value, 
+              rval[key], 
+              "#{selector} > .#{key}", 
+              options
             )
           end
         end
-      elsif left_value.is_a?(Array)
-        if right_value.is_a?(Array)
-          left_value.each_with_index do |left_sub_value, i|
+      elsif lval.is_a?(Array)
+        if rval.is_a?(Array)
+          lval.each_with_index do |left_sub_value, i|
             @children << NodeComparison.new(
-              left_sub_value, right_value[i], 
-              selector: "#{selector} :nth-child(#{i+1})", 
-              exclusions: @exclusions
+              left_sub_value, 
+              rval[i], 
+              "#{selector} :nth-child(#{i+1})",
+              options
             )
           end
         end
       end
     end
 
-    def value_inspect(value)
-      str = value.inspect
-      if str.length >= 40
-        "#{value.class.name} #{str[0..37]}..."
-      else
-        str
-      end
+    def blank?(value)
+      value.respond_to?(:empty?) ? value.empty? : !value
     end
 
-    def difference_message
-      unless equal?
+    def blank_equality?
+      @options[:blank_equality]
+    end
+
+    def differences
+      if equal?
+        []
+      else
         if leaf?
           if excerptable_difference?
-            excerpted_difference
+            [excerpted_difference]
           else
-            "#{@selector.inspect} expected to be #{value_inspect(@left_value)} but was #{value_inspect(@right_value)}"
+            [Difference.new(
+              @selector, "expected to be :lval but was :rval",
+              lval: value_inspect(@lval), rval: value_inspect(@rval)
+            )]
           end
         else
-          @children.reject(&:equal?).map(&:difference_message).join("\n")
+          @children.map(&:differences).compact.flatten
         end
       end
     end
 
     def equal?
       if leaf?
-        @exclusions.include?(@selector) || @left_value == @right_value
+        if selector_excluded?
+          true
+        elsif equality_proc
+          equality_proc.call(@lval, @rval)
+        else
+          @lval == @rval || (blank_equality? && blank?(@lval) && blank?(@rval))
+        end
       else
         @children.all?(&:equal?)
       end
     end
 
+    def equality_proc
+      @options[:equality]
+    end
+
     def excerptable_difference?
-      @left_value.is_a?(String) and @right_value.is_a?(String) && (
-        @left_value.size > ExcerptPadding * 2 || 
-        @right_value.size > ExcerptPadding * 2
+      @lval.is_a?(String) and @rval.is_a?(String) && (
+        @lval.size > ExcerptPadding * 2 || @rval.size > ExcerptPadding * 2
       )
     end
 
     def excerpted_difference
-      difference_start = (0..@left_value.length).detect { |i| 
-        @left_value[i] != @right_value[i]
-      }
+      difference_start = (0..@lval.length).detect { |i| @lval[i] != @rval[i] }
       range_start = if difference_start > ExcerptPadding
         difference_start - ExcerptPadding
       else
         0
       end
-      left_excerpt = @left_value[
-        range_start..difference_start+ExcerptPadding
-      ]
-      right_excerpt = @right_value[
-        range_start..difference_start+ExcerptPadding
-      ]
+      left_excerpt = @lval[range_start..difference_start+ExcerptPadding]
+      right_excerpt = @rval[range_start..difference_start+ExcerptPadding]
       if difference_start - ExcerptPadding > 0
         left_excerpt = "..." + left_excerpt
         right_excerpt = "..." + right_excerpt
       end
-      if difference_start + ExcerptPadding < @left_value.length
+      if difference_start + ExcerptPadding < @lval.length
         left_excerpt = left_excerpt + '...'
       end
-      if difference_start + ExcerptPadding < @right_value.length
+      if difference_start + ExcerptPadding < @rval.length
         right_excerpt = right_excerpt + '...'
       end
-      "#{@selector.inspect} differs starting at char #{difference_start}: #{left_excerpt.inspect} differs from #{right_excerpt.inspect}"
+      Difference.new(
+        @selector,
+        "differs starting at char :difference_start: :lval differs from :rval",
+        difference_start: difference_start.to_s,
+        lval: left_excerpt.inspect, rval: right_excerpt.inspect
+      )
     end
 
     def leaf?
       @children.empty?
     end
+
+    def selector_excluded?
+      @options[:exclusions].any? { |exclusion|
+        if exclusion.is_a?(String)
+          exclusion == @selector
+        else
+          @selector =~ exclusion
+        end
+      }
+    end
+
+    def value_inspect(value)
+      str = value.inspect
+      if str.length >= 40
+        "#{value.class.name} #{str[0..37]}..."
+      else
+        str
+      end
+    end
+
+    class Difference
+      attr_reader :selector
+
+      def initialize(selector, msg_template, variables)
+        @selector, @msg_template, @variables = 
+          selector, msg_template, variables
+      end
+
+      def message
+        msg = @msg_template
+        @variables.each do |name, value|
+          msg = msg.gsub(/#{name.inspect}/, value)
+        end
+        "#{@selector.inspect} #{msg}"
+      end
+
+      def reverse
+        reversed_variables = {lval: @variables[:rval], rval: @variables[:lval]}
+        (@variables.keys - [:lval, :rval]).each do |other_var|
+          reversed_variables[other_var] = @variables[other_var]
+        end
+        Difference.new(@selector, @msg_template, reversed_variables)
+      end
+    end
   end
 
   module Assertions
     def assert_json_equal(expected, actual, exclusions = nil)
-      comparison = NodeComparison.new(expected, actual, exclusions: exclusions)
+      comparison = DocumentComparison.new(expected, actual, exclusions: exclusions)
       unless comparison.equal?
-        fail comparison.difference_message
+        fail comparison.difference_messages
       end
     end
   end

data/test/json_deep_compare_test.rb

@@ -2,7 +2,41 @@ require 'test/unit'
 $: << '.'
 require 'lib/json-deep-compare'
 
-class NodeComparisonTestCase < Test::Unit::TestCase
+class DocumentComparisonTestCase < Test::Unit::TestCase
+  def assert_symmetrically_different(
+    lval, rval, message_template = nil, sub_pairs = nil
+  )
+    sub_pairs = [sub_pairs] if sub_pairs and sub_pairs.first.is_a?(String)
+    comparison1 = JsonDeepCompare::DocumentComparison.new(lval, rval)
+    assert(
+      !comparison1.equal?, 
+      "Comparison of #{lval.inspect} to #{rval.inspect} should not have been equal"
+    )
+    if message_template
+      message1 = message_template
+      sub_pairs.each_with_index do |sub_pair, i|
+        message1 = message1.
+          sub(/:left#{i}/, sub_pair.first).
+          sub(/:right#{i}/, sub_pair.last)
+      end
+      assert_equal(message1, comparison1.difference_messages)
+    end
+    comparison2 = JsonDeepCompare::DocumentComparison.new(rval, lval)
+    assert(
+      !comparison2.equal?, 
+      "Comparison of #{rval.inspect} to #{lval.inspect} should not have been equal"
+    )
+    if message_template
+      message2 = message_template
+      sub_pairs.each_with_index do |sub_pair, i|
+        message2 = message2.
+          sub(/:left#{i}/, sub_pair.last).
+          sub(/:right#{i}/, sub_pair.first)
+      end
+      assert_equal(message2, comparison2.difference_messages)
+    end
+  end
+
   def test_detects_difference_in_atoms
     left_value = {
       'total_rows' => 2,
@@ -30,29 +64,36 @@ class NodeComparisonTestCase < Test::Unit::TestCase
         }
       ]
     }
-    comparison = JsonDeepCompare::NodeComparison.new(left_value, right_value)
-    assert !comparison.equal?
-    assert_equal(
-      "\":root > .rows :nth-child(1) > .doc > .sub_document > .one\" expected to be \"two\" but was \"1\"", 
-      comparison.difference_message
+    assert_symmetrically_different(
+      left_value, right_value, 
+      "\":root > .rows :nth-child(1) > .doc > .sub_document > .one\" expected to be :left0 but was :right0",
+      ["two".inspect, "1".inspect]
     )
   end
 
   def test_detects_differences_in_keys
     left_value = {"doc" => {"foo" => "bar"}}
     right_value = {"doc" => {"biz" => "bang", "bing" => nil}}
-    comparison = JsonDeepCompare::NodeComparison.new(left_value, right_value)
-    assert !comparison.equal?
+    assert_symmetrically_different(left_value, right_value)
+  end
+
+  def test_missing_keys
+    lval = {"outer" => {"key1" => "value1"}}
+    rval = {"outer" => {"key1" => "value1", "key2" => {"foo" => "bar"}}}
+    assert_symmetrically_different(
+      lval, rval,
+      "\":root > .outer > .key2\" expected to be :left0 but was :right0",
+      ["nil", {"foo" => "bar"}.inspect]
+    )
   end
 
   def test_detects_difference_in_type
     lval = {"foo" => {'bar' => 'bang'}}
     rval = {"foo" => [3,4,5]}
-    comparison = JsonDeepCompare::NodeComparison.new(lval, rval)
-    assert !comparison.equal?
-    assert_equal(
-      "\":root > .foo\" expected to be {\"bar\"=>\"bang\"} but was [3, 4, 5]",
-      comparison.difference_message
+    assert_symmetrically_different(
+      lval, rval,
+      "\":root > .foo\" expected to be :left0 but was :right0",
+      [{"bar" => "bang"}.inspect, [3,4,5].inspect]
     )
   end
 
@@ -63,64 +104,98 @@ class NodeComparisonTestCase < Test::Unit::TestCase
     end
     lval = {"foo" => lval_hash}
     rval = {"foo" => [3,4,5]}
-    comparison = JsonDeepCompare::NodeComparison.new(lval, rval)
-    assert !comparison.equal?
-    assert_equal(
-      "\":root > .foo\" expected to be Hash {\"A\"=>\"A\", \"B\"=>\"B\", \"C\"=>\"C\", \"D\"=>\"D... but was [3, 4, 5]",
-      comparison.difference_message
+    assert_symmetrically_different(
+      lval, rval,
+      "\":root > .foo\" expected to be :left0 but was :right0",
+      [
+        "Hash {\"A\"=>\"A\", \"B\"=>\"B\", \"C\"=>\"C\", \"D\"=>\"D...", 
+        [3,4,5].inspect
+      ]
     )
   end
 
   def test_lists_multliple_differences
     lval = {'one' => {'two' => 'three', 'four' => 'five'}, 'six' => 'seven'}
     rval = {'one' => {'two' => 'TWO', 'four' => 'five'}, 'six' => 'SIX'}
-    comparison = JsonDeepCompare::NodeComparison.new(lval, rval)
-    assert !comparison.equal?
-    assert_equal(
-      "\":root > .one > .two\" expected to be \"three\" but was \"TWO\"\n\":root > .six\" expected to be \"seven\" but was \"SIX\"",
-      comparison.difference_message
+    assert_symmetrically_different(
+      lval, rval,
+      "\":root > .one > .two\" expected to be :left0 but was :right0\n\":root > .six\" expected to be :left1 but was :right1",
+      [["three".inspect, "TWO".inspect], ["seven".inspect, "SIX".inspect]]
     )
   end
 
   def test_detects_difference_between_array_and_nil
     lval = {'one' => [1,2,3]}
     rval = {'one' => nil}
-    comparison = JsonDeepCompare::NodeComparison.new(lval, rval)
-    assert !comparison.equal?
-    assert_equal(
-      "\":root > .one\" expected to be [1, 2, 3] but was nil",
-      comparison.difference_message
+    assert_symmetrically_different(
+      lval, rval,
+      "\":root > .one\" expected to be :left0 but was :right0",
+      [[1,2,3].inspect, 'nil']
     )
   end
 
   def test_shows_first_string_difference
     lval = {'body' => "Four score and seven years ago our fathers brought forth on this continent, a new nation, conceived in Liberty, and dedicated to the proposition that all men are created equal."}
     rval = {'body' => "Four score and seven years ago our fathers brought forth on this continent, a new nation, conceived in liberty, and dedicated to the proposition that all men are created equal."}
-    comparison = JsonDeepCompare::NodeComparison.new(lval, rval)
-    assert !comparison.equal?
-    assert_equal(
-      "\":root > .body\" differs starting at char 103: \"..., conceived in Liberty, and ded...\" differs from \"..., conceived in liberty, and ded...\"",
-      comparison.difference_message
+    assert_symmetrically_different(
+      lval, rval,
+      "\":root > .body\" differs starting at char 103: :left0 differs from :right0",
+      [
+        "..., conceived in Liberty, and ded...".inspect,
+        "..., conceived in liberty, and ded...".inspect
+      ]
     )
   end
 
   def test_shows_string_difference_start
     lval = {'rev' => "22-23c92a95665bb692313229c8224b7088"}
     rval = {'rev' => "23-54a5106f8c522a57d6d4c6963bc36611"}
-    comparison = JsonDeepCompare::NodeComparison.new(lval, rval)
-    assert !comparison.equal?
-    assert_equal(
-      "\":root > .rev\" differs starting at char 1: \"22-23c92a95665bb6...\" differs from \"23-54a5106f8c522a...\"",
-      comparison.difference_message
+    assert_symmetrically_different(
+      lval, rval,
+      "\":root > .rev\" differs starting at char 1: :left0 differs from :right0",
+      ["22-23c92a95665bb6...".inspect, "23-54a5106f8c522a...".inspect]
     )
   end
 
   def test_simple_exclusion
     lval = {'one' => 'two', 'three' => 'four'}
     rval = {'one' => 'two', 'three' => 'THREE'}
-    comparison = JsonDeepCompare::NodeComparison.new(
+    comparison = JsonDeepCompare::DocumentComparison.new(
       lval, rval, exclusions: [":root > .three"]
     )
     assert comparison.equal?
   end
+
+  def test_exclusion_regexp
+    lval = {'one' => 'two', 'three' => 'four'}
+    rval = {'one' => 'two', 'three' => 'THREE'}
+    comparison = JsonDeepCompare::DocumentComparison.new(
+      lval, rval, exclusions: [/> \.three$/]
+    )
+    assert comparison.equal?
+  end
+
+  def test_blank_equality_option
+    lval = {'one' => 'two', 'three' => ''}
+    rval = {'one' => 'two', 'three' => nil}
+    comparison = JsonDeepCompare::DocumentComparison.new(
+      lval, rval, blank_equality: true
+    )
+    assert comparison.equal?
+  end
+
+  def test_equality_proc_option
+    lval = {'one' => 2, 'three' => "He says 'hi'"}
+    rval = {'one' => 2, 'three' => "He says \"hi\""}
+    comparison = JsonDeepCompare::DocumentComparison.new(
+      lval, rval, equality: Proc.new { |lval, rval|
+        if lval.is_a?(String) && rval.is_a?(String)
+          lval.gsub(/"/, "'") == rval.gsub(/"/, "'")
+        else
+          lval == rval
+        end
+      }
+    )
+    assert comparison.equal?
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: json-deep-compare
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-03 00:00:00.000000000 Z
+date: 2014-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -73,7 +73,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 383603838726367257
+      hash: 634763774305586060
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -82,7 +82,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 383603838726367257
+      hash: 634763774305586060
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23