super_diff 0.6.2 → 0.9.0

data/lib/super_diff/operation_tree_flatteners.rb

@@ -0,0 +1,20 @@
+module SuperDiff
+  module OperationTreeFlatteners
+    autoload :Array, "super_diff/operation_tree_flatteners/array"
+    autoload :Base, "super_diff/operation_tree_flatteners/base"
+    autoload :Collection, "super_diff/operation_tree_flatteners/collection"
+    autoload(
+      :CustomObject,
+      "super_diff/operation_tree_flatteners/custom_object",
+    )
+    autoload(
+      :DefaultObject,
+      "super_diff/operation_tree_flatteners/default_object",
+    )
+    autoload :Hash, "super_diff/operation_tree_flatteners/hash"
+    autoload(
+      :MultilineString,
+      "super_diff/operation_tree_flatteners/multiline_string",
+    )
+  end
+end

data/lib/super_diff/operation_trees/array.rb

@@ -5,13 +5,10 @@ module SuperDiff
         value.is_a?(::Array)
       end
 
-      def to_diff(indent_level:, collection_prefix:, add_comma:)
-        DiffFormatters::Array.call(
-          self,
-          indent_level: indent_level,
-          collection_prefix: collection_prefix,
-          add_comma: add_comma,
-        )
+      protected
+
+      def operation_tree_flattener_class
+        OperationTreeFlatteners::Array
       end
     end
   end

data/lib/super_diff/operation_trees/base.rb

@@ -1,33 +1,56 @@
-require 'delegate'
+require "forwardable"
 
 module SuperDiff
   module OperationTrees
-    class Base < SimpleDelegator
-      def self.applies_to?(_value)
+    class Base
+      def self.applies_to?(*)
         unimplemented_class_method!
       end
 
+      include Enumerable
+      include ImplementationChecks
       extend ImplementationChecks
+      extend Forwardable
 
-      # rubocop:disable Lint/UnusedMethodArgument
-      def to_diff(indent_level:, add_comma: false, collection_prefix: nil)
-        raise NotImplementedError
+      def_delegators :operations, :<<, :delete, :each
+
+      def initialize(operations)
+        @operations = operations
+      end
+
+      def to_diff(indentation_level:)
+        TieredLinesFormatter.call(
+          perhaps_elide(flatten(indentation_level: indentation_level)),
+        )
+      end
+
+      def flatten(indentation_level:)
+        operation_tree_flattener_class.call(
+          self,
+          indentation_level: indentation_level,
+        )
       end
-      # rubocop:enable Lint/UnusedMethodArgument
 
       def pretty_print(pp)
-        pp.text "#{self.class.name}.new(["
-        pp.group_sub do
-          pp.nest(2) do
-            pp.breakable
-            pp.seplist(self) do |value|
-              pp.pp value
-            end
+        pp.group(1, "#<#{self.class.name} [", "]>") do
+          pp.breakable
+          pp.seplist(self) do |value|
+            pp.pp value
           end
         end
-        pp.breakable
-        pp.text("])")
       end
+
+      def perhaps_elide(tiered_lines)
+        if SuperDiff.configuration.diff_elision_enabled?
+          TieredLinesElider.call(tiered_lines)
+        else
+          tiered_lines
+        end
+      end
+
+      private
+
+      attr_reader :operations
     end
   end
 end

data/lib/super_diff/operation_trees/custom_object.rb

@@ -5,14 +5,10 @@ module SuperDiff
         value.respond_to?(:attributes_for_super_diff)
       end
 
-      def to_diff(indent_level:, add_comma: false, collection_prefix: nil)
-        DiffFormatters::CustomObject.call(
-          self,
-          indent_level: indent_level,
-          collection_prefix: collection_prefix,
-          add_comma: add_comma,
-          value_class: value_class,
-        )
+      protected
+
+      def operation_tree_flattener_class
+        OperationTreeFlatteners::CustomObject
       end
     end
   end

data/lib/super_diff/operation_trees/default_object.rb

@@ -1,26 +1,41 @@
 module SuperDiff
   module OperationTrees
     class DefaultObject < Base
-      def self.applies_to?(_value)
+      def self.applies_to?(*)
         true
       end
 
-      attr_reader :value_class
+      attr_reader :underlying_object
 
-      # TODO: Default this to collection.class?
-      def initialize(collection, value_class:)
-        super(collection)
+      def initialize(operations, underlying_object:)
+        super(operations)
+        @underlying_object = underlying_object
+      end
 
-        @value_class = value_class
+      def pretty_print(pp)
+        pp.text "#<#{self.class.name} "
+        pp.nest(1) do
+          pp.breakable
+          pp.text ":operations=>"
+          pp.group(1, "[", "]") do
+            pp.breakable
+            pp.seplist(self) do |value|
+              pp.pp value
+            end
+          end
+          pp.comma_breakable
+          pp.text ":underlying_object=>"
+          pp.object_address_group underlying_object do
+            # do nothing
+          end
+        end
+        pp.text ">"
       end
 
-      def to_diff(indent_level:, add_comma: false, **_rest)
-        DiffFormatters::Main.call(
-          self,
-          indent_level: indent_level,
-          add_comma: add_comma,
-          value_class: value_class,
-        )
+      protected
+
+      def operation_tree_flattener_class
+        OperationTreeFlatteners::DefaultObject
       end
     end
   end

data/lib/super_diff/operation_trees/hash.rb

@@ -5,13 +5,10 @@ module SuperDiff
         value.is_a?(::Hash)
       end
 
-      def to_diff(indent_level:, collection_prefix:, add_comma:)
-        DiffFormatters::Hash.call(
-          self,
-          indent_level: indent_level,
-          collection_prefix: collection_prefix,
-          add_comma: add_comma,
-        )
+      protected
+
+      def operation_tree_flattener_class
+        OperationTreeFlatteners::Hash
       end
     end
   end

data/lib/super_diff/operation_trees/main.rb

@@ -8,7 +8,7 @@ module SuperDiff
       def call
         if resolved_class
           begin
-            resolved_class.new([], value_class: value.class)
+            resolved_class.new([], underlying_object: value)
           rescue ArgumentError
             resolved_class.new([])
           end

data/lib/super_diff/operation_trees/multiline_string.rb

@@ -5,13 +5,10 @@ module SuperDiff
         value.is_a?(::String) && value.is_a?(::String)
       end
 
-      def to_diff(indent_level:, collection_prefix:, add_comma:)
-        DiffFormatters::MultilineString.call(
-          self,
-          indent_level: indent_level,
-          collection_prefix: collection_prefix,
-          add_comma: add_comma,
-        )
+      protected
+
+      def operation_tree_flattener_class
+        OperationTreeFlatteners::MultilineString
       end
     end
   end

data/lib/super_diff/operations/binary_operation.rb

@@ -14,14 +14,9 @@ module SuperDiff
           :right_value!,
           :left_index!,
           :right_index!,
-          child_operations: [],
+          children: [],
         ],
       )
-
-      def should_add_comma_after_displaying?
-        left_index < left_collection.size - 1 ||
-          right_index < right_collection.size - 1
-      end
     end
   end
 end

data/lib/super_diff/operations/unary_operation.rb

@@ -1,37 +1,9 @@
 module SuperDiff
   module Operations
     class UnaryOperation
-      attr_reader(
-        :name,
-        :collection,
-        :key,
-        :value,
-        # TODO: Is this even used??
-        :index,
-        :index_in_collection,
-      )
+      extend AttrExtras.mixin
 
-      def initialize(
-        name:,
-        collection:,
-        key:,
-        value:,
-        # TODO: Is this even used??
-        index:,
-        index_in_collection: index
-      )
-        @name = name
-        @collection = collection
-        @key = key
-        @value = value
-        # TODO: Is this even used??
-        @index = index
-        @index_in_collection = index_in_collection
-      end
-
-      def should_add_comma_after_displaying?
-        index_in_collection < collection.size - 1
-      end
+      rattr_initialize [:name!, :collection!, :key!, :value!, :index!]
     end
   end
 end

data/lib/super_diff/recursion_guard.rb

@@ -7,7 +7,7 @@ module SuperDiff
 
     def self.guarding_recursion_of(*objects, &block)
       already_seen_objects, first_seen_objects = objects.partition do |object|
-        already_seen_object_ids.include?(object.object_id)
+        !SuperDiff.primitive?(object) && already_seen?(object)
       end
 
       first_seen_objects.each do |object|
@@ -38,8 +38,8 @@ module SuperDiff
       end
     end
 
-    def self.already_seen_objects
-      already_seen_object_ids.map { |object_id| ObjectSpace._id2ref(object_id) }
+    def self.already_seen?(object)
+      already_seen_object_ids.include?(object.object_id)
     end
 
     def self.already_seen_object_ids

data/lib/super_diff/rspec/differs/collection_including.rb

@@ -3,8 +3,10 @@ module SuperDiff
     module Differs
       class CollectionIncluding < SuperDiff::Differs::Array
         def self.applies_to?(expected, actual)
-          SuperDiff::RSpec.a_collection_including_something?(expected) &&
-            actual.is_a?(::Array)
+          (
+            SuperDiff::RSpec.a_collection_including_something?(expected) ||
+            SuperDiff::RSpec.array_including_something?(expected)
+          ) && actual.is_a?(::Array)
         end
 
         private

data/lib/super_diff/rspec/differs/hash_including.rb

@@ -3,8 +3,10 @@ module SuperDiff
     module Differs
       class HashIncluding < SuperDiff::Differs::Hash
         def self.applies_to?(expected, actual)
-          SuperDiff::RSpec.a_hash_including_something?(expected) &&
-            actual.is_a?(::Hash)
+          (
+            SuperDiff::RSpec.a_hash_including_something?(expected) ||
+            SuperDiff::RSpec.hash_including_something?(expected)
+          ) && actual.is_a?(::Hash)
         end
 
         private

data/lib/super_diff/rspec/monkey_patches.rb

@@ -266,14 +266,14 @@ module RSpec
       SuperDiff.insert_singleton_overrides(self) do
         # Override to use our formatting algorithm
         def format(value)
-          SuperDiff.inspect_object(value, as_single_line: true)
+          SuperDiff.inspect_object(value, as_lines: false)
         end
       end
 
       SuperDiff.insert_overrides(self) do
         # Override to use our formatting algorithm
         def format(value)
-          SuperDiff.inspect_object(value, as_single_line: true)
+          SuperDiff.inspect_object(value, as_lines: false)
         end
       end
     end

data/lib/super_diff/rspec/object_inspection/{inspectors → inspection_tree_builders}/collection_containing_exactly.rb

@@ -1,24 +1,25 @@
 module SuperDiff
   module RSpec
     module ObjectInspection
-      module Inspectors
-        class CollectionContainingExactly < SuperDiff::ObjectInspection::Inspectors::Base
+      module InspectionTreeBuilders
+        class CollectionContainingExactly < SuperDiff::ObjectInspection::InspectionTreeBuilders::Base
           def self.applies_to?(value)
             SuperDiff::RSpec.a_collection_containing_exactly_something?(value)
           end
 
-          protected
-
-          def inspection_tree
+          def call
             SuperDiff::ObjectInspection::InspectionTree.new do
-              add_text "#<a collection containing exactly ("
+              as_lines_when_rendering_to_lines(collection_bookend: :open) do
+                add_text "#<a collection containing exactly ("
+              end
 
               nested do |aliased_matcher|
                 insert_array_inspection_of(aliased_matcher.expected)
               end
 
-              add_break
-              add_text ")>"
+              as_lines_when_rendering_to_lines(collection_bookend: :close) do
+                add_text ")>"
+              end
             end
           end
         end

data/lib/super_diff/rspec/object_inspection/inspection_tree_builders/collection_including.rb

@@ -0,0 +1,34 @@
+module SuperDiff
+  module RSpec
+    module ObjectInspection
+      module InspectionTreeBuilders
+        class CollectionIncluding < SuperDiff::ObjectInspection::InspectionTreeBuilders::Base
+          def self.applies_to?(value)
+            SuperDiff::RSpec.a_collection_including_something?(value) || SuperDiff::RSpec.array_including_something?(value)
+          end
+
+          def call
+            SuperDiff::ObjectInspection::InspectionTree.new do
+              as_lines_when_rendering_to_lines(collection_bookend: :open) do
+                add_text "#<a collection including ("
+              end
+
+              nested do |value|
+                array = if SuperDiff::RSpec.a_collection_including_something?(value)
+                          value.expecteds
+                        else
+                          value.instance_variable_get(:@expected)
+                        end
+                insert_array_inspection_of(array)
+              end
+
+              as_lines_when_rendering_to_lines(collection_bookend: :close) do
+                add_text ")>"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/rspec/object_inspection/inspection_tree_builders/double.rb

@@ -0,0 +1,103 @@
+module SuperDiff
+  module RSpec
+    module ObjectInspection
+      module InspectionTreeBuilders
+        class Double < SuperDiff::ObjectInspection::InspectionTreeBuilders::Base
+          def self.applies_to?(value)
+            value.is_a?(::RSpec::Mocks::Double)
+          end
+
+          def call
+            builder = self
+            empty = -> { empty? }
+            nonempty = -> { !empty? }
+
+            SuperDiff::ObjectInspection::InspectionTree.new do
+              only_when empty do
+                as_lines_when_rendering_to_lines do
+                  add_text do |object|
+                    inspected_class = builder.inspected_class
+                    inspected_name = builder.inspected_name
+                    "#<#{inspected_class} #{inspected_name}>"
+                  end
+                end
+              end
+
+              only_when nonempty do
+                as_lines_when_rendering_to_lines(collection_bookend: :open) do
+                  add_text do |object|
+                    inspected_class = builder.inspected_class
+                    inspected_name = builder.inspected_name
+                    "#<#{inspected_class} #{inspected_name}"
+                  end
+
+                  when_rendering_to_lines do
+                    add_text " {"
+                  end
+                end
+
+                when_rendering_to_string do
+                  add_text " "
+                end
+
+                nested do |object|
+                  insert_hash_inspection_of(builder.doubled_methods)
+                end
+
+                as_lines_when_rendering_to_lines(collection_bookend: :close) do
+                  when_rendering_to_lines do
+                    add_text "}"
+                  end
+
+                  add_text ">"
+                end
+              end
+            end
+          end
+
+          def empty?
+            doubled_methods.empty?
+          end
+
+          def nonempty?
+            !empty?
+          end
+
+          def inspected_class
+            case object
+            when ::RSpec::Mocks::InstanceVerifyingDouble
+              "InstanceDouble"
+            when ::RSpec::Mocks::ClassVerifyingDouble
+              "ClassDouble"
+            when ::RSpec::Mocks::ObjectVerifyingDouble
+              "ObjectDouble"
+            else
+              "Double"
+            end
+          end
+
+          def inspected_name
+            if object.instance_variable_get("@name")
+              object.instance_variable_get("@name").inspect
+            else
+              "(anonymous)"
+            end
+          end
+
+          def doubled_methods
+            @_doubled_methods ||= doubled_method_names.reduce({}) do |hash, key|
+              hash.merge(key => object.public_send(key))
+            end
+          end
+
+          def doubled_method_names
+            object.
+              __send__(:__mock_proxy).
+              instance_variable_get("@method_doubles").
+              keys
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/rspec/object_inspection/inspection_tree_builders/hash_including.rb

@@ -0,0 +1,36 @@
+module SuperDiff
+  module RSpec
+    module ObjectInspection
+      module InspectionTreeBuilders
+        class HashIncluding < SuperDiff::ObjectInspection::InspectionTreeBuilders::Base
+          def self.applies_to?(value)
+            SuperDiff::RSpec.a_hash_including_something?(value) || SuperDiff::RSpec.hash_including_something?(value)
+          end
+
+          def call
+            SuperDiff::ObjectInspection::InspectionTree.new do
+              as_lines_when_rendering_to_lines(collection_bookend: :open) do
+                add_text "#<a hash including ("
+              end
+
+              nested do |value|
+                hash =
+                  if SuperDiff::RSpec.a_hash_including_something?(value)
+                    value.expecteds.first
+                  else
+                    value.instance_variable_get(:@expected)
+                  end
+
+                insert_hash_inspection_of(hash)
+              end
+
+              as_lines_when_rendering_to_lines(collection_bookend: :close) do
+                add_text ")>"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/rspec/object_inspection/inspection_tree_builders/instance_of.rb

@@ -0,0 +1,26 @@
+module SuperDiff
+  module RSpec
+    module ObjectInspection
+      module InspectionTreeBuilders
+        class InstanceOf < SuperDiff::ObjectInspection::InspectionTreeBuilders::Base
+          def self.applies_to?(value)
+            SuperDiff::RSpec.an_instance_of_something?(value) || SuperDiff::RSpec.instance_of_something?(value)
+          end
+
+          def call
+            SuperDiff::ObjectInspection::InspectionTree.new do
+              add_text do |value|
+                klass = if SuperDiff::RSpec.an_instance_of_something?(value)
+                          value.expected
+                        else
+                          value.instance_variable_get(:@klass)
+                        end
+                "#<an instance of #{klass}>"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/rspec/object_inspection/inspection_tree_builders/kind_of.rb

@@ -0,0 +1,26 @@
+module SuperDiff
+  module RSpec
+    module ObjectInspection
+      module InspectionTreeBuilders
+        class KindOf < SuperDiff::ObjectInspection::InspectionTreeBuilders::Base
+          def self.applies_to?(value)
+            SuperDiff::RSpec.a_kind_of_something?(value) || SuperDiff::RSpec.kind_of_something?(value)
+          end
+
+          def call
+            SuperDiff::ObjectInspection::InspectionTree.new do
+              add_text do |value|
+                klass = if SuperDiff::RSpec.a_kind_of_something?(value)
+                          value.expected
+                        else
+                          value.instance_variable_get(:@klass)
+                        end
+                "#<a kind of #{klass}>"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/rspec/object_inspection/{inspectors → inspection_tree_builders}/object_having_attributes.rb

@@ -1,27 +1,25 @@
 module SuperDiff
   module RSpec
     module ObjectInspection
-      module Inspectors
-        class ObjectHavingAttributes < SuperDiff::ObjectInspection::Inspectors::Base
+      module InspectionTreeBuilders
+        class ObjectHavingAttributes < SuperDiff::ObjectInspection::InspectionTreeBuilders::Base
           def self.applies_to?(value)
             SuperDiff::RSpec.an_object_having_some_attributes?(value)
           end
 
-          protected
-
-          def inspection_tree
+          def call
             SuperDiff::ObjectInspection::InspectionTree.new do
-              add_text "#<an object having attributes ("
+              as_lines_when_rendering_to_lines(collection_bookend: :open) do
+                add_text "#<an object having attributes ("
+              end
 
               nested do |aliased_matcher|
-                insert_hash_inspection_of(
-                  aliased_matcher.expected,
-                  initial_break: nil,
-                )
+                insert_hash_inspection_of(aliased_matcher.expected)
               end
 
-              add_break
-              add_text ")>"
+              as_lines_when_rendering_to_lines(collection_bookend: :close) do
+                add_text ")>"
+              end
             end
           end
         end

data/lib/super_diff/rspec/object_inspection/inspection_tree_builders/primitive.rb

@@ -0,0 +1,10 @@
+module SuperDiff
+  module RSpec
+    module ObjectInspection
+      module InspectionTreeBuilders
+        class Primitive < SuperDiff::ObjectInspection::InspectionTreeBuilders::Primitive
+        end
+      end
+    end
+  end
+end