Retain original ordering of keys when diffing hashes

.rubocop.yml

@@ -50,6 +50,8 @@ Metrics/BlockLength:
     - shared_context
     - shared_examples
     - shared_examples_for
+Metrics/BlockNesting:
+  Enabled: false
 Metrics/ClassLength:
   Enabled: false
 Metrics/CyclomaticComplexity:
@@ -115,10 +117,14 @@ Style/NegatedIf:
   Enabled: false
 Style/NegatedWhile:
   Enabled: false
+Style/Next:
+  Enabled: false
 Style/NumericPredicate:
   Enabled: false
 Style/OneLineConditional:
   Enabled: false
+Style/ParallelAssignment:
+  Enabled: false
 Style/PercentLiteralDelimiters:
   Enabled: false
 Style/PreferredHashMethods:

lib/super_diff/operational_sequencers/array.rb

@@ -32,36 +32,15 @@ class LcsCallbacks
         public :operations
 
         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)
@@ -77,21 +56,6 @@ def change(event)
 
         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(
             name: :delete,
@@ -113,6 +77,33 @@ def add_insert_operation(event)
             index_in_collection: actual.index(event.new_element),
           )
         end
+
+        def add_noop_operation(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),
+          )
+        end
+
+        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
+
       end
     end
   end

lib/super_diff/operational_sequencers/base.rb

@@ -10,35 +10,7 @@ def self.applies_to?(_expected, _actual)
       method_object [:expected!, :actual!]
 
       def call
-        i = 0
-        operations = build_operation_sequence
-
-        while i < unary_operations.length
-          operation = unary_operations[i]
-          next_operation = unary_operations[i + 1]
-          child_operations = possible_comparison_of(operation, next_operation)
-
-          if child_operations
-            operations << Operations::BinaryOperation.new(
-              name: :change,
-              left_collection: operation.collection,
-              right_collection: next_operation.collection,
-              left_key: operation.key,
-              right_key: operation.key,
-              left_value: operation.collection[operation.key],
-              right_value: next_operation.collection[operation.key],
-              left_index: operation.index,
-              right_index: operation.index,
-              child_operations: child_operations,
-            )
-            i += 2
-          else
-            operations << operation
-            i += 1
-          end
-        end
-
-        operations
+        compressed_operations
       end
 
       protected
@@ -53,6 +25,51 @@ def build_operation_sequence
 
       private
 
+      def compressed_operations
+        unary_operations = self.unary_operations
+        compressed_operations = build_operation_sequence
+        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,
+            ))
+              compressed_operations.delete(delete_operation)
+              compressed_operations << 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
+              compressed_operations << insert_operation
+            end
+          else
+            if operation.name == :delete
+              unmatched_delete_operations << operation
+            end
+
+            compressed_operations << operation
+          end
+        end
+
+        compressed_operations
+      end
+
       def possible_comparison_of(operation, next_operation)
         if should_compare?(operation, next_operation)
           sequence(operation.value, next_operation.value)
@@ -65,7 +82,7 @@ def should_compare?(operation, next_operation)
         next_operation &&
           operation.name == :delete &&
           next_operation.name == :insert &&
-          next_operation.index == operation.index
+          next_operation.key == operation.key
       end
 
       def sequence(expected, actual)