Add support for one-dimensional hashes

Author: mcmire

lib/super_diff/differ.rb

@@ -27,6 +27,8 @@ def call
           diff_strings
         elsif expected.is_a?(Array) && actual.is_a?(Array)
           diff_arrays
+        elsif expected.is_a?(Hash) && actual.is_a?(Hash)
+          diff_hashes
         else
           diff_objects
         end
@@ -137,6 +139,49 @@ def diff_arrays
       OUTPUT
     end
 
+    def diff_hashes
+      all_keys = (expected.keys | actual.keys)
+
+      details = all_keys.inject([]) do |array, key|
+        if expected.include?(key)
+          if actual.include?(key)
+            if expected[key] == actual[key]
+              array
+            else
+              array << "*[#{key.inspect}]: " +
+                "Differing #{plural_type_for(actual[key])}.\n" +
+                "  Expected: #{expected[key].inspect}\n" +
+                "    Actual: #{actual[key].inspect}"
+            end
+          else
+            array << "*[#{key.inspect} -> ?]: Actual is missing key."
+          end
+        else
+          if actual.include?(key)
+            array << "*[? -> #{key.inspect}]: " +
+              "Actual has extra key (with value of #{actual[key].inspect})."
+          else
+            array
+          end
+        end
+      end
+
+      if details.any?
+        <<~OUTPUT
+          Differing hashes.
+
+          Expected: #{inspect(expected)}
+            Actual: #{inspect(actual)}
+
+          Details:
+
+          #{details.map { |detail| "- #{detail}"}.join("\n")}
+        OUTPUT
+      else
+        ""
+      end
+    end
+
     def diff_objects
       <<~OUTPUT
         Differing #{plural_type_for(actual)}.
@@ -166,5 +211,16 @@ def plural_type_for(value)
       else "objects"
       end
     end
+
+    def inspect(value)
+      if value.is_a?(Hash)
+        value.inspect.
+          gsub(/([^,]+)=>([^,]+)/, '\1 => \2').
+          gsub(/:(\w+) => /, '\1: ').
+          gsub(/\{([^{}]+)\}/, '{ \1 }')
+      else
+        value.inspect
+      end
+    end
   end
 end

spec/unit/differ_spec.rb

@@ -258,7 +258,7 @@
       end
     end
 
-    context "given two one-dimensional arrays where the actual has added elements" do
+    context "given two one-dimensional arrays where the actual has extra elements" do
       it "returns a message along with the diff" do
         actual_output = described_class.call(
           expected: ["foo", "bar"],
@@ -307,14 +307,162 @@
     context "given the same hash" do
       it "returns an empty string" do
         output = described_class.call(
-          expected: { foo: "bar" },
-          actual: { foo: "bar" }
+          expected: { name: "Elliot" },
+          actual: { name: "Elliot" }
         )
 
         expect(output).to eq("")
       end
     end
 
+    context "given two equal-size, one-dimensional hashes where the same key has differing numbers" do
+      it "returns a message along with the diff" do
+        actual_output = described_class.call(
+          expected: { tall: 12, grande: 19, venti: 20 },
+          actual: { tall: 12, grande: 16, venti: 20 }
+        )
+
+        expected_output = <<~STR
+          Differing hashes.
+
+          Expected: { tall: 12, grande: 19, venti: 20 }
+            Actual: { tall: 12, grande: 16, venti: 20 }
+
+          Details:
+
+          - *[:grande]: Differing numbers.
+            Expected: 19
+              Actual: 16
+        STR
+
+        expect(actual_output).to eq(expected_output)
+      end
+    end
+
+    context "given two equal-size, one-dimensional hashes where the same key has differing symbols" do
+      it "returns a message along with the diff" do
+        actual_output = described_class.call(
+          expected: { tall: :small, grande: :grand, venti: :large },
+          actual: { tall: :small, grande: :medium, venti: :large },
+        )
+
+        expected_output = <<~STR
+          Differing hashes.
+
+          Expected: { tall: :small, grande: :grand, venti: :large }
+            Actual: { tall: :small, grande: :medium, venti: :large }
+
+          Details:
+
+          - *[:grande]: Differing symbols.
+            Expected: :grand
+              Actual: :medium
+        STR
+
+        expect(actual_output).to eq(expected_output)
+      end
+    end
+
+    context "given two equal-size, one-dimensional hashes where the same key has differing strings" do
+      it "returns a message along with the diff" do
+        actual_output = described_class.call(
+          expected: { tall: "small", grande: "grand", venti: "large" },
+          actual: { tall: "small", grande: "medium", venti: "large" },
+        )
+
+        expected_output = <<~STR
+          Differing hashes.
+
+          Expected: { tall: "small", grande: "grand", venti: "large" }
+            Actual: { tall: "small", grande: "medium", venti: "large" }
+
+          Details:
+
+          - *[:grande]: Differing strings.
+            Expected: "grand"
+              Actual: "medium"
+        STR
+
+        expect(actual_output).to eq(expected_output)
+      end
+    end
+
+    context "given two equal-size, one-dimensional hashes where the same key has differing objects" do
+      it "returns a message along with the diff" do
+        actual_output = described_class.call(
+          expected: {
+            steve: SuperDiff::Test::Person.new(name: "Jobs"),
+            susan: SuperDiff::Test::Person.new(name: "Kare")
+          },
+          actual: {
+            steve: SuperDiff::Test::Person.new(name: "Wozniak"),
+            susan: SuperDiff::Test::Person.new(name: "Kare")
+          }
+        )
+
+        expected_output = <<~STR
+          Differing hashes.
+
+          Expected: { steve: #<Person name="Jobs">, susan: #<Person name="Kare"> }
+            Actual: { steve: #<Person name="Wozniak">, susan: #<Person name="Kare"> }
+
+          Details:
+
+          - *[:steve]: Differing objects.
+            Expected: #<Person name="Jobs">
+              Actual: #<Person name="Wozniak">
+        STR
+
+        expect(actual_output).to eq(expected_output)
+      end
+    end
+
+    context "given two equal-size, one-dimensional hashes where the actual has extra keys" do
+      it "returns a message along with the diff" do
+        actual_output = described_class.call(
+          expected: { latte: 4.5 },
+          actual: { latte: 4.5, mocha: 3.5, cortado: 3 }
+        )
+
+        expected_output = <<~STR
+          Differing hashes.
+
+          Expected: { latte: 4.5 }
+            Actual: { latte: 4.5, mocha: 3.5, cortado: 3 }
+
+          Details:
+
+          - *[? -> :mocha]: Actual has extra key (with value of 3.5).
+          - *[? -> :cortado]: Actual has extra key (with value of 3).
+        STR
+
+        expect(actual_output).to eq(expected_output)
+      end
+    end
+
+    context "given two equal-size, one-dimensional hashes where the actual has missing keys" do
+      it "returns a message along with the diff" do
+        actual_output = described_class.call(
+          expected: { latte: 4.5, mocha: 3.5, cortado: 3 },
+          actual: { latte: 4.5 }
+        )
+
+        expected_output = <<~STR
+          Differing hashes.
+
+          Expected: { latte: 4.5, mocha: 3.5, cortado: 3 }
+            Actual: { latte: 4.5 }
+
+          Details:
+
+          - *[:mocha -> ?]: Actual is missing key.
+          - *[:cortado -> ?]: Actual is missing key.
+        STR
+
+        expect(actual_output).to eq(expected_output)
+      end
+    end
+
     context "given two objects which == each other" do
       it "returns an empty string" do
         expected = SuperDiff::Test::Person.new(name: "Elliot")