super_diff 0.1.0 → 0.2.0

data/lib/super_diff/operational_sequencer.rb

@@ -1,20 +1,16 @@
 module SuperDiff
   class OperationalSequencer
-    def self.call(*args)
-      new(*args).call
-    end
+    extend AttrExtras.mixin
 
-    def initialize(
-      expected:,
-      actual:,
-      extra_classes: [],
-      extra_diff_formatter_classes: []
+    method_object(
+      [
+        :expected!,
+        :actual!,
+        :all_or_nothing!,
+        extra_classes: [],
+        extra_diff_formatter_classes: [],
+      ],
     )
-      @expected = expected
-      @actual = actual
-      @extra_classes = extra_classes
-      @extra_diff_formatter_classes = extra_diff_formatter_classes
-    end
 
     def call
       if resolved_class
@@ -24,19 +20,28 @@ module SuperDiff
           extra_operational_sequencer_classes: extra_classes,
           extra_diff_formatter_classes: extra_diff_formatter_classes,
         )
-      else
+      elsif all_or_nothing?
         raise NoOperationalSequencerAvailableError.create(expected, actual)
+      else
+        nil
       end
     end
 
     private
 
-    attr_reader :expected, :actual, :extra_classes,
-      :extra_diff_formatter_classes
+    attr_query :all_or_nothing?
 
     def resolved_class
-      (OperationalSequencers::DEFAULTS + extra_classes).find do |klass|
-        klass.applies_to?(expected) && klass.applies_to?(actual)
+      available_classes.find { |klass| klass.applies_to?(expected, actual) }
+    end
+
+    def available_classes
+      classes = extra_classes + OperationalSequencers::DEFAULTS
+
+      if all_or_nothing?
+        classes + [OperationalSequencers::DefaultObject]
+      else
+        classes
       end
     end
   end

data/lib/super_diff/operational_sequencers.rb

@@ -1,5 +1,16 @@
 module SuperDiff
   module OperationalSequencers
-    DEFAULTS = [Array, Hash].freeze
+    autoload :Array, "super_diff/operational_sequencers/array"
+    autoload :Base, "super_diff/operational_sequencers/base"
+    autoload :CustomObject, "super_diff/operational_sequencers/custom_object"
+    autoload :DefaultObject, "super_diff/operational_sequencers/default_object"
+    autoload :Hash, "super_diff/operational_sequencers/hash"
+    # TODO: Where is this used?
+    autoload(
+      :MultilineString,
+      "super_diff/operational_sequencers/multiline_string",
+    )
+
+    DEFAULTS = [Array, Hash, CustomObject].freeze
   end
 end

data/lib/super_diff/operational_sequencers/array.rb

@@ -1,46 +1,46 @@
 module SuperDiff
   module OperationalSequencers
     class Array < Base
-      def self.applies_to?(value)
-        value.is_a?(::Array)
+      def self.applies_to?(expected, actual)
+        expected.is_a?(::Array) && actual.is_a?(::Array)
       end
 
-      def initialize(*args)
-        super(*args)
+      def call
+        Diff::LCS.traverse_balanced(expected, actual, lcs_callbacks)
+        operations
+      end
 
-        @lcs_callbacks = LcsCallbacks.new(
+      private
+
+      def lcs_callbacks
+        @_lcs_callbacks ||= LcsCallbacks.new(
+          operations: operations,
           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 call
-        Diff::LCS.traverse_balanced(expected, actual, lcs_callbacks)
-        lcs_callbacks.operations
+      def operations
+        @_operations ||= OperationSequences::Array.new([])
       end
 
-      private
-
-      attr_reader :lcs_callbacks
-
       class LcsCallbacks
-        attr_reader :operations
+        extend AttrExtras.mixin
 
-        def initialize(
-          expected:,
-          actual:,
-          extra_operational_sequencer_classes:,
-          extra_diff_formatter_classes:
+        pattr_initialize(
+          [
+            :operations!,
+            :expected!,
+            :actual!,
+            :extra_operational_sequencer_classes!,
+            :extra_diff_formatter_classes!,
+            :sequence!
+          ],
         )
-          @expected = expected
-          @actual = actual
-          @operations = OperationSequences::Array.new([])
-          @extra_operational_sequencer_classes =
-            extra_operational_sequencer_classes
-          @extra_diff_formatter_classes = extra_diff_formatter_classes
-        end
+        public :operations
 
         def match(event)
           operations << ::SuperDiff::Operations::UnaryOperation.new(
@@ -49,6 +49,7 @@ module SuperDiff
             key: event.new_position,
             value: event.new_element,
             index: event.new_position,
+            index_in_collection: actual.index(event.new_element),
           )
         end
 
@@ -59,6 +60,7 @@ module SuperDiff
             key: event.old_position,
             value: event.old_element,
             index: event.old_position,
+            index_in_collection: expected.index(event.old_element),
           )
         end
 
@@ -69,57 +71,58 @@ module SuperDiff
             key: event.new_position,
             value: event.new_element,
             index: event.new_position,
+            index_in_collection: actual.index(event.new_element),
           )
         end
 
         def change(event)
-          child_operations = sequence(event.old_element, event.new_element)
+          child_operations = sequence.call(event.old_element, event.new_element)
 
           if 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,
-            )
+            add_change_operation(event, child_operations)
           else
-            operations << Operations::UnaryOperation.new(
-              name: :delete,
-              collection: expected,
-              key: event.old_position,
-              value: event.old_element,
-              index: event.old_position,
-            )
-            operations << Operations::UnaryOperation.new(
-              name: :insert,
-              collection: actual,
-              key: event.new_position,
-              value: event.new_element,
-              index: event.new_position,
-            )
+            add_delete_operation(event)
+            add_insert_operation(event)
           end
         end
 
         private
 
-        attr_reader :expected, :actual, :extra_operational_sequencer_classes,
-          :extra_diff_formatter_classes
+        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(
+            name: :delete,
+            collection: expected,
+            key: event.old_position,
+            value: event.old_element,
+            index: event.old_position,
+            index_in_collection: expected.index(event.old_element),
+          )
+        end
 
-        def sequence(expected, actual)
-          OperationalSequencer.call(
-            expected: expected,
-            actual: actual,
-            extra_classes: extra_operational_sequencer_classes,
-            extra_diff_formatter_classes: extra_diff_formatter_classes,
+        def add_insert_operation(event)
+          operations << 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),
           )
-        rescue NoOperationalSequencerAvailableError
-          nil
         end
       end
     end

data/lib/super_diff/operational_sequencers/base.rb

@@ -1,30 +1,24 @@
 module SuperDiff
   module OperationalSequencers
     class Base
-      def self.applies_to?(_value)
+      def self.applies_to?(_expected, _actual)
         raise NotImplementedError
       end
 
-      def self.call(*args)
-        new(*args).call
-      end
+      extend AttrExtras.mixin
 
-      def initialize(
-        expected:,
-        actual:,
-        extra_operational_sequencer_classes: [],
-        extra_diff_formatter_classes: []
+      method_object(
+        [
+          :expected!,
+          :actual!,
+          extra_operational_sequencer_classes: [],
+          extra_diff_formatter_classes: [],
+        ],
       )
-        @expected = expected
-        @actual = actual
-        @extra_operational_sequencer_classes =
-          extra_operational_sequencer_classes
-        @extra_diff_formatter_classes = extra_diff_formatter_classes
-      end
 
       def call
         i = 0
-        operations = operation_sequence_class.new([])
+        operations = build_operation_sequencer
 
         while i < unary_operations.length
           operation = unary_operations[i]
@@ -60,18 +54,17 @@ module SuperDiff
         raise NotImplementedError
       end
 
-      def operation_sequence_class
+      def build_operation_sequencer
         raise NotImplementedError
       end
 
       private
 
-      attr_reader :expected, :actual, :extra_operational_sequencer_classes,
-        :extra_diff_formatter_classes
-
       def possible_comparison_of(operation, next_operation)
         if should_compare?(operation, next_operation)
-          sequence(operation, next_operation)
+          sequence(operation.value, next_operation.value)
+        else
+          nil
         end
       end
 
@@ -82,15 +75,14 @@ module SuperDiff
           next_operation.index == operation.index
       end
 
-      def sequence(operation, next_operation)
+      def sequence(expected, actual)
         OperationalSequencer.call(
-          expected: operation.value,
-          actual: next_operation.value,
+          expected: expected,
+          actual: actual,
+          all_or_nothing: false,
           extra_classes: extra_operational_sequencer_classes,
           extra_diff_formatter_classes: extra_diff_formatter_classes,
         )
-      rescue NoOperationalSequencerAvailableError
-        nil
       end
     end
   end

data/lib/super_diff/operational_sequencers/custom_object.rb

@@ -0,0 +1,35 @@
+module SuperDiff
+  module OperationalSequencers
+    class CustomObject < DefaultObject
+      def self.applies_to?(expected, actual)
+        expected.class == actual.class &&
+          expected.respond_to?(:attributes_for_super_diff) &&
+          actual.respond_to?(:attributes_for_super_diff)
+      end
+
+      def build_operation_sequencer
+        # XXX This assumes that `expected` and `actual` are the same
+        OperationSequences::CustomObject.new([], value_class: expected.class)
+      end
+
+      def attribute_names
+        expected.attributes_for_super_diff.keys &
+          actual.attributes_for_super_diff.keys
+      end
+
+      private
+
+      attr_reader :expected_attributes, :actual_attributes
+
+      def establish_expected_and_actual_attributes
+        @expected_attributes = attribute_names.reduce({}) do |hash, name|
+          hash.merge(name => expected.public_send(name))
+        end
+
+        @actual_attributes = attribute_names.reduce({}) do |hash, name|
+          hash.merge(name => actual.public_send(name))
+        end
+      end
+    end
+  end
+end

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

@@ -1,16 +1,14 @@
 module SuperDiff
   module OperationalSequencers
-    class Object < Base
+    class DefaultObject < Base
+      def self.applies_to?(_expected, _actual)
+        true
+      end
+
       def initialize(*args)
         super(*args)
 
-        @expected_attributes = attribute_names.reduce({}) do |hash, name|
-          hash.merge(name => expected.public_send(name))
-        end
-
-        @actual_attributes = attribute_names.reduce({}) do |hash, name|
-          hash.merge(name => actual.public_send(name))
-        end
+        establish_expected_and_actual_attributes
       end
 
       protected
@@ -24,18 +22,30 @@ module SuperDiff
         end
       end
 
-      def operation_sequence_class
-        OperationSequences::Object
+      def build_operation_sequencer
+        # XXX This assumes that `expected` and `actual` are the same
+        OperationSequences::DefaultObject.new([], value_class: expected.class)
       end
 
       def attribute_names
-        raise NotImplementedError
+        (expected.instance_variables.sort & actual.instance_variables.sort).
+          map { |variable_name| variable_name[1..-1] }
       end
 
       private
 
       attr_reader :expected_attributes, :actual_attributes
 
+      def establish_expected_and_actual_attributes
+        @expected_attributes = attribute_names.reduce({}) do |hash, name|
+          hash.merge(name => expected.instance_variable_get("@#{name}"))
+        end
+
+        @actual_attributes = attribute_names.reduce({}) do |hash, name|
+          hash.merge(name => actual.instance_variable_get("@#{name}"))
+        end
+      end
+
       def possibly_add_noop_operation_to(operations, attribute_name)
         if should_add_noop_operation?(attribute_name)
           operations << Operations::UnaryOperation.new(

data/lib/super_diff/operational_sequencers/hash.rb

@@ -1,8 +1,8 @@
 module SuperDiff
   module OperationalSequencers
     class Hash < Base
-      def self.applies_to?(value)
-        value.is_a?(::Hash)
+      def self.applies_to?(expected, actual)
+        expected.is_a?(::Hash) && actual.is_a?(::Hash)
       end
 
       protected
@@ -16,14 +16,14 @@ module SuperDiff
         end
       end
 
-      def operation_sequence_class
-        OperationSequences::Hash
+      def build_operation_sequencer
+        OperationSequences::Hash.new([])
       end
 
       private
 
       def all_keys
-        (expected.keys | actual.keys)
+        actual.keys | expected.keys
       end
 
       def possibly_add_noop_to(operations, key)
@@ -33,6 +33,7 @@ module SuperDiff
             collection: actual,
             key: key,
             index: all_keys.index(key),
+            index_in_collection: actual.keys.index(key),
             value: actual[key],
           )
         end
@@ -51,6 +52,7 @@ module SuperDiff
             collection: expected,
             key: key,
             index: all_keys.index(key),
+            index_in_collection: expected.keys.index(key),
             value: expected[key],
           )
         end
@@ -68,6 +70,7 @@ module SuperDiff
             collection: actual,
             key: key,
             index: all_keys.index(key),
+            index_in_collection: actual.keys.index(key),
             value: actual[key],
           )
         end