super_diff 0.16.0 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a7da584c29393f807295a740d893c8890b5d33f9507f4c0ddd914b672b5e9b71
-  data.tar.gz: 89e8cb0b6bd46b7f109b91421636acb21356e14c1e75e0acbd6a45d22b086172
+  metadata.gz: f84c14c100aff4bd5ec41c27530ecc6e7a586a90d770a07617b2a591fb438658
+  data.tar.gz: b441eb9beafd67394df0f3b6a13d0bfafc5cd94d06593acf5780b8df7cc59df0
 SHA512:
-  metadata.gz: 573603b3933aa21c388973e295565199e0c15660a28f7204d1a9d281f0ca320cf28e80bbaf0b9074df13c1e0ea324a5654844985a3f0db9011eb2bb5ff3b7c6c
-  data.tar.gz: 8daa4e73a589b67ac571ea101d7080a1487daf13dc42ce0ce7ee224b9801fd8ed3399e8380c9611cec4d2e93dc5611af3c9bbd5da02c434245d9fda5f127de19
+  metadata.gz: 0a581414c9306226bd8a65cd5c92d8d64e35586a969beefdf2f53f08d7c97bd57d78d30dcf98fcd1f1b7f33446a2eda4f719510ac42106818e83022f3f7b0307
+  data.tar.gz: a5efcec3c3818c5849110701813c04dd66f8fe8edebbd3f4db031fddbb30916303331ae20489421e94dc24f0dd047af9e8e03e810d5ba5bc90a30cbe9d995524

data/lib/super_diff/basic/operation_tree_builders/hash.rb

@@ -21,195 +21,95 @@ module SuperDiff
         private
 
         def unary_operations_using_variant_of_patience_algorithm
-          operations = []
           aks = actual.keys
           eks = expected.keys
-          previous_ei = nil
-          ei = 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 = actual[ak]
-            ev = 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 = expected[ek]
-                  av2 = actual[ek]
-
-                  next unless
-                       (!actual.include?(ek) || ev2 != av2) &&
-                       operations.none? do |operation|
-                         %i[delete noop].include?(operation.name) &&
-                         operation.key == ek
-                       end
-
-                  operations << Core::UnaryOperation.new(
-                    name: :delete,
-                    collection: expected,
-                    key: ek,
-                    value: ev2,
-                    index: ei2
-                  )
-                end
-              end
 
+          operations = []
+          lcs_callbacks = LCSCallbacks.new(
+            operations: operations,
+            expected: expected,
+            actual: actual,
+            should_add_noop_operation: method(:should_add_noop_operation?)
+          )
+          Diff::LCS.traverse_sequences(eks, aks, lcs_callbacks)
+
+          operations
+        end
+
+        class LCSCallbacks
+          extend AttrExtras.mixin
+
+          pattr_initialize %i[operations! expected! actual! should_add_noop_operation!]
+          public :operations
+
+          def discard_a(event)
+            # This key is in `expected`, but may also be in `actual`.
+            key = event.old_element
+
+            # We want the diff to match the key order of `actual` as much as
+            # possible, so if this is also a key in `actual` that's just being
+            # reordered, don't add any operations now. The change or noop will
+            # be added later.
+            return if actual.include?(key)
+
+            operations << Core::UnaryOperation.new(
+              name: :delete,
+              collection: expected,
+              key: key,
+              value: expected[key],
+              index: event.old_position
+            )
+          end
+
+          def discard_b(event)
+            # This key is in `actual`, but may also be in `expected`.
+
+            key = event.new_element
+            handle_operation_on_key_in_actual(key, event)
+          end
+
+          def match(event)
+            # This key is part of the longest common subsequence.
+
+            key = event.old_element
+            handle_operation_on_key_in_actual(key, event)
+          end
+
+          private
+
+          def handle_operation_on_key_in_actual(key, event)
+            if should_add_noop_operation.call(key)
               operations << Core::UnaryOperation.new(
                 name: :noop,
                 collection: actual,
-                key: ak,
-                value: av,
-                index: ai
+                key: key,
+                value: actual[key],
+                index: event.new_position
               )
             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.zero? || 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.positive?
-                    eks.index(aks[ai - 1]) + 1
-                  else
-                    0
-                  end
-
-                start_index.upto(eks.size - 1) do |ei2|
-                  ek = eks[ei2]
-                  ev = expected[ek]
-                  av2 = 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..].any? do |k| # rubocop:disable Lint/DuplicateBranch for clarity
-                          expected.include?(k) && expected[k] != actual[k]
-                        end
-
-                    # 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 << Core::UnaryOperation.new(
-                      name: :delete,
-                      collection: expected,
-                      key: ek,
-                      value: ev,
-                      index: ei2
-                    )
-                  end
-
-                  next unless 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 << Core::UnaryOperation.new(
-                    name: :insert,
-                    collection: actual,
-                    key: ak,
-                    value: av,
-                    index: ai
-                  )
-                end
-              end
-
-              if expected.include?(ak) && ev != av &&
-                 operations.none? do |op|
-                   op.name == :delete && op.key == ak
-                 end
-
-                # 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.
+              # If the key is present in both `actual` and `expected`
+              # but the values don't match, create a `delete` operation
+              # just before the `insert`.
+              # (This condition will always be true for `match` events.)
+              if expected.include?(key)
                 operations << Core::UnaryOperation.new(
                   name: :delete,
                   collection: expected,
-                  key: ak,
-                  value: expected[ak],
-                  index: ei
+                  key: key,
+                  value: expected[key],
+                  index: event.old_position
                 )
               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 << Core::UnaryOperation.new(
-                  name: :insert,
-                  collection: actual,
-                  key: ak,
-                  value: av,
-                  index: ai
-                )
-              end
+              operations << Core::UnaryOperation.new(
+                name: :insert,
+                collection: actual,
+                key: key,
+                value: actual[key],
+                index: event.new_position
+              )
             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 << Core::UnaryOperation.new(
-              name: :delete,
-              collection: expected,
-              key: ek,
-              value: ev,
-              index: ei
-            )
           end
-
-          operations
         end
 
         def should_add_noop_operation?(key)

data/lib/super_diff/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SuperDiff
-  VERSION = '0.16.0'
+  VERSION = '0.17.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: super_diff
 version: !ruby/object:Gem::Version
-  version: 0.16.0
+  version: 0.17.0
 platform: ruby
 authors:
 - Elliot Winkler
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-06-18 00:00:00.000000000 Z
+date: 2025-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: attr_extras