super_diff 0.4.1 → 0.5.3

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

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

@@ -1,5 +1,5 @@
 module SuperDiff
-  module OperationalSequencers
+  module OperationTreeBuilders
     class CustomObject < DefaultObject
       def self.applies_to?(expected, actual)
         expected.class == actual.class &&
@@ -7,9 +7,9 @@ module SuperDiff
           actual.respond_to?(:attributes_for_super_diff)
       end
 
-      def build_operation_sequencer
+      def build_operation_tree
         # XXX This assumes that `expected` and `actual` are the same
-        OperationSequences::CustomObject.new([], value_class: expected.class)
+        OperationTrees::CustomObject.new([], value_class: expected.class)
       end
 
       def attribute_names

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

@@ -1,5 +1,5 @@
 module SuperDiff
-  module OperationalSequencers
+  module OperationTreeBuilders
     class DefaultObject < Base
       def self.applies_to?(_expected, _actual)
         true
@@ -22,9 +22,14 @@ module SuperDiff
         end
       end
 
-      def build_operation_sequencer
+      def build_operation_tree
         # XXX This assumes that `expected` and `actual` are the same
-        OperationSequences::DefaultObject.new([], value_class: expected.class)
+        # TODO: Does this need to be find_operation_tree_for?
+        OperationTrees::DefaultObject.new([], value_class: expected.class)
+      end
+
+      def find_operation_tree_for(value)
+        OperationTrees::Main.call(value)
       end
 
       def attribute_names

data/lib/super_diff/operation_tree_builders/defaults.rb

@@ -0,0 +1,5 @@
+module SuperDiff
+  module OperationTreeBuilders
+    DEFAULTS = [Array, Hash, CustomObject].freeze
+  end
+end

data/lib/super_diff/operation_tree_builders/hash.rb

@@ -0,0 +1,226 @@
+module SuperDiff
+  module OperationTreeBuilders
+    class Hash < Base
+      def self.applies_to?(expected, actual)
+        expected.is_a?(::Hash) && actual.is_a?(::Hash)
+      end
+
+      protected
+
+      def unary_operations
+        unary_operations_using_variant_of_patience_algorithm
+      end
+
+      def build_operation_tree
+        OperationTrees::Hash.new([])
+      end
+
+      private
+
+      def unary_operations_using_variant_of_patience_algorithm
+        operations = []
+        aks, eks = actual.keys, expected.keys
+        previous_ei, ei = nil, 0
+        ai = 0
+
+        # When diffing a hash, we're more interested in the 'actual' version
+        # than the 'expected' version, because that's the ultimate truth.
+        # Therefore, the diff is presented from the perspective of the 'actual'
+        # hash, and we start off by looping over it.
+        while ai < aks.size
+          ak = aks[ai]
+          av, ev = actual[ak], expected[ak]
+          # While we iterate over 'actual' in order, we jump all over
+          # 'expected', trying to match up its keys with the keys in 'actual' as
+          # much as possible.
+          ei = eks.index(ak)
+
+          if should_add_noop_operation?(ak)
+            # (If we're here, it probably means that the key we're pointing to
+            # in the 'actual' and 'expected' hashes have the same value.)
+
+            if ei && previous_ei && (ei - previous_ei) > 1
+              # If we've jumped from one operation in the 'expected' hash to
+              # another operation later in 'expected' (due to the fact that the
+              # 'expected' hash is in a different order than 'actual'), collect
+              # any delete operations in between and add them to our operations
+              # array as deletes before adding the noop. If we don't do this
+              # now, then those deletes will disappear. (Again, we are mainly
+              # iterating over 'actual', so this is the only way to catch all of
+              # the keys in 'expected'.)
+              (previous_ei + 1).upto(ei - 1) do |ei2|
+                ek = eks[ei2]
+                ev2, av2 = expected[ek], actual[ek]
+
+                if (
+                  (!actual.include?(ek) || ev != av2) &&
+                  operations.none? { |operation|
+                    [:delete, :noop].include?(operation.name) &&
+                      operation.key == ek
+                  }
+                )
+                  operations << Operations::UnaryOperation.new(
+                    name: :delete,
+                    collection: expected,
+                    key: ek,
+                    value: ev2,
+                    index: ei2,
+                    index_in_collection: ei2,
+                  )
+                end
+              end
+            end
+
+            operations << Operations::UnaryOperation.new(
+              name: :noop,
+              collection: actual,
+              key: ak,
+              value: av,
+              index: ai,
+              index_in_collection: ai,
+            )
+          else
+            # (If we're here, it probably means that the key in 'actual' isn't
+            # present in 'expected' or the values don't match.)
+
+            if (
+              (operations.empty? || operations.last.name == :noop) &&
+              (ai == 0 || eks.include?(aks[ai - 1]))
+            )
+              # If we go from a match in the last iteration to a missing or
+              # extra key in this one, or we're at the first key in 'actual' and
+              # it's missing or extra, look for deletes in the 'expected' hash
+              # and add them to our list of operations before we add the
+              # inserts. In most cases we will accomplish this by backtracking a
+              # bit to the key in 'expected' that matched the key in 'actual' we
+              # processed in the previous iteration (or just the first key in
+              # 'expected' if this is the first key in 'actual'), and then
+              # iterating from there through 'expected' until we reach the end
+              # or we hit some other condition (see below).
+
+              start_index =
+                if ai > 0
+                  eks.index(aks[ai - 1]) + 1
+                else
+                  0
+                end
+
+              start_index.upto(eks.size - 1) do |ei2|
+                ek = eks[ei2]
+                ev, av2 = expected[ek], actual[ek]
+
+                if actual.include?(ek) && ev == av2
+                  # If the key in 'expected' we've landed on happens to be a
+                  # match in 'actual', then stop, because it's going to be
+                  # handled in some future iteration of the 'actual' loop.
+                  break
+                elsif (
+                  aks[ai + 1 .. -1].any? { |k|
+                    expected.include?(k) && expected[k] != actual[k]
+                  }
+                )
+                  # While we backtracked a bit to iterate over 'expected', we
+                  # now have to look ahead. If we will end up encountering a
+                  # insert that matches this delete later, stop and go back to
+                  # iterating over 'actual'. This is because the delete we would
+                  # have added now will be added later when we encounter the
+                  # associated insert, so we don't want to add it twice.
+                  break
+                else
+                  operations << Operations::UnaryOperation.new(
+                    name: :delete,
+                    collection: expected,
+                    key: ek,
+                    value: ev,
+                    index: ei2,
+                    index_in_collection: ei2,
+                  )
+                end
+
+                if ek == ak && ev != av
+                  # If we're pointing to the same key in 'expected' as in
+                  # 'actual', but with different values, go ahead and add an
+                  # insert now to accompany the delete added above. That way
+                  # they appear together, which will be easier to read.
+                  operations << Operations::UnaryOperation.new(
+                    name: :insert,
+                    collection: actual,
+                    key: ak,
+                    value: av,
+                    index: ai,
+                    index_in_collection: ai,
+                  )
+                end
+              end
+            end
+
+            if (
+              expected.include?(ak) &&
+              ev != av &&
+              operations.none? { |op| op.name == :delete && op.key == ak }
+            )
+              # If we're here, it means that we didn't encounter any delete
+              # operations above for whatever reason and so we need to add a
+              # delete to represent the fact that the value for this key has
+              # changed.
+              operations << Operations::UnaryOperation.new(
+                name: :delete,
+                collection: expected,
+                key: ak,
+                value: expected[ak],
+                index: ei,
+                index_in_collection: ei,
+              )
+            end
+
+            if operations.none? { |op| op.name == :insert && op.key == ak }
+              # If we're here, it means that we didn't encounter any insert
+              # operations above. Since we already handled delete, the only
+              # alternative is that this key must not exist in 'expected', so
+              # we need to add an insert.
+              operations << Operations::UnaryOperation.new(
+                name: :insert,
+                collection: actual,
+                key: ak,
+                value: av,
+                index: ai,
+                index_in_collection: ai,
+              )
+            end
+          end
+
+          ai += 1
+          previous_ei = ei
+        end
+
+        # The last thing to do is this: if there are keys in 'expected' that
+        # aren't in 'actual', and they aren't associated with any inserts to
+        # where they would have been added above, tack those deletes onto the
+        # end of our operations array.
+        (eks - aks - operations.map(&:key)).each do |ek|
+          ei = eks.index(ek)
+          ev = expected[ek]
+
+          operations << Operations::UnaryOperation.new(
+            name: :delete,
+            collection: expected,
+            key: ek,
+            value: ev,
+            index: ei,
+            index_in_collection: ei,
+          )
+        end
+
+        operations
+      end
+
+      def should_add_noop_operation?(key)
+        expected.include?(key) && expected[key] == actual[key]
+      end
+
+      def all_keys
+        actual.keys | expected.keys
+      end
+    end
+  end
+end