Fix diffing two different kinds of objects

When comparing two objects that do not share the same class, a diff is
being produced. This is really not very useful, so we hide it in that
case.

Author: mcmire

lib/super_diff/differs/custom_object.rb

@@ -2,7 +2,8 @@ module SuperDiff
   module Differs
     class CustomObject < Base
       def self.applies_to?(expected, actual)
-        expected.respond_to?(:attributes_for_super_diff) &&
+        expected.class == actual.class &&
+          expected.respond_to?(:attributes_for_super_diff) &&
           actual.respond_to?(:attributes_for_super_diff)
       end
 

lib/super_diff/differs/default_object.rb

@@ -1,8 +1,8 @@
 module SuperDiff
   module Differs
     class DefaultObject < Base
-      def self.applies_to?(_expected, _actual)
-        true
+      def self.applies_to?(expected, actual)
+        expected.class == actual.class
       end
 
       def call

lib/super_diff/equality_matcher.rb

@@ -24,10 +24,6 @@ def call
     private
 
     def resolved_class
-      matching_class || EqualityMatchers::Object
-    end
-
-    def matching_class
       (EqualityMatchers::DEFAULTS + extra_classes).find do |klass|
         klass.applies_to?(expected) && klass.applies_to?(actual)
       end

lib/super_diff/equality_matchers.rb

@@ -4,20 +4,20 @@ module EqualityMatchers
     autoload :Base, "super_diff/equality_matchers/base"
     autoload :Hash, "super_diff/equality_matchers/hash"
     autoload :MultilineString, "super_diff/equality_matchers/multiline_string"
-    autoload :Object, "super_diff/equality_matchers/object"
+    autoload :Default, "super_diff/equality_matchers/default"
     autoload :Primitive, "super_diff/equality_matchers/primitive"
     autoload(
       :SinglelineString,
       "super_diff/equality_matchers/singleline_string",
     )
 
     DEFAULTS = [
+      Primitive,
       Array,
       Hash,
       MultilineString,
       SinglelineString,
-      Object,
-      Primitive,
+      Default,
     ].freeze
   end
 end

lib/super_diff/equality_matchers/default.rb

@@ -0,0 +1,60 @@
+module SuperDiff
+  module EqualityMatchers
+    class Default < Base
+      def self.applies_to?(_value)
+        true
+      end
+
+      def fail
+        <<~OUTPUT.strip
+          Differing objects.
+
+          #{expected_line}
+          #{actual_line}
+          #{diff_section}
+        OUTPUT
+      end
+
+      protected
+
+      def expected_line
+        Helpers.style(
+          :deleted,
+          "Expected: " +
+          ObjectInspection.inspect(expected, as_single_line: true),
+        )
+      end
+
+      def actual_line
+        Helpers.style(
+          :inserted,
+          "  Actual: " +
+          ObjectInspection.inspect(actual, as_single_line: true),
+        )
+      end
+
+      def diff_section
+        if diff.blank?
+          ""
+        else
+          <<~SECTION
+
+            Diff:
+
+            #{diff}
+          SECTION
+        end
+      end
+
+      def diff
+        Differ.call(
+          expected,
+          actual,
+          indent_level: 0,
+          extra_operational_sequencer_classes: extra_operational_sequencer_classes,
+          extra_diff_formatter_classes: extra_diff_formatter_classes,
+        )
+      end
+    end
+  end
+end

lib/super_diff/equality_matchers/object.rb

@@ -2,7 +2,8 @@ module SuperDiff
   module OperationalSequencers
     class CustomObject < DefaultObject
       def self.applies_to?(expected, actual)
-        expected.respond_to?(:attributes_for_super_diff) &&
+        expected.class == actual.class &&
+          expected.respond_to?(:attributes_for_super_diff) &&
           actual.respond_to?(:attributes_for_super_diff)
       end
 

lib/super_diff/operational_sequencers/custom_object.rb

@@ -16,6 +16,7 @@ def diff
               Differs::CollectionContainingExactly,
               Differs::PartialArray,
               Differs::PartialHash,
+              Differs::PartialObject,
             ],
             extra_operational_sequencer_classes: [
               *RSpec.configuration.extra_operational_sequencer_classes,

lib/super_diff/rspec/differ.rb

@@ -7,7 +7,7 @@ module Differs
       )
       autoload :PartialArray, "super_diff/rspec/differs/partial_array"
       autoload :PartialHash, "super_diff/rspec/differs/partial_hash"
-      # autoload :PartialObject, "super_diff/rspec/differs/partial_object"
+      autoload :PartialObject, "super_diff/rspec/differs/partial_object"
     end
   end
 end

lib/super_diff/rspec/differs.rb

@@ -377,6 +377,84 @@
         expect(program).to produce_output_when_run(expected_output)
       end
     end
+
+    context "when comparing two different kinds of custom objects" do
+      it "produces the correct output" do
+        program = make_plain_test_program(<<~TEST.strip)
+          expected = SuperDiff::Test::Person.new(
+            name: "Marty",
+            age: 31,
+          )
+          actual = SuperDiff::Test::Customer.new(
+            name: "Doc",
+            shipping_address: :some_shipping_address,
+            phone: "1234567890",
+          )
+          expect(actual).to eq(expected)
+        TEST
+
+        expected_output = build_expected_output(
+          snippet: %|expect(actual).to eq(expected)|,
+          newline_before_expectation: true,
+          expectation: proc {
+            line do
+              plain "Expected "
+              green %|#<SuperDiff::Test::Customer name: "Doc", shipping_address: :some_shipping_address, phone: "1234567890">|
+            end
+
+            line do
+              plain "   to eq "
+              red %|#<SuperDiff::Test::Person name: "Marty", age: 31>|
+            end
+          },
+        )
+
+        expect(program).to produce_output_when_run(expected_output)
+      end
+    end
+
+    context "when comparing two different kinds of non-custom objects" do
+      it "produces the correct output" do
+        program = make_plain_test_program(<<~TEST.strip)
+          expected = SuperDiff::Test::Item.new(
+            name: "camera",
+            quantity: 3,
+          )
+          actual = SuperDiff::Test::Player.new(
+            handle: "mcmire",
+            character: "Jon",
+            inventory: ["sword"],
+            shields: 11.4,
+            health: 4,
+            ultimate: true,
+          )
+          expect(actual).to eq(expected)
+        TEST
+
+        expected_output = build_expected_output(
+          snippet: %|expect(actual).to eq(expected)|,
+          newline_before_expectation: true,
+          expectation: proc {
+            if SuperDiff::Test.jruby?
+            else
+              line do
+                plain "Expected "
+                green %|#<SuperDiff::Test::Player @handle="mcmire", @character="Jon", @inventory=["sword"], @shields=11.4, @health=4, @ultimate=true>|
+              end
+
+              line do
+                plain "   to eq "
+                red %|#<SuperDiff::Test::Item @name="camera", @quantity=3>|
+              end
+            end
+          },
+        )
+
+        expect(program).
+          to produce_output_when_run(expected_output).
+          first_replacing(/#<([\w:]+):0x[a-z0-9]+ /, '#<\1 ')
+      end
+    end
   end
 
   describe "the #include matcher" do