hashdiff 1.1.2 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 113e55eeac757365f792e7e2554a8fbb5f16c06cfcf83d4dcf7db268637ef47e
-  data.tar.gz: ae222f4980bff17fa8f9fecef25cb1fa54db61503c075cc49b3ef755927ec5f1
+  metadata.gz: 4752d45ff706f5b763bb7bc2b6b6c4302657caad5e45fce2d02730d962ef3d31
+  data.tar.gz: 5d9ff9c909184d3bbd798a3dbc8ea82d1c2752450c0c04671755aaa0d8d34c25
 SHA512:
-  metadata.gz: 7476c18bd05f2e5c57da5b15d9bd938bbfd5fa330825b21be8d867fded3b404d6ae3405acca5f235397f816b866aede13425e0ab314ee71497bfa54010ab6e82
-  data.tar.gz: ce5d8d3ea4e8bca768688aa782e21bab01ae4a5ae8cd0b8f5b11927abc5c5163da3dc2a1135a069ad139998654471d11359b48e2a2eeb1d87f17bc461813745f
+  metadata.gz: 6ee25347a9b92ec1ff0849c319221101d2a53c0194586227395d79ced3d7d4172a3a3448ca197886ae175dcc2ab5f681d13790f4a75d69b3c31cec8150c82779
+  data.tar.gz: 0da5f54d158ad5dbe806bd0c25279554c6e47d22faff4334ae427351ff00cca338ea490fb96246611cde5b505d9970b9216b8d6de5960a0532a349f738e0ed52

data/.github/workflows/ci.yml

@@ -11,7 +11,7 @@ jobs:
       matrix:
         ruby:
           - 2.7
-          - 3.0
+          - '3.0'
           - 3.1
           - 3.2
           - 3.3
@@ -22,7 +22,6 @@ jobs:
         uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.ruby }}
-      - name: Install dependencies
-        run: bundle install --jobs $(nproc) --retry 3
+          bundler-cache: true # 'bundle install' and cache gems
       - name: Run rake
         run: bundle exec rake

data/README.md

@@ -95,7 +95,8 @@ Hashdiff.unpatch!(b, diff).should == a
 ### Options
 
 The following options are available: `:delimiter`, `:similarity`, `:strict`, `:ignore_keys`,
-`:indifferent`, `:numeric_tolerance`, `:strip`, `:case_insensitive`, `:array_path` and `:use_lcs`
+`:indifferent`, `:numeric_tolerance`, `:strip`, `:case_insensitive`, `:array_path`, 
+`:use_lcs`, and `:preserve_key_order`
 
 #### `:delimiter`
 
@@ -235,6 +236,30 @@ diff = Hashdiff.diff(a, b, use_lcs: false)
 diff.should == [["~", "x[1]", 1, 2], ["+", "x[3]", 3]]
 ```
 
+#### `:preserve_key_order`
+
+By default, the change set is ordered by operation type: deletions (-) first, then updates (~), and finally additions (+). 
+Within each operation group, keys are sorted alphabetically:
+
+```ruby
+a = {d: 1, c: 1,       a: 1}
+b = {d: 2,       b: 2, a: 2}
+
+diff = Hashdiff.diff(a, b)
+diff.should == [["-", "c", 1], ["~", "a", 1, 2], ["~", "d", 1, 2], ["+", "b", 2]]
+```
+
+Setting :preserve_key_order to true processes keys in the order they appear in the first hash.
+Keys that only exist in the second hash are appended in their original order:
+
+```ruby
+a = {d: 1, c: 1,       a: 1}
+b = {d: 2,       b: 2, a: 2}
+
+diff = Hashdiff.diff(a, b, preserve_key_order: true)
+diff.should == [["~", "d", 1, 2], ["-", "c", 1], ["~", "a", 1, 2], ["+", "b", 2]]
+```
+
 #### Specifying a custom comparison method
 
 It's possible to specify how the values of a key should be compared.

data/changelog.md

@@ -1,5 +1,9 @@
 # Change Log
 
+## v1.2.0 2025-5-20
+
+* Added :preserve_key_order option to maintain original hash key order #99 (@robkiessling)
+
 ## v1.1.2 2024-11-12
 
 * Fix bundler cache #96 (@olleolleolle)

data/lib/hashdiff/compare_hashes.rb

@@ -20,9 +20,9 @@ module Hashdiff
           obj2_keys = obj2_keys.map { |k| k.is_a?(Symbol) ? k.to_s : k }
         end
 
-        added_keys = (obj2_keys - obj1_keys).sort_by(&:to_s)
-        common_keys = (obj1_keys & obj2_keys).sort_by(&:to_s)
-        deleted_keys = (obj1_keys - obj2_keys).sort_by(&:to_s)
+        added_keys = obj2_keys - obj1_keys
+        common_keys = obj1_keys & obj2_keys
+        deleted_keys = obj1_keys - obj2_keys
 
         result = []
 
@@ -32,40 +32,66 @@ module Hashdiff
           deleted_keys.delete k
         end
 
-        # add deleted properties
-        deleted_keys.each do |k|
-          k = opts[:indifferent] ? obj1_lookup[k] : k
-          change_key = Hashdiff.prefix_append_key(opts[:prefix], k, opts)
-          custom_result = Hashdiff.custom_compare(opts[:comparison], change_key, obj1[k], nil)
+        handle_key = lambda do |k, type|
+          case type
+          when :deleted
+            # add deleted properties
+            k = opts[:indifferent] ? obj1_lookup[k] : k
+            change_key = Hashdiff.prefix_append_key(opts[:prefix], k, opts)
+            custom_result = Hashdiff.custom_compare(opts[:comparison], change_key, obj1[k], nil)
 
-          if custom_result
-            result.concat(custom_result)
-          else
-            result << ['-', change_key, obj1[k]]
-          end
-        end
+            if custom_result
+              result.concat(custom_result)
+            else
+              result << ['-', change_key, obj1[k]]
+            end
+          when :common
+            # recursive comparison for common keys
+            prefix = Hashdiff.prefix_append_key(opts[:prefix], k, opts)
 
-        # recursive comparison for common keys
-        common_keys.each do |k|
-          prefix = Hashdiff.prefix_append_key(opts[:prefix], k, opts)
+            k1 = opts[:indifferent] ? obj1_lookup[k] : k
+            k2 = opts[:indifferent] ? obj2_lookup[k] : k
+            result.concat(Hashdiff.diff(obj1[k1], obj2[k2], opts.merge(prefix: prefix)))
+          when :added
+            # added properties
+            change_key = Hashdiff.prefix_append_key(opts[:prefix], k, opts)
 
-          k1 = opts[:indifferent] ? obj1_lookup[k] : k
-          k2 = opts[:indifferent] ? obj2_lookup[k] : k
-          result.concat(Hashdiff.diff(obj1[k1], obj2[k2], opts.merge(prefix: prefix)))
-        end
+            k = opts[:indifferent] ? obj2_lookup[k] : k
+            custom_result = Hashdiff.custom_compare(opts[:comparison], change_key, nil, obj2[k])
 
-        # added properties
-        added_keys.each do |k|
-          change_key = Hashdiff.prefix_append_key(opts[:prefix], k, opts)
+            if custom_result
+              result.concat(custom_result)
+            else
+              result << ['+', change_key, obj2[k]]
+            end
+          else
+            raise "Invalid type: #{type}"
+          end
+        end
 
-          k = opts[:indifferent] ? obj2_lookup[k] : k
-          custom_result = Hashdiff.custom_compare(opts[:comparison], change_key, nil, obj2[k])
+        if opts[:preserve_key_order]
+          # Building lookups to speed up key classification
+          added_keys_lookup = added_keys.each_with_object({}) { |k, h| h[k] = true }
+          common_keys_lookup = common_keys.each_with_object({}) { |k, h| h[k] = true }
+          deleted_keys_lookup = deleted_keys.each_with_object({}) { |k, h| h[k] = true }
 
-          if custom_result
-            result.concat(custom_result)
-          else
-            result << ['+', change_key, obj2[k]]
+          # Iterate through all keys, preserving obj1's key order and appending any new keys from obj2. Shared keys
+          # (found in both obj1 and obj2) follow obj1's order since uniq only keeps the first occurrence.
+          (obj1_keys + obj2_keys).uniq.each do |k|
+            if added_keys_lookup[k]
+              handle_key.call(k, :added)
+            elsif common_keys_lookup[k]
+              handle_key.call(k, :common)
+            elsif deleted_keys_lookup[k]
+              handle_key.call(k, :deleted)
+            end
           end
+        else
+          # Keys are first grouped by operation type (deletions first, then changes, then additions), and then sorted
+          # alphabetically within each group.
+          deleted_keys.sort_by(&:to_s).each { |k| handle_key.call(k, :deleted) }
+          common_keys.sort_by(&:to_s).each { |k| handle_key.call(k, :common) }
+          added_keys.sort_by(&:to_s).each { |k| handle_key.call(k, :added) }
         end
 
         result

data/lib/hashdiff/diff.rb

@@ -16,6 +16,7 @@ module Hashdiff
   #   * :strip (Boolean) [false] whether or not to call #strip on strings before comparing
   #   * :array_path (Boolean) [false] whether to return the path references for nested values in an array, can be used for patch compatibility with non string keys.
   #   * :use_lcs (Boolean) [true] whether or not to use an implementation of the Longest common subsequence algorithm for comparing arrays, produces better diffs but is slower.
+  #   * :preserve_key_order (Boolean) [false] If false, operations are grouped by type (-, ~, then +) then by hash key alphabetically. If true, preserves the original key order from the first hash and appends new keys from the second hash in order.
   #
   # @yield [path, value1, value2] Optional block is used to compare each value, instead of default #==. If the block returns value other than true of false, then other specified comparison options will be used to do the comparison.
   #
@@ -62,6 +63,7 @@ module Hashdiff
   #   * :strip (Boolean) [false] whether or not to call #strip on strings before comparing
   #   * :array_path (Boolean) [false] whether to return the path references for nested values in an array, can be used for patch compatibility with non string keys.
   #   * :use_lcs (Boolean) [true] whether or not to use an implementation of the Longest common subsequence algorithm for comparing arrays, produces better diffs but is slower.
+  #   * :preserve_key_order (Boolean) [false] If false, operations are grouped by type (-, ~, then +) then by hash key alphabetically. If true, preserves the original key order from the first hash and appends new keys from the second hash in order.
   #
   #
   # @yield [path, value1, value2] Optional block is used to compare each value, instead of default #==. If the block returns value other than true of false, then other specified comparison options will be used to do the comparison.
@@ -88,7 +90,8 @@ module Hashdiff
       strip: false,
       numeric_tolerance: 0,
       array_path: false,
-      use_lcs: true
+      use_lcs: true,
+      preserve_key_order: false
     }.merge!(options)
 
     opts[:prefix] = [] if opts[:array_path] && opts[:prefix] == ''

data/lib/hashdiff/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hashdiff
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.2.0
 platform: ruby
 authors:
 - Liu Fengyun
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-11-12 00:00:00.000000000 Z
+date: 2025-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bluecloth