super_diff 0.1.0 → 0.2.0

data/lib/super_diff/operational_sequencers/{multi_line_string.rb → multiline_string.rb}

@@ -1,8 +1,9 @@
 module SuperDiff
   module OperationalSequencers
-    class MultiLineString < Base
-      def self.applies_to?(value)
-        value.is_a?(::String) && value.include?("\n")
+    class MultilineString < Base
+      def self.applies_to?(expected, actual)
+        expected.is_a?(::String) && actual.is_a?(::String) &&
+          (expected.include?("\n") || actual.include?("\n"))
       end
 
       def initialize(*args)
@@ -29,8 +30,8 @@ module SuperDiff
         end
       end
 
-      def operation_sequence_class
-        OperationSequences::Array
+      def build_operation_sequencer
+        OperationSequences::Array.new([])
       end
 
       private
@@ -38,7 +39,11 @@ module SuperDiff
       attr_reader :sequence_matcher, :original_expected, :original_actual
 
       def split_into_lines(str)
-        str.split(/(\n)/).map { |v| v.tr("\n", "⏎") }.each_slice(2).map(&:join)
+        str.
+          split(/(\r?\n)/).
+          each_slice(2).
+          map(&:join).
+          map { |line| line.inspect[1..-2] }
       end
 
       def opcodes

data/lib/super_diff/operations.rb

@@ -0,0 +1,6 @@
+module SuperDiff
+  module Operations
+    autoload :BinaryOperation, "super_diff/operations/binary_operation"
+    autoload :UnaryOperation, "super_diff/operations/unary_operation"
+  end
+end

data/lib/super_diff/operations/binary_operation.rb

@@ -1,42 +1,22 @@
 module SuperDiff
   module Operations
     class BinaryOperation
-      attr_reader(
-        :name,
-        :left_collection,
-        :right_collection,
-        :left_key,
-        :right_key,
-        :left_value,
-        :right_value,
-        :left_index,
-        :right_index,
-        :child_operations,
-      )
+      extend AttrExtras.mixin
 
-      def initialize(
-        name:,
-        left_collection:,
-        right_collection:,
-        left_index:,
-        right_index:,
-        left_key:,
-        right_key:,
-        left_value:,
-        right_value:,
-        child_operations: []
+      rattr_initialize(
+        [
+          :name!,
+          :left_collection!,
+          :right_collection!,
+          :left_key!,
+          :right_key!,
+          :left_value!,
+          :right_value!,
+          :left_index!,
+          :right_index!,
+          child_operations: [],
+        ],
       )
-        @name = name
-        @left_collection = left_collection
-        @right_collection = right_collection
-        @left_index = left_index
-        @right_index = right_index
-        @left_key = left_key
-        @right_key = right_key
-        @left_value = left_value
-        @right_value = right_value
-        @child_operations = child_operations
-      end
 
       def should_add_comma_after_displaying?
         left_index < left_collection.size - 1 ||

data/lib/super_diff/operations/unary_operation.rb

@@ -7,18 +7,27 @@ module SuperDiff
         :key,
         :value,
         :index,
+        :index_in_collection,
       )
 
-      def initialize(name:, collection:, key:, value:, index:)
+      def initialize(
+        name:,
+        collection:,
+        key:,
+        value:,
+        index:,
+        index_in_collection: index
+      )
         @name = name
         @collection = collection
         @key = key
         @value = value
         @index = index
+        @index_in_collection = index_in_collection
       end
 
       def should_add_comma_after_displaying?
-        index < collection.size - 1
+        index_in_collection < collection.size - 1
       end
     end
   end

data/lib/super_diff/rails.rb

@@ -0,0 +1 @@
+require "super_diff/active_record"

data/lib/super_diff/recursion_guard.rb

@@ -0,0 +1,47 @@
+module SuperDiff
+  module RecursionGuard
+    RECURSION_GUARD_KEY = "super_diff_recursion_guard_key".freeze
+    PLACEHOLDER = "∙∙∙".freeze
+
+    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)
+      end
+
+      first_seen_objects.each do |object|
+        already_seen_object_ids.add(object.object_id)
+      end
+
+      result =
+        if block.arity > 0
+          block.call(already_seen_objects.any?)
+        else
+          block.call
+        end
+
+      first_seen_objects.each do |object|
+        already_seen_object_ids.delete(object.object_id)
+      end
+
+      result
+    end
+
+    def self.substituting_recursion_of(*objects)
+      guarding_recursion_of(*objects) do |already_seen|
+        if already_seen
+          PLACEHOLDER
+        else
+          yield
+        end
+      end
+    end
+
+    def self.already_seen_objects
+      already_seen_object_ids.map { |object_id| ObjectSpace._id2ref(object_id) }
+    end
+
+    def self.already_seen_object_ids
+      Thread.current[RECURSION_GUARD_KEY] ||= Set.new
+    end
+  end
+end

data/lib/super_diff/rspec-rails.rb

@@ -0,0 +1,2 @@
+require "super_diff/rspec"
+require "super_diff/rails"

data/lib/super_diff/rspec.rb

@@ -1,19 +1,63 @@
-require_relative "../super_diff"
-require_relative "rspec/differ"
-require_relative "rspec/monkey_patches"
+require "super_diff"
 
 module SuperDiff
   module RSpec
+    autoload :AugmentedMatcher, "super_diff/rspec/augmented_matcher"
+    autoload :Configuration, "super_diff/rspec/configuration"
+    autoload :Differ, "super_diff/rspec/differ"
+    autoload :Differs, "super_diff/rspec/differs"
+    autoload :MatcherTextBuilders, "super_diff/rspec/matcher_text_builders"
+    autoload :MatcherTextTemplate, "super_diff/rspec/matcher_text_template"
+    autoload :ObjectInspection, "super_diff/rspec/object_inspection"
+    autoload :OperationalSequencers, "super_diff/rspec/operational_sequencers"
+
     class << self
+      attr_accessor :extra_differ_classes
       attr_accessor :extra_operational_sequencer_classes
       attr_accessor :extra_diff_formatter_classes
+    end
+
+    def self.configure
+      yield configuration
+    end
+
+    def self.configuration
+      @_configuration ||= Configuration.new
+    end
+
+    def self.partial_hash?(value)
+      partial_placeholder?(value) &&
+        value.respond_to?(:expecteds) &&
+        value.expecteds.one? &&
+        value.expecteds.first.is_a?(::Hash)
+    end
 
-      def configure
-        yield self
-      end
+    def self.partial_array?(value)
+      partial_placeholder?(value) &&
+        value.respond_to?(:expecteds) &&
+        !(value.expecteds.one? && value.expecteds.first.is_a?(::Hash))
     end
 
-    self.extra_operational_sequencer_classes = []
-    self.extra_diff_formatter_classes = []
+    def self.partial_object?(value)
+      partial_placeholder?(value) &&
+        value.base_matcher.is_a?(::RSpec::Matchers::BuiltIn::HaveAttributes)
+    end
+
+    def self.collection_containing_exactly?(value)
+      partial_placeholder?(value) &&
+        value.base_matcher.is_a?(::RSpec::Matchers::BuiltIn::ContainExactly)
+    end
+
+    def self.partial_placeholder?(value)
+      value.is_a?(::RSpec::Matchers::AliasedMatcher)
+    end
   end
 end
+
+require_relative "rspec/monkey_patches"
+
+SuperDiff::ObjectInspection.map.prepend(
+  SuperDiff::RSpec::ObjectInspection::MapExtension,
+)
+
+SuperDiff::Csi.color_enabled = RSpec.configuration.color_enabled?

data/lib/super_diff/rspec/augmented_matcher.rb

@@ -0,0 +1,98 @@
+module SuperDiff
+  module RSpec
+    module AugmentedMatcher
+      # Update to use expected_for_description instead of @expected
+      # TODO: Test
+      def description
+        matcher_text_builder.matcher_description
+      end
+
+      # Colorize the 'actual' value
+      def failure_message
+        build_failure_message(negated: false)
+      end
+
+      # Colorize the 'actual' value
+      def failure_message_when_negated
+        build_failure_message(negated: true)
+      end
+
+      # Always be diffable (we have the logic of whether to show a diff or not
+      # in SuperDiff::RSpec::Differ)
+      def diffable?
+        true
+      end
+
+      protected
+
+      def build_failure_message(negated:)
+        matcher_text_builder.call(negated: negated)
+      end
+
+      def matcher_text_builder
+        @_matcher_text_builder ||=
+          matcher_text_builder_class.new(matcher_text_builder_args)
+      end
+
+      def matcher_text_builder_class
+        RSpec::MatcherTextBuilders::Base
+      end
+
+      def matcher_text_builder_args
+        {
+          actual: actual_for_matcher_text,
+          expected_for_failure_message: expected_for_failure_message,
+          expected_for_description: expected_for_description,
+          expected_action_for_failure_message: expected_action_for_failure_message,
+          expected_action_for_description: expected_action_for_description,
+        }
+      end
+
+      def actual_for_matcher_text
+        description_of(actual)
+      end
+
+      def expected_for_matcher_text
+        description_of(expected)
+      end
+
+      def expected_for_failure_message
+        expected_for_matcher_text
+      end
+
+      def expected_for_description
+        expected_for_matcher_text
+      end
+
+      private
+
+      def expected_action_for_matcher_text
+        ::RSpec::Matchers::EnglishPhrasing.split_words(self.class.matcher_name)
+      end
+
+      def expected_action_for_failure_message
+        expected_action_for_matcher_text
+      end
+
+      def expected_action_for_description
+        expected_action_for_matcher_text
+      end
+
+      def readable_list_of(things)
+        ::RSpec::Matchers::EnglishPhrasing.list(things)
+      end
+
+      def matchers
+        Object.new.tap do |object|
+          object.singleton_class.class_eval do
+            include ::RSpec::Matchers
+          end
+        end
+      end
+
+      def colorizer
+        ::RSpec::Core::Formatters::ConsoleCodes
+      end
+    end
+  end
+end

data/lib/super_diff/rspec/configuration.rb

@@ -0,0 +1,31 @@
+module SuperDiff
+  module RSpec
+    class Configuration
+      attr_reader(
+        :extra_differ_classes,
+        :extra_operational_sequencer_classes,
+        :extra_diff_formatter_classes,
+      )
+
+      def initialize
+        @extra_differ_classes = [].freeze
+        @extra_operational_sequencer_classes = [].freeze
+        @extra_diff_formatter_classes = [].freeze
+      end
+
+      def add_extra_differ_class(klass)
+        @extra_differ_classes = (@extra_differ_classes + [klass]).freeze
+      end
+
+      def add_extra_operational_sequencer_class(klass)
+        @extra_operational_sequencer_classes =
+          (@extra_operational_sequencer_classes + [klass]).freeze
+      end
+
+      def add_extra_diff_formatter_class(klass)
+        @extra_diff_formatter_classes =
+          (@extra_diff_formatter_classes + [klass]).freeze
+      end
+    end
+  end
+end

data/lib/super_diff/rspec/differ.rb

@@ -1,29 +1,73 @@
 module SuperDiff
   module RSpec
-    module Differ
-      def self.diff(actual, expected)
-        if (
-          expected != actual &&
-          expected.class == actual.class &&
-          !expected.is_a?(Symbol) &&
-          !expected.is_a?(Integer) &&
-          !(
-            expected.is_a?(String) &&
-            actual.is_a?(String) &&
-            !expected.include?("\n") &&
-            !actual.include?("\n")
-          )
-        )
+    class Differ
+      extend AttrExtras.mixin
+
+      static_facade :diff, :actual, :expected
+
+      def diff
+        if worth_diffing?
           diff = SuperDiff::Differ.call(
             expected,
             actual,
-            extra_operational_sequencer_classes: RSpec.extra_operational_sequencer_classes,
-            extra_diff_formatter_classes: RSpec.extra_diff_formatter_classes,
+            omit_empty: true,
+            extra_classes: [
+              *RSpec.configuration.extra_differ_classes,
+              Differs::CollectionContainingExactly,
+              Differs::PartialArray,
+              Differs::PartialHash,
+              Differs::PartialObject,
+            ],
+            extra_operational_sequencer_classes: [
+              *RSpec.configuration.extra_operational_sequencer_classes,
+              OperationalSequencers::CollectionContainingExactly,
+              OperationalSequencers::PartialArray,
+              OperationalSequencers::PartialHash,
+              OperationalSequencers::PartialObject,
+            ],
+            extra_diff_formatter_classes: RSpec.configuration.extra_diff_formatter_classes,
           )
           "\n\n" + diff
         else
           ""
         end
+      rescue NoDifferAvailableError
+        ""
+      end
+
+      private
+
+      def worth_diffing?
+        comparing_inequal_values? &&
+          !comparing_primitive_values? &&
+          !comparing_singleline_strings?
+      end
+
+      def comparing_inequal_values?
+        !helpers.values_match?(expected, actual)
+      end
+
+      def comparing_primitive_values?
+        expected.is_a?(Symbol) ||
+          expected.is_a?(Integer) ||
+          [true, false, nil].include?(expected)
+      end
+
+      def comparing_singleline_strings?
+        expected.is_a?(String) &&
+          actual.is_a?(String) &&
+          !expected.include?("\n") &&
+          !actual.include?("\n")
+      end
+
+      def helpers
+        @_helpers ||= Helpers.new
+      end
+
+      class Helpers
+        include ::RSpec::Matchers::Composable
+
+        public :values_match?
       end
     end
   end