Fix inspection of empty values in diffs

When inspecting an empty value, such an array, hash, or object — even
when using `singleline: false` — don't try to split that value across
multiple lines.

Author: mcmire

lib/super_diff/object_inspection/inspection_tree.rb

@@ -53,6 +53,14 @@ def nested(&block)
         add_node :nesting, &block
       end
 
+      def when_empty(&block)
+        add_node :when_empty, &block
+      end
+
+      def when_non_empty(&block)
+        add_node :when_non_empty, &block
+      end
+
       def insert_array_inspection_of(array)
         # FIXME: why must this be inside the `nested`?
         add_break

lib/super_diff/object_inspection/inspectors/array.rb

@@ -2,14 +2,20 @@ module SuperDiff
   module ObjectInspection
     module Inspectors
       Array = InspectionTree.new do
-        add_text "["
-
-        nested do |array|
-          insert_array_inspection_of(array)
+        when_empty do
+          add_text "[]"
         end
 
-        add_break
-        add_text "]"
+        when_non_empty do
+          add_text "["
+
+          nested do |array|
+            insert_array_inspection_of(array)
+          end
+
+          add_break
+          add_text "]"
+        end
       end
     end
   end

lib/super_diff/object_inspection/inspectors/default_object.rb

@@ -2,36 +2,44 @@ module SuperDiff
   module ObjectInspection
     module Inspectors
       DefaultObject = InspectionTree.new do
-        when_singleline do
+        when_empty do
           add_text do |object|
             object.inspect
           end
         end
 
-        when_multiline do
-          add_text do |object|
-            "#<%<class>s:0x%<id>x {" % {
-              class: object.class,
-              id: object.object_id * 2,
-            }
+        when_non_empty do
+          when_singleline do
+            add_text do |object|
+              object.inspect
+            end
           end
 
-          nested do |object|
-            add_break " "
+          when_multiline do
+            add_text do |object|
+              "#<%<class>s:0x%<id>x {" % {
+                class: object.class,
+                id: object.object_id * 2,
+              }
+            end
+
+            nested do |object|
+              add_break " "
 
-            insert_separated_list(
-              object.instance_variables.sort,
-              separator: ","
-            ) do |name|
-              add_text name.to_s
-              add_text "="
-              add_inspection_of object.instance_variable_get(name)
+              insert_separated_list(
+                object.instance_variables.sort,
+                separator: ","
+              ) do |name|
+                add_text name.to_s
+                add_text "="
+                add_inspection_of object.instance_variable_get(name)
+              end
             end
-          end
 
-          add_break
+            add_break
 
-          add_text "}>"
+            add_text "}>"
+          end
         end
       end
     end

lib/super_diff/object_inspection/inspectors/hash.rb

@@ -2,14 +2,20 @@ module SuperDiff
   module ObjectInspection
     module Inspectors
       Hash = InspectionTree.new do
-        add_text "{"
-
-        nested do |hash|
-          insert_hash_inspection_of(hash)
+        when_empty do
+          add_text "{}"
         end
 
-        add_break " "
-        add_text "}"
+        when_non_empty do
+          add_text "{"
+
+          nested do |hash|
+            insert_hash_inspection_of(hash)
+          end
+
+          add_break " "
+          add_text "}"
+        end
       end
     end
   end

lib/super_diff/object_inspection/map.rb

@@ -16,8 +16,9 @@ def call(object)
             Inspectors::Hash
           when String
             Inspectors::String
-          when true, false, nil, Symbol, Numeric, Regexp
-            Inspectors::Primitive else
+          when true, false, nil, Symbol, Numeric, Regexp, Class
+            Inspectors::Primitive
+          else
             Inspectors::DefaultObject
           end
         end

lib/super_diff/object_inspection/nodes.rb

@@ -6,18 +6,29 @@ module Nodes
       autoload :Inspection, "super_diff/object_inspection/nodes/inspection"
       autoload :Nesting, "super_diff/object_inspection/nodes/nesting"
       autoload :Text, "super_diff/object_inspection/nodes/text"
+      autoload(
+        :WhenEmpty,
+        "super_diff/object_inspection/nodes/when_empty",
+      )
       autoload(
         :WhenMultiline,
         "super_diff/object_inspection/nodes/when_multiline",
       )
+      autoload(
+        :WhenNonEmpty,
+        "super_diff/object_inspection/nodes/when_non_empty",
+      )
       autoload(
         :WhenSingleline,
         "super_diff/object_inspection/nodes/when_singleline",
       )
 
       def self.fetch(type)
         registry.fetch(type) do
-          raise KeyError, "Could not find a node class for #{type.inspect}!"
+          raise(
+            KeyError,
+            "#{type.inspect} is not included in ObjectInspection::Nodes.registry!",
+          )
         end
       end
 
@@ -27,7 +38,9 @@ def self.registry
           inspection: Inspection,
           nesting: Nesting,
           text: Text,
+          when_empty: WhenEmpty,
           when_multiline: WhenMultiline,
+          when_non_empty: WhenNonEmpty,
           when_singleline: WhenSingleline,
         }
       end

lib/super_diff/object_inspection/nodes/when_empty.rb

@@ -0,0 +1,30 @@
+module SuperDiff
+  module ObjectInspection
+    module Nodes
+      class WhenEmpty < Base
+        def evaluate(object, indent_level:, as_single_line:)
+          if empty?(object)
+            evaluate_in_subtree(
+              object,
+              indent_level: indent_level,
+              as_single_line: as_single_line,
+              &block
+            )
+          else
+            ""
+          end
+        end
+
+        private
+
+        def empty?(object)
+          if object.respond_to?(:empty?)
+            object.empty?
+          else
+            object.instance_variables.empty?
+          end
+        end
+      end
+    end
+  end
+end

lib/super_diff/object_inspection/nodes/when_non_empty.rb

@@ -0,0 +1,30 @@
+module SuperDiff
+  module ObjectInspection
+    module Nodes
+      class WhenNonEmpty < Base
+        def evaluate(object, indent_level:, as_single_line:)
+          if empty?(object)
+            ""
+          else
+            evaluate_in_subtree(
+              object,
+              indent_level: indent_level,
+              as_single_line: as_single_line,
+              &block
+            )
+          end
+        end
+
+        private
+
+        def empty?(object)
+          if object.respond_to?(:empty?)
+            object.empty?
+          else
+            object.instance_variables.empty?
+          end
+        end
+      end
+    end
+  end
+end

spec/integration/rspec/eq_matcher_spec.rb

@@ -756,4 +756,119 @@
       end
     end
   end
+
+  context "when comparing two data structures where one contains an empty array" do
+    it "formats the array correctly in the diff" do
+      as_both_colored_and_uncolored do |color_enabled|
+        snippet = <<~TEST.strip
+          expected = { foo: nil }
+          actual = { foo: [] }
+          expect(actual).to eq(expected)
+        TEST
+        program = make_plain_test_program(snippet, color_enabled: color_enabled)
+
+        expected_output = build_expected_output(
+          color_enabled: color_enabled,
+          snippet: %|expect(actual).to eq(expected)|,
+          newline_before_expectation: true,
+          expectation: proc {
+            line do
+              plain "Expected "
+              green %|{ foo: [] }|
+              plain " to eq "
+              red %|{ foo: nil }|
+              plain "."
+            end
+          },
+          diff: proc {
+            plain_line %|  {|
+            red_line   %|-   foo: nil|
+            green_line %|+   foo: []|
+            plain_line %|  }|
+          }
+        )
+
+        expect(program).
+          to produce_output_when_run(expected_output).
+          in_color(color_enabled)
+      end
+    end
+  end
+
+  context "when comparing two data structures where one contains an empty hash" do
+    it "formats the hash correctly in the diff" do
+      as_both_colored_and_uncolored do |color_enabled|
+        snippet = <<~TEST.strip
+          expected = { foo: nil }
+          actual = { foo: {} }
+          expect(actual).to eq(expected)
+        TEST
+        program = make_plain_test_program(snippet, color_enabled: color_enabled)
+
+        expected_output = build_expected_output(
+          color_enabled: color_enabled,
+          snippet: %|expect(actual).to eq(expected)|,
+          newline_before_expectation: true,
+          expectation: proc {
+            line do
+              plain "Expected "
+              green %|{ foo: {} }|
+              plain " to eq "
+              red %|{ foo: nil }|
+              plain "."
+            end
+          },
+          diff: proc {
+            plain_line %|  {|
+            red_line   %|-   foo: nil|
+            green_line %|+   foo: {}|
+            plain_line %|  }|
+          }
+        )
+
+        expect(program).
+          to produce_output_when_run(expected_output).
+          in_color(color_enabled)
+      end
+    end
+  end
+
+  context "when comparing two data structures where one contains an empty object" do
+    it "formats the object correctly in the diff" do
+      as_both_colored_and_uncolored do |color_enabled|
+        snippet = <<~TEST.strip
+          expected = { foo: nil }
+          actual = { foo: SuperDiff::Test::EmptyClass.new }
+          expect(actual).to eq(expected)
+        TEST
+        program = make_plain_test_program(snippet, color_enabled: color_enabled)
+
+        expected_output = build_expected_output(
+          color_enabled: color_enabled,
+          snippet: %|expect(actual).to eq(expected)|,
+          newline_before_expectation: true,
+          expectation: proc {
+            line do
+              plain "Expected "
+              green %|{ foo: #<SuperDiff::Test::EmptyClass> }|
+              plain " to eq "
+              red %|{ foo: nil }|
+              plain "."
+            end
+          },
+          diff: proc {
+            plain_line %|  {|
+            red_line   %|-   foo: nil|
+            green_line %|+   foo: #<SuperDiff::Test::EmptyClass>|
+            plain_line %|  }|
+          }
+        )
+
+        expect(program).
+          to produce_output_when_run(expected_output).
+          in_color(color_enabled).
+          removing_object_ids
+      end
+    end
+  end
 end

spec/support/models/empty_class.rb

@@ -0,0 +1,6 @@
+module SuperDiff
+  module Test
+    class EmptyClass
+    end
+  end
+end