super_diff 0.5.3 → 0.8.0

data/lib/super_diff/operation_tree_flatteners/custom_object.rb

@@ -0,0 +1,28 @@
+module SuperDiff
+  module OperationTreeFlatteners
+    class CustomObject < Collection
+      protected
+
+      def open_token
+        "#<%<class>s {" % { class: operation_tree.underlying_object.class }
+      end
+
+      def close_token
+        "}>"
+      end
+
+      def item_prefix_for(operation)
+        key =
+          # Note: We could have used the right_key here too, they're both the
+          # same keys
+          if operation.respond_to?(:left_key)
+            operation.left_key
+          else
+            operation.key
+          end
+
+        "#{key}: "
+      end
+    end
+  end
+end

data/lib/super_diff/operation_tree_flatteners/default_object.rb

@@ -0,0 +1,32 @@
+module SuperDiff
+  module OperationTreeFlatteners
+    class DefaultObject < Collection
+      protected
+
+      def open_token
+        "#<#{operation_tree.underlying_object.class.name}:" +
+          SuperDiff::Helpers.object_address_for(
+            operation_tree.underlying_object
+          ) +
+          " {"
+      end
+
+      def close_token
+        "}>"
+      end
+
+      def item_prefix_for(operation)
+        key =
+          # Note: We could have used the right_key here too, they're both the
+          # same keys
+          if operation.respond_to?(:left_key)
+            operation.left_key
+          else
+            operation.key
+          end
+
+        "@#{key}="
+      end
+    end
+  end
+end

data/lib/super_diff/operation_tree_flatteners/hash.rb

@@ -0,0 +1,41 @@
+module SuperDiff
+  module OperationTreeFlatteners
+    class Hash < Collection
+      protected
+
+      def open_token
+        "{"
+      end
+
+      def close_token
+        "}"
+      end
+
+      def item_prefix_for(operation)
+        key = key_for(operation)
+
+        if format_keys_as_kwargs?
+          "#{key}: "
+        else
+          "#{key.inspect} => "
+        end
+      end
+
+      private
+
+      def format_keys_as_kwargs?
+        operation_tree.all? { |operation| key_for(operation).is_a?(Symbol) }
+      end
+
+      def key_for(operation)
+        # Note: We could have used the right_key here too, they're both the
+        # same keys
+        if operation.respond_to?(:left_key)
+          operation.left_key
+        else
+          operation.key
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/operation_tree_flatteners/multiline_string.rb

@@ -0,0 +1,17 @@
+module SuperDiff
+  module OperationTreeFlatteners
+    class MultilineString < Base
+      def build_tiered_lines
+        operation_tree.map do |operation|
+          Line.new(
+            type: operation.name,
+            indentation_level: indentation_level,
+            # TODO: Test that quotes and things don't get escaped but escape
+            # characters do
+            value: operation.value.inspect[1..-2].gsub(/\\"/, '"').gsub(/\\'/, "'")
+          )
+        end
+      end
+    end
+  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.rb

@@ -11,8 +11,8 @@ module SuperDiff
     autoload :ObjectInspection, "super_diff/rspec/object_inspection"
     autoload :OperationTreeBuilders, "super_diff/rspec/operation_tree_builders"
 
-    def self.configure
-      yield configuration
+    def self.configure(&block)
+      SuperDiff.configure(&block)
     end
 
     def self.configuration
@@ -26,12 +26,22 @@ module SuperDiff
         value.expecteds.first.is_a?(::Hash)
     end
 
+    # HINT: `a_hash_including` is an alias of `include` in the rspec-expectations gem.
+    #       `hash_including` is an argument matcher in the rspec-mocks gem.
+    def self.hash_including_something?(value)
+      value.is_a?(::RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher)
+    end
+
     def self.a_collection_including_something?(value)
       fuzzy_object?(value) &&
         value.respond_to?(:expecteds) &&
         !(value.expecteds.one? && value.expecteds.first.is_a?(::Hash))
     end
 
+    def self.array_including_something?(value)
+      value.is_a?(::RSpec::Mocks::ArgumentMatchers::ArrayIncludingMatcher)
+    end
+
     def self.an_object_having_some_attributes?(value)
       fuzzy_object?(value) &&
         value.base_matcher.is_a?(::RSpec::Matchers::BuiltIn::HaveAttributes)
@@ -47,11 +57,23 @@ module SuperDiff
         value.base_matcher.is_a?(::RSpec::Matchers::BuiltIn::BeAKindOf)
     end
 
+    # HINT: `a_kind_of` is a matcher in the rspec-expectations gem.
+    #       `kind_of` is an argument matcher in the rspec-mocks gem.
+    def self.kind_of_something?(value)
+      value.is_a?(::RSpec::Mocks::ArgumentMatchers::KindOf)
+    end
+
     def self.an_instance_of_something?(value)
       fuzzy_object?(value) &&
         value.base_matcher.is_a?(::RSpec::Matchers::BuiltIn::BeAnInstanceOf)
     end
 
+    # HINT: `an_instance_of` is a matcher in the rspec-expectations gem.
+    #       `instance_of` is an argument matcher in the rspec-mocks gem.
+    def self.instance_of_something?(value)
+      value.is_a?(::RSpec::Mocks::ArgumentMatchers::InstanceOf)
+    end
+
     def self.a_value_within_something?(value)
       fuzzy_object?(value) &&
         value.base_matcher.is_a?(::RSpec::Matchers::BuiltIn::BeWithin)
@@ -61,6 +83,13 @@ module SuperDiff
       value.is_a?(::RSpec::Matchers::AliasedMatcher)
     end
 
+    def self.rspec_version
+      @_rspec_version ||= begin
+        require "rspec/core/version"
+        GemVersion.new(::RSpec::Core::Version::STRING)
+      end
+    end
+
     SuperDiff.configuration.tap do |config|
       config.add_extra_differ_classes(
         Differs::CollectionContainingExactly,
@@ -76,20 +105,19 @@ module SuperDiff
         OperationTreeBuilders::ObjectHavingAttributes,
       )
 
-      config.add_extra_inspector_classes(
-        ObjectInspection::Inspectors::CollectionContainingExactly,
-        ObjectInspection::Inspectors::CollectionIncluding,
-        ObjectInspection::Inspectors::HashIncluding,
-        ObjectInspection::Inspectors::InstanceOf,
-        ObjectInspection::Inspectors::KindOf,
-        ObjectInspection::Inspectors::ObjectHavingAttributes,
-        ObjectInspection::Inspectors::Primitive,
-        ObjectInspection::Inspectors::ValueWithin,
+      config.add_extra_inspection_tree_builder_classes(
+        ObjectInspection::InspectionTreeBuilders::Double,
+        ObjectInspection::InspectionTreeBuilders::CollectionContainingExactly,
+        ObjectInspection::InspectionTreeBuilders::CollectionIncluding,
+        ObjectInspection::InspectionTreeBuilders::HashIncluding,
+        ObjectInspection::InspectionTreeBuilders::InstanceOf,
+        ObjectInspection::InspectionTreeBuilders::KindOf,
+        ObjectInspection::InspectionTreeBuilders::ObjectHavingAttributes,
+        # ObjectInspection::InspectionTreeBuilders::Primitive,
+        ObjectInspection::InspectionTreeBuilders::ValueWithin,
       )
     end
   end
 end
 
 require_relative "rspec/monkey_patches"
-
-SuperDiff::Csi.color_enabled = ::RSpec.configuration.color_enabled?