hashdiff 1.2.1 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 99e198ac76f687f33cb2537c32bd81ccdd45798502cba565a624d1107a7e85ca
-  data.tar.gz: 7eba9f454570311e7b784d3da51db6827331f6e9c73d98d113b407d57bc60626
+  metadata.gz: e1cbec06648aef6ff8f519bab7e12a667121f4dec64a603f172198d818f245bb
+  data.tar.gz: fe86c5abd6c6c61b8820a3c90e3f09aa56233087831932f75da507e05212858d
 SHA512:
-  metadata.gz: e8bf11d2563db1d99348a17bd6074e51cfd35dc95968bf43eca5f115b7af7547c5a08457b031b880442e4d8111343d3e096c8d5075c83a63c858fcd8627d4140
-  data.tar.gz: 6b318cd78d7f8dac01d1fea139fbc81d4724dc2c9a7f4cb0b21d5c54b38da5384908e6ba91b40503d7c501d596d4f91ecaf348122679f62fb91f0a2dc6e8e30a
+  metadata.gz: e09cd08b570c6fb894bb4e904369f64061e78125a8b83462b22d5b37fb9b549afcd501a1bfc839e8aaf02ce552b420b121d08c12109ed74b47e2c8dc8b1b7957
+  data.tar.gz: ede8595360f0da6f409c4955d979f82fe6f72df3434485cb036d0277b6173fcb64371a6d810f89c2c0eeb55e850a16bfbc27c195d8191337d800c25eff5967d6

data/RELEASE.md

@@ -0,0 +1,76 @@
+# Releasing Hashdiff
+
+Prepare releases directly on `master`: update the changelog and version, make a
+release commit, and push it to `origin/master`. Previous releases followed this
+process (for example, `8846a2c` for 1.2.1). A release PR is not required.
+
+## Prepare the release
+
+1. Start with a clean working tree and bring `master` up to date:
+
+   ```sh
+   git checkout master
+   git pull --ff-only origin master
+   git fetch --tags origin
+   git status --short
+   ```
+
+2. Review changes since the previous release, replacing `v1.2.1` with the
+   previous release tag:
+
+   ```sh
+   git log --oneline v1.2.1..HEAD
+   git diff v1.2.1..HEAD -- lib spec
+   ```
+
+3. Update `Hashdiff::VERSION` in `lib/hashdiff/version.rb`. The gemspec reads
+   this constant; it does not have a separate version to update.
+
+4. Add a section at the top of `changelog.md` with the matching version and
+   release date (`YYYY-MM-DD`). Summarize changes users will notice and link to
+   the relevant pull requests and contributors.
+
+## Validate and push
+
+The commands below use 1.2.2 as an example; substitute the version being released.
+
+1. Install development dependencies and run the same checks as CI (RSpec and
+   RuboCop):
+
+   ```sh
+   bundle install
+   bundle exec rake
+   ```
+
+2. Stage and review the release files, then build the gem. The gemspec uses
+   `git ls-files`, so stage any new files that should be packaged before building.
+   Generated `.gem` files are ignored and should not be committed.
+
+   ```sh
+   git add changelog.md lib/hashdiff/version.rb RELEASE.md
+   git diff --cached --check
+   git diff --cached
+   gem build hashdiff.gemspec
+   ```
+
+3. Commit and push directly to `master`, then check the GitHub Actions result:
+
+   ```sh
+   git commit -m "Release 1.2.2"
+   git push origin master
+   ```
+
+## Publish the gem
+
+Pushing to `master` runs CI; it does not publish to RubyGems. When publishing the
+gem, wait for CI to pass and use a maintainer account with RubyGems push access.
+From the release commit, tag the release and publish the gem built above:
+
+```sh
+git tag v1.2.2
+git push origin v1.2.2
+gem push hashdiff-1.2.2.gem
+```
+
+Confirm that RubyGems lists the new version. If a version has already been
+published, prepare a new version rather than reusing it or moving its release tag.

data/changelog.md

@@ -1,5 +1,10 @@
 # Change Log
 
+## v1.2.2 2026-11-08
+
+* Fix array diffs with `use_lcs: false` so that `patch!` can replay them correctly [#102](https://github.com/liufengyun/hashdiff/pull/102) ([@oboxodo](https://github.com/oboxodo))
+* Reduce LCS memory use and improve performance for equal arrays and arrays with common leading or trailing items [#103](https://github.com/liufengyun/hashdiff/pull/103) ([@oboxodo](https://github.com/oboxodo))
+
 ## v1.2.1 2025-09-06
 
 * Use HTTPS for the source in the Gemfile [#101](https://github.com/liufengyun/hashdiff/issues/101) ([@krzysiek1507](https://github.com/krzysiek1507))

data/lib/hashdiff/lcs.rb

@@ -6,61 +6,125 @@ module Hashdiff
   # caculate array difference using LCS algorithm
   # http://en.wikipedia.org/wiki/Longest_common_subsequence_problem
   def self.lcs(arraya, arrayb, options = {})
-    return [] if arraya.empty? || arrayb.empty?
+    Lcs.call(arraya, arrayb, options)
+  end
+
+  # @private
+  #
+  # Finds the pairs [index in arraya, index in arrayb] of similar items that
+  # make up the longest common subsequence of the two arrays.
+  class Lcs
+    def self.call(arraya, arrayb, options = {})
+      return [] if arraya.empty? || arrayb.empty?
+
+      new(arraya, arrayb, options).call
+    end
 
-    opts = { similarity: 0.8 }.merge!(options)
+    # The table costs O(n * m), so it only covers the items between the common
+    # prefix and suffix. The result is the same as with a full table.
+    def call
+      pair_common_suffix
+      start = common_prefix_length
+      backtrack(build_table(start), start)
+      backtrack_through_prefix
+      pairs.reverse
+    end
 
-    opts[:prefix] = prefix_append_array_index(opts[:prefix], '*', opts)
+    private
 
-    a_start = b_start = 0
-    a_finish = arraya.size - 1
-    b_finish = arrayb.size - 1
-    vector = []
+    attr_reader :arraya, :arrayb, :options, :pairs
+    # the items the backtrack is at, walking from the last ones to the first
+    attr_accessor :a_index, :b_index
 
-    lcs = []
-    (b_start..b_finish).each do |bi|
-      lcs[bi] = []
-      (a_start..a_finish).each do |ai|
-        if similar?(arraya[ai], arrayb[bi], opts)
-          topleft = (ai > 0) && (bi > 0) ? lcs[bi - 1][ai - 1][1] : 0
-          lcs[bi][ai] = [:topleft, topleft + 1]
-        elsif (top = bi > 0 ? lcs[bi - 1][ai][1] : 0)
-          left = ai > 0 ? lcs[bi][ai - 1][1] : 0
-          count = top > left ? top : left
+    def initialize(arraya, arrayb, options)
+      @arraya = arraya
+      @arrayb = arrayb
+      @options = { similarity: 0.8 }.merge!(options)
+      @options[:prefix] = Hashdiff.prefix_append_array_index(@options[:prefix], '*', @options)
+      @pairs = []
+      self.a_index = arraya.size - 1
+      self.b_index = arrayb.size - 1
+    end
 
-          direction = if top > left
-                        :top
-                      elsif top < left
-                        :left
-                      elsif bi.zero?
-                        :top
-                      elsif ai.zero?
-                        :left
-                      else
-                        :both
-                      end
+    # The backtrack starts at the last items and pairs them whenever they are
+    # similar, so it always pairs the common suffix item by item.
+    def pair_common_suffix
+      pair_and_step while a_index >= 0 && b_index >= 0 && similar_at?(a_index, b_index)
+    end
 
-          lcs[bi][ai] = [direction, count]
+    def common_prefix_length
+      length = 0
+      length += 1 while length <= a_index && length <= b_index && similar_at?(length, length)
+      length
+    end
+
+    # Each cell holds the length of the LCS of the items up to it, and the
+    # direction the backtrack takes from it. When both directions give the
+    # same length it goes left.
+    #
+    # Past a common prefix, the lengths in a full table are the ones in this
+    # table plus the prefix length, so both backtracks take the same steps.
+    def build_table(start)
+      a_items = arraya[start...a_index + 1]
+      b_items = arrayb[start...b_index + 1]
+      table = []
+      b_items.each_with_index do |b_item, bi|
+        above = table[bi - 1] if bi > 0
+        row = table[bi] = []
+        a_items.each_with_index do |a_item, ai|
+          row[ai] = if Hashdiff.similar?(a_item, b_item, options)
+                      [:topleft, (above && ai > 0 ? above[ai - 1][1] : 0) + 1]
+                    else
+                      top = above ? above[ai][1] : 0
+                      left = ai > 0 ? row[ai - 1][1] : 0
+                      top > left ? [:top, top] : [:left, left]
+                    end
         end
       end
+      table
     end
 
-    x = a_finish
-    y = b_finish
-    while (x >= 0) && (y >= 0) && (lcs[y][x][1] > 0)
-      if lcs[y][x][0] == :both
-        x -= 1
-      elsif lcs[y][x][0] == :topleft
-        vector.insert(0, [x, y])
-        x -= 1
-        y -= 1
-      elsif lcs[y][x][0] == :top
-        y -= 1
-      elsif lcs[y][x][0] == :left
-        x -= 1
+    # Cells of length 0 point left, so once the middle has no more pairs the
+    # backtrack leaves the table into the prefix, as a full table's would.
+    def backtrack(table, start)
+      while a_index >= start && b_index >= start
+        direction = table[b_index - start][a_index - start].first
+        if direction == :topleft
+          pair_and_step
+        elsif direction == :top
+          self.b_index = b_index - 1
+        else
+          self.a_index = a_index - 1
+        end
       end
     end
 
-    vector
+    # Takes the steps a full table would take once an index is in the prefix:
+    # it pairs similar items and otherwise steps towards the diagonal, where
+    # items are known to be similar. So the last prefix item can pair with a
+    # later copy:
+    #
+    #     lcs(%w[x w], %w[x x z]) # => [[0, 1]]
+    def backtrack_through_prefix
+      while a_index >= 0 && b_index >= 0
+        if a_index == b_index || similar_at?(a_index, b_index)
+          pair_and_step
+        elsif b_index > a_index
+          self.b_index = b_index - 1
+        else
+          self.a_index = a_index - 1
+        end
+      end
+    end
+
+    def similar_at?(index_a, index_b)
+      Hashdiff.similar?(arraya[index_a], arrayb[index_b], options)
+    end
+
+    def pair_and_step
+      pairs << [a_index, b_index]
+      self.a_index = a_index - 1
+      self.b_index = b_index - 1
+    end
   end
 end

data/lib/hashdiff/linear_compare_array.rb

@@ -16,9 +16,6 @@ module Hashdiff
 
       self.old_index = 0
       self.new_index = 0
-      # by comparing the array lengths we can expect that a number of items
-      # are either added or removed
-      self.expected_additions = new_array.length - old_array.length
 
       loop do
         if extra_items_in_old_array?
@@ -40,7 +37,7 @@ module Hashdiff
     private
 
     attr_reader :old_array, :new_array, :options, :additions, :deletions, :differences
-    attr_accessor :old_index, :new_index, :expected_additions
+    attr_accessor :old_index, :new_index
 
     def initialize(old_array, new_array, options)
       @old_array = old_array
@@ -60,6 +57,12 @@ module Hashdiff
       new_index < new_array.length && old_index >= old_array.length
     end
 
+    # by comparing the lengths of what is left of each array we can expect
+    # that a number of items are either added or removed
+    def expected_additions
+      (new_array.length - new_index) - (old_array.length - old_index)
+    end
+
     def iterated_through_both_arrays?
       old_index >= old_array.length && new_index >= new_array.length
     end
@@ -69,7 +72,7 @@ module Hashdiff
       return if difference.empty?
 
       index_after_additions = index_of_match_after_additions
-      append_addititions_before_match(index_after_additions)
+      append_additions_before_match(index_after_additions)
 
       index_after_deletions = index_of_match_after_deletions
       append_deletions_before_match(index_after_deletions)
@@ -120,11 +123,10 @@ module Hashdiff
       nil
     end
 
-    def append_addititions_before_match(match_index)
+    def append_additions_before_match(match_index)
       return unless match_index
 
       (new_index...match_index).each { |i| append_addition(new_array[i], i) }
-      self.expected_additions = expected_additions - (match_index - new_index)
       self.new_index = match_index
     end
 
@@ -132,7 +134,6 @@ module Hashdiff
       return unless match_index
 
       (old_index...match_index).each { |i| append_deletion(old_array[i], i) }
-      self.expected_additions = expected_additions + (match_index - new_index)
       self.old_index = match_index
     end
 

data/lib/hashdiff/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Hashdiff
-  VERSION = '1.2.1'.freeze
+  VERSION = '1.2.2'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hashdiff
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.2.2
 platform: ruby
 authors:
 - Liu Fengyun
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-09-06 00:00:00.000000000 Z
+date: 2026-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bluecloth
@@ -97,6 +97,7 @@ files:
 - Gemfile
 - LICENSE
 - README.md
+- RELEASE.md
 - Rakefile
 - changelog.md
 - hashdiff.gemspec