super_diff 0.3.0 → 0.5.1

data/lib/super_diff/object_inspection/inspectors/defaults.rb

@@ -0,0 +1,15 @@
+module SuperDiff
+  module ObjectInspection
+    module Inspectors
+      DEFAULTS = [
+        CustomObject,
+        Array,
+        Hash,
+        Primitive,
+        String,
+        TimeLike,
+        DefaultObject,
+      ].freeze
+    end
+  end
+end

data/lib/super_diff/object_inspection/inspectors/hash.rb

@@ -1,20 +1,30 @@
 module SuperDiff
   module ObjectInspection
     module Inspectors
-      Hash = InspectionTree.new do
-        when_empty do
-          add_text "{}"
+      class Hash < Base
+        def self.applies_to?(value)
+          value.is_a?(::Hash)
         end
 
-        when_non_empty do
-          add_text "{"
+        protected
 
-          nested do |hash|
-            insert_hash_inspection_of(hash)
-          end
+        def inspection_tree
+          InspectionTree.new do
+            when_empty do
+              add_text "{}"
+            end
+
+            when_non_empty do
+              add_text "{"
 
-          add_break " "
-          add_text "}"
+              nested do |hash|
+                insert_hash_inspection_of(hash)
+              end
+
+              add_break " "
+              add_text "}"
+            end
+          end
         end
       end
     end

data/lib/super_diff/object_inspection/inspectors/main.rb

@@ -0,0 +1,35 @@
+module SuperDiff
+  module ObjectInspection
+    module Inspectors
+      class Main
+        extend AttrExtras.mixin
+
+        method_object :object, [:as_single_line!, :indent_level!]
+
+        def call
+          if resolved_class
+            resolved_class.call(
+              object,
+              as_single_line: as_single_line?,
+              indent_level: indent_level,
+            )
+          else
+            raise NoInspectorAvailableError.create(object)
+          end
+        end
+
+        private
+
+        attr_query :as_single_line?
+
+        def resolved_class
+          available_classes.find { |klass| klass.applies_to?(object) }
+        end
+
+        def available_classes
+          SuperDiff.configuration.extra_inspector_classes + DEFAULTS
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/object_inspection/inspectors/primitive.rb

@@ -1,12 +1,27 @@
 module SuperDiff
   module ObjectInspection
     module Inspectors
-      Primitive = InspectionTree.new do
-        # rubocop:disable Style/SymbolProc
-        add_text do |object|
-          object.inspect
+      class Primitive < Base
+        def self.applies_to?(value)
+          case value
+          when true, false, nil, Symbol, Numeric, Regexp, Class
+            true
+          else
+            false
+          end
+        end
+
+        protected
+
+        def inspection_tree
+          InspectionTree.new do
+            # rubocop:disable Style/SymbolProc
+            add_text do |object|
+              object.inspect
+            end
+            # rubocop:enable Style/SymbolProc
+          end
         end
-        # rubocop:enable Style/SymbolProc
       end
     end
   end

data/lib/super_diff/object_inspection/inspectors/string.rb

@@ -1,12 +1,22 @@
 module SuperDiff
   module ObjectInspection
     module Inspectors
-      String = InspectionTree.new do
-        # rubocop:disable Style/SymbolProc
-        add_text do |string|
-          string.inspect
+      class String < Base
+        def self.applies_to?(value)
+          value.is_a?(::String)
+        end
+
+        protected
+
+        def inspection_tree
+          InspectionTree.new do
+            # rubocop:disable Style/SymbolProc
+            add_text do |string|
+              string.inspect
+            end
+            # rubocop:enable Style/SymbolProc
+          end
         end
-        # rubocop:enable Style/SymbolProc
       end
     end
   end

data/lib/super_diff/object_inspection/inspectors/time_like.rb

@@ -0,0 +1,23 @@
+module SuperDiff
+  module ObjectInspection
+    module Inspectors
+      class TimeLike < Base
+        def self.applies_to?(value)
+          SuperDiff.time_like?(value)
+        end
+
+        TIME_FORMAT = "%Y-%m-%d %H:%M:%S.%3N %Z %:z".freeze
+
+        protected
+
+        def inspection_tree
+          InspectionTree.new do
+            add_text do |time|
+              "#{time.strftime(TIME_FORMAT)} (#{time.class})"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/object_inspection/nodes/inspection.rb

@@ -2,9 +2,16 @@ module SuperDiff
   module ObjectInspection
     module Nodes
       class Inspection < Base
-        def evaluate(_object, indent_level:, as_single_line:)
+        def evaluate(object, indent_level:, as_single_line:)
+          value =
+            if block
+              tree.evaluate_block(object, &block)
+            else
+              immediate_value
+            end
+
           SuperDiff::ObjectInspection.inspect(
-            immediate_value,
+            value,
             indent_level: indent_level,
             as_single_line: as_single_line,
           )

data/lib/super_diff/operation_tree_builders.rb

@@ -0,0 +1,18 @@
+module SuperDiff
+  module OperationTreeBuilders
+    autoload :Array, "super_diff/operation_tree_builders/array"
+    autoload :Base, "super_diff/operation_tree_builders/base"
+    autoload :CustomObject, "super_diff/operation_tree_builders/custom_object"
+    autoload :DefaultObject, "super_diff/operation_tree_builders/default_object"
+    autoload :Hash, "super_diff/operation_tree_builders/hash"
+    autoload :Main, "super_diff/operation_tree_builders/main"
+    # TODO: Where is this used?
+    autoload(
+      :MultilineString,
+      "super_diff/operation_tree_builders/multiline_string",
+    )
+    autoload :TimeLike, "super_diff/operation_tree_builders/time_like"
+  end
+end
+
+require "super_diff/operation_tree_builders/defaults"

data/lib/super_diff/{operational_sequencers → operation_tree_builders}/array.rb

@@ -1,5 +1,5 @@
 module SuperDiff
-  module OperationalSequencers
+  module OperationTreeBuilders
     class Array < Base
       def self.applies_to?(expected, actual)
         expected.is_a?(::Array) && actual.is_a?(::Array)
@@ -7,72 +7,40 @@ module SuperDiff
 
       def call
         Diff::LCS.traverse_balanced(expected, actual, lcs_callbacks)
-        operations
+        operation_tree
       end
 
       private
 
       def lcs_callbacks
         @_lcs_callbacks ||= LcsCallbacks.new(
-          operations: operations,
+          operation_tree: operation_tree,
           expected: expected,
           actual: actual,
-          extra_operational_sequencer_classes: extra_operational_sequencer_classes,
-          extra_diff_formatter_classes: extra_diff_formatter_classes,
           sequence: method(:sequence),
         )
       end
 
-      def operations
-        @_operations ||= OperationSequences::Array.new([])
+      def operation_tree
+        @_operation_tree ||= OperationTrees::Array.new([])
       end
 
       class LcsCallbacks
         extend AttrExtras.mixin
 
-        pattr_initialize(
-          [
-            :operations!,
-            :expected!,
-            :actual!,
-            :extra_operational_sequencer_classes!,
-            :extra_diff_formatter_classes!,
-            :sequence!
-          ],
-        )
-        public :operations
+        pattr_initialize [:operation_tree!, :expected!, :actual!, :sequence!]
+        public :operation_tree
 
         def match(event)
-          operations << ::SuperDiff::Operations::UnaryOperation.new(
-            name: :noop,
-            collection: actual,
-            key: event.new_position,
-            value: event.new_element,
-            index: event.new_position,
-            index_in_collection: actual.index(event.new_element),
-          )
+          add_noop_operation(event)
         end
 
         def discard_a(event)
-          operations << ::SuperDiff::Operations::UnaryOperation.new(
-            name: :delete,
-            collection: expected,
-            key: event.old_position,
-            value: event.old_element,
-            index: event.old_position,
-            index_in_collection: expected.index(event.old_element),
-          )
+          add_delete_operation(event)
         end
 
         def discard_b(event)
-          operations << ::SuperDiff::Operations::UnaryOperation.new(
-            name: :insert,
-            collection: actual,
-            key: event.new_position,
-            value: event.new_element,
-            index: event.new_position,
-            index_in_collection: actual.index(event.new_element),
-          )
+          add_insert_operation(event)
         end
 
         def change(event)
@@ -88,23 +56,8 @@ module SuperDiff
 
         private
 
-        def add_change_operation(event, child_operations)
-          operations << ::SuperDiff::Operations::BinaryOperation.new(
-            name: :change,
-            left_collection: expected,
-            right_collection: actual,
-            left_key: event.old_position,
-            right_key: event.new_position,
-            left_value: event.old_element,
-            right_value: event.new_element,
-            left_index: event.old_position,
-            right_index: event.new_position,
-            child_operations: child_operations,
-          )
-        end
-
         def add_delete_operation(event)
-          operations << Operations::UnaryOperation.new(
+          operation_tree << Operations::UnaryOperation.new(
             name: :delete,
             collection: expected,
             key: event.old_position,
@@ -115,7 +68,7 @@ module SuperDiff
         end
 
         def add_insert_operation(event)
-          operations << Operations::UnaryOperation.new(
+          operation_tree << Operations::UnaryOperation.new(
             name: :insert,
             collection: actual,
             key: event.new_position,
@@ -124,6 +77,32 @@ module SuperDiff
             index_in_collection: actual.index(event.new_element),
           )
         end
+
+        def add_noop_operation(event)
+          operation_tree << Operations::UnaryOperation.new(
+            name: :noop,
+            collection: actual,
+            key: event.new_position,
+            value: event.new_element,
+            index: event.new_position,
+            index_in_collection: actual.index(event.new_element),
+          )
+        end
+
+        def add_change_operation(event, child_operations)
+          operation_tree << Operations::BinaryOperation.new(
+            name: :change,
+            left_collection: expected,
+            right_collection: actual,
+            left_key: event.old_position,
+            right_key: event.new_position,
+            left_value: event.old_element,
+            right_value: event.new_element,
+            left_index: event.old_position,
+            right_index: event.new_position,
+            child_operations: child_operations,
+          )
+        end
       end
     end
   end

data/lib/super_diff/operation_tree_builders/base.rb

@@ -0,0 +1,98 @@
+module SuperDiff
+  module OperationTreeBuilders
+    class Base
+      def self.applies_to?(_expected, _actual)
+        raise NotImplementedError
+      end
+
+      extend AttrExtras.mixin
+      include ImplementationChecks
+
+      method_object [:expected!, :actual!]
+
+      def call
+        operation_tree
+      end
+
+      protected
+
+      def unary_operations
+        unimplemented_instance_method!
+      end
+
+      def build_operation_tree
+        unimplemented_instance_method!
+      end
+
+      private
+
+      def operation_tree
+        unary_operations = self.unary_operations
+        operation_tree = build_operation_tree
+        unmatched_delete_operations = []
+
+        unary_operations.each_with_index do |operation, index|
+          if (
+            operation.name == :insert &&
+            (delete_operation = unmatched_delete_operations.find { |op| op.key == operation.key }) &&
+            (insert_operation = operation)
+          )
+            unmatched_delete_operations.delete(delete_operation)
+
+            if (child_operations = possible_comparison_of(
+              delete_operation,
+              insert_operation,
+            ))
+              operation_tree.delete(delete_operation)
+              operation_tree << Operations::BinaryOperation.new(
+                name: :change,
+                left_collection: delete_operation.collection,
+                right_collection: insert_operation.collection,
+                left_key: delete_operation.key,
+                right_key: insert_operation.key,
+                left_value: delete_operation.collection[operation.key],
+                right_value: insert_operation.collection[operation.key],
+                left_index: delete_operation.index_in_collection,
+                right_index: insert_operation.index_in_collection,
+                child_operations: child_operations,
+              )
+            else
+              operation_tree << insert_operation
+            end
+          else
+            if operation.name == :delete
+              unmatched_delete_operations << operation
+            end
+
+            operation_tree << operation
+          end
+        end
+
+        operation_tree
+      end
+
+      def possible_comparison_of(operation, next_operation)
+        if should_compare?(operation, next_operation)
+          sequence(operation.value, next_operation.value)
+        else
+          nil
+        end
+      end
+
+      def should_compare?(operation, next_operation)
+        next_operation &&
+          operation.name == :delete &&
+          next_operation.name == :insert &&
+          next_operation.key == operation.key
+      end
+
+      def sequence(expected, actual)
+        OperationTreeBuilders::Main.call(
+          expected: expected,
+          actual: actual,
+          all_or_nothing: false,
+        )
+      end
+    end
+  end
+end