iron_admin 0.5.0 → 0.6.0

data/vendor/bundle/ruby/3.2.0/gems/hashdiff-1.2.1/README.md

@@ -0,0 +1,323 @@
+# Hashdiff [![Build Status](https://github.com/liufengyun/hashdiff/workflows/ci/badge.svg)](https://github.com/liufengyun/hashdiff/actions?query=workflow%3Aci) [![Gem Version](https://badge.fury.io/rb/hashdiff.svg)](http://badge.fury.io/rb/hashdiff)
+
+Hashdiff is a ruby library to compute the smallest difference between two hashes.
+
+It also supports comparing two arrays.
+
+Hashdiff does not monkey-patch any existing class. All features are contained inside the `Hashdiff` module.
+
+**Docs**: [Documentation](http://rubydoc.info/gems/hashdiff)
+
+
+__WARNING__: Don't use the library for comparing large arrays, say ~10K (see #49).
+
+## Why Hashdiff?
+
+Given two Hashes A and B, sometimes you face the question: what's the smallest modification that can be made to change A into B?
+
+An algorithm that responds to this question has to do following:
+
+* Generate a list of additions, deletions and changes, so that `A + ChangeSet = B` and `B - ChangeSet = A`.
+* Compute recursively -- Arrays and Hashes may be nested arbitrarily in A or B.
+* Compute the smallest change -- it should recognize similar child Hashes or child Arrays between A and B.
+
+Hashdiff answers the question above using an opinionated approach:
+
+* Hash can be represented as a list of (dot-syntax-path, value) pairs. For example, `{a:[{c:2}]}` can be represented as `["a[0].c", 2]`.
+* The change set can be represented using the dot-syntax representation. For example, `[['-', 'b.x', 3], ['~', 'b.z', 45, 30], ['+', 'b.y', 3]]`.
+* It compares Arrays using the [LCS(longest common subsequence)](http://en.wikipedia.org/wiki/Longest_common_subsequence_problem) algorithm.
+* It recognizes similar Hashes in an Array using a similarity value (0 < similarity <= 1).
+
+## Usage
+
+To use the gem, add the following to your Gemfile:
+
+```Ruby
+gem 'hashdiff'
+```
+
+## Quick Start
+
+### Diff
+
+Two simple hashes:
+
+```ruby
+a = {a:3, b:2}
+b = {}
+
+diff = Hashdiff.diff(a, b)
+diff.should == [['-', 'a', 3], ['-', 'b', 2]]
+```
+
+More complex hashes:
+
+```ruby
+a = {a:{x:2, y:3, z:4}, b:{x:3, z:45}}
+b = {a:{y:3}, b:{y:3, z:30}}
+
+diff = Hashdiff.diff(a, b)
+diff.should == [['-', 'a.x', 2], ['-', 'a.z', 4], ['-', 'b.x', 3], ['~', 'b.z', 45, 30], ['+', 'b.y', 3]]
+```
+
+Arrays in hashes:
+
+```ruby
+a = {a:[{x:2, y:3, z:4}, {x:11, y:22, z:33}], b:{x:3, z:45}}
+b = {a:[{y:3}, {x:11, z:33}], b:{y:22}}
+
+diff = Hashdiff.best_diff(a, b)
+diff.should == [['-', 'a[0].x', 2], ['-', 'a[0].z', 4], ['-', 'a[1].y', 22], ['-', 'b.x', 3], ['-', 'b.z', 45], ['+', 'b.y', 22]]
+```
+
+### Patch
+
+patch example:
+
+```ruby
+a = {'a' => 3}
+b = {'a' => {'a1' => 1, 'a2' => 2}}
+
+diff = Hashdiff.diff(a, b)
+Hashdiff.patch!(a, diff).should == b
+```
+
+unpatch example:
+
+```ruby
+a = [{'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5}, {'x' => 5, 'y' => 6, 'z' => 3}, 1]
+b = [1, {'a' => 1, 'b' => 2, 'c' => 3, 'e' => 5}]
+
+diff = Hashdiff.diff(a, b) # diff two array is OK
+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`, 
+`:use_lcs`, and `:preserve_key_order`
+
+#### `:delimiter`
+
+You can specify `:delimiter` to be something other than the default dot. For example:
+
+```ruby
+a = {a:{x:2, y:3, z:4}, b:{x:3, z:45}}
+b = {a:{y:3}, b:{y:3, z:30}}
+
+diff = Hashdiff.diff(a, b, delimiter: '\t')
+diff.should == [['-', 'a\tx', 2], ['-', 'a\tz', 4], ['-', 'b\tx', 3], ['~', 'b\tz', 45, 30], ['+', 'b\ty', 3]]
+```
+
+#### `:similarity`
+
+In cases where you have similar hash objects in arrays, you can pass a custom value for `:similarity` instead of the default `0.8`.  This is interpreted as a ratio of similarity (default is 80% similar, whereas `:similarity => 0.5` would look for at least a 50% similarity).
+
+#### `:strict`
+
+The `:strict` option, which defaults to `true`, specifies whether numeric types are compared on type as well as value.  By default, an Integer will never be equal to a Float (e.g. 4 != 4.0).  Setting `:strict` to false makes the comparison looser (e.g. 4 == 4.0).
+
+#### `:ignore_keys`
+
+The `:ignore_keys` option allows you to specify one or more keys to ignore, which defaults to `[]` (none). Ignored keys are ignored at all levels in both hashes. For example:
+
+```ruby
+a = { a: 4, g: 0, b: { a: 5, c: 6, e: 1 }       }
+b = {             b: { a: 7, c: 3, f: 1 }, d: 8 }
+diff = Hashdiff.diff(a, b, ignore_keys: %i[a f])
+diff.should == [['-', 'g', 0], ['-', 'b.e', 1], ['~', 'b.c', 6, 3], ['+', 'd', 8]]
+```
+If you wish instead to ignore keys at a particlar level you should
+use a [custom comparison method](https://github.com/liufengyun/hashdiff#specifying-a-custom-comparison-method) instead. For example to diff only at the 2nd level of both hashes:
+
+```ruby
+a = { a: 4, g: 0, b: { a: 5, c: 6, e: 1 }       }
+b = {             b: { a: 7, c: 3, f: 1 }, d: 8 }
+diff = Hashdiff.diff(a, b) do |path, _e, _a|
+  arr = path.split('.')
+  true if %w[a f].include?(arr.last) && arr.size == 2 # note '.' is the default delimiter
+end
+diff.should == [['-', 'a', 4], ['-', 'g', 0], ['-', 'b.e', 1], ['~', 'b.c', 6, 3], ['+', 'd', 8]]
+```
+
+#### `:indifferent`
+
+The `:indifferent` option, which defaults to `false`, specifies whether to treat hash keys indifferently.  Setting `:indifferent` to true has the effect of ignoring differences between symbol keys (ie. {a: 1} ~= {'a' => 1})
+
+#### `:numeric_tolerance`
+
+The :numeric_tolerance option allows for a small numeric tolerance.
+
+```ruby
+a = {x:5, y:3.75, z:7}
+b = {x:6, y:3.76, z:7}
+
+diff = Hashdiff.diff(a, b, numeric_tolerance: 0.1)
+diff.should == [["~", "x", 5, 6]]
+```
+
+#### `:strip`
+
+The :strip option strips all strings before comparing.
+
+```ruby
+a = {x:5, s:'foo '}
+b = {x:6, s:'foo'}
+
+diff = Hashdiff.diff(a, b, numeric_tolerance: 0.1, strip: true)
+diff.should == [["~", "x", 5, 6]]
+```
+
+#### `:case_insensitive`
+
+The :case_insensitive option makes string comparisons ignore case.
+
+```ruby
+a = {x:5, s:'FooBar'}
+b = {x:6, s:'foobar'}
+
+diff = Hashdiff.diff(a, b, numeric_tolerance: 0.1, case_insensitive: true)
+diff.should == [["~", "x", 5, 6]]
+```
+
+#### `:array_path`
+
+The :array_path option represents the path of the diff in an array rather than
+a string. This can be used to show differences in between hash key types and
+is useful for `patch!` when used on hashes without string keys.
+
+```ruby
+a = {x:5}
+b = {'x'=>6}
+
+diff = Hashdiff.diff(a, b, array_path: true)
+diff.should == [['-', [:x], 5], ['+', ['x'], 6]]
+```
+
+For cases where there are arrays in paths their index will be added to the path.
+```ruby
+a = {x:[0,1]}
+b = {x:[0,2]}
+
+diff = Hashdiff.diff(a, b, array_path: true)
+diff.should == [["-", [:x, 1], 1], ["+", [:x, 1], 2]]
+```
+
+This shouldn't cause problems if you are comparing an array with a hash:
+
+```ruby
+a = {x:{0=>1}}
+b = {x:[1]}
+
+diff = Hashdiff.diff(a, b, array_path: true)
+diff.should == [["~", [:x], {0=>1}, [1]]]
+```
+
+#### `:use_lcs`
+
+The :use_lcs option is used to specify whether a
+[Longest common subsequence](https://en.wikipedia.org/wiki/Longest_common_subsequence_problem)
+(LCS) algorithm is used to determine differences in arrays. This defaults to
+`true` but can be changed to `false` for significantly faster array comparisons
+(O(n) complexity rather than O(n<sup>2</sup>) for LCS).
+
+When :use_lcs is false the results of array comparisons have a tendency to
+show changes at indexes rather than additions and subtractions when :use_lcs is
+true.
+
+Note, currently the :similarity option has no effect when :use_lcs is false.
+
+```ruby
+a = {x: [0, 1, 2]}
+b = {x: [0, 2, 2, 3]}
+
+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.
+
+```ruby
+a = {a:'car', b:'boat', c:'plane'}
+b = {a:'bus', b:'truck', c:' plan'}
+
+diff = Hashdiff.diff(a, b) do |path, obj1, obj2|
+  case path
+  when  /a|b|c/
+    obj1.length == obj2.length
+  end
+end
+
+diff.should == [['~', 'b', 'boat', 'truck']]
+```
+
+The yielded params of the comparison block is `|path, obj1, obj2|`, in which path is the key (or delimited compound key) to the value being compared. When comparing elements in array, the path is with the format `array[*]`. For example:
+
+```ruby
+a = {a:'car', b:['boat', 'plane'] }
+b = {a:'bus', b:['truck', ' plan'] }
+
+diff = Hashdiff.diff(a, b) do |path, obj1, obj2|
+  case path
+  when 'b[*]'
+    obj1.length == obj2.length
+  end
+end
+
+diff.should == [["~", "a", "car", "bus"], ["~", "b[1]", "plane", " plan"], ["-", "b[0]", "boat"], ["+", "b[0]", "truck"]]
+```
+
+When a comparison block is given, it'll be given priority over other specified options. If the block returns value other than `true` or `false`, then the two values will be compared with other specified options.
+
+When used in conjunction with the `array_path` option, the path passed in as an argument will be an array. When determining the ordering of an array a key of `"*"` will be used in place of the `key[*]` field. It is possible, if you have hashes with integer or `"*"` keys, to have problems distinguishing between arrays and hashes - although this shouldn't be an issue unless your data is very difficult to predict and/or your custom rules are very specific.
+
+#### Sorting arrays before comparison
+
+An order difference alone between two arrays can create too many diffs to be useful. Consider sorting them prior to diffing.
+
+```ruby
+a = {a:'car', b:['boat', 'plane'] }
+b = {a:'car', b:['plane', 'boat'] }
+
+Hashdiff.diff(a, b).should == [["+", "b[0]", "plane"], ["-", "b[2]", "plane"]]
+
+b[:b].sort!
+
+Hashdiff.diff(a, b).should == []
+```
+
+## Maintainers
+
+- Krzysztof Rybka ([@krzysiek1507](https://github.com/krzysiek1507))
+- Fengyun Liu ([@liufengyun](https://github.com/liufengyun))
+
+## License
+
+Hashdiff is distributed under the MIT-LICENSE.

data/vendor/bundle/ruby/3.2.0/gems/hashdiff-1.2.1/Rakefile

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path('lib', __dir__)
+
+require 'rubocop/rake_task'
+
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+
+RuboCop::RakeTask.new
+
+task default: %w[spec rubocop]
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = './spec/**/*_spec.rb'
+end

data/vendor/bundle/ruby/3.2.0/gems/hashdiff-1.2.1/changelog.md

@@ -0,0 +1,127 @@
+# Change Log
+
+## 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))
+
+## v1.2.0 2025-5-20
+
+* Added :preserve_key_order option to maintain original hash key order [#99](https://github.com/liufengyun/hashdiff/issues/99) ([@robkiessling](https://github.com/robkiessling))
+
+## v1.1.2 2024-11-12
+
+* Fix bundler cache [#96](https://github.com/liufengyun/hashdiff/issues/96) ([@olleolleolle](https://github.com/olleolleolle))
+* Quote the '3.0' in YAML [#95](https://github.com/liufengyun/hashdiff/issues/95) ([@olleolleolle](https://github.com/olleolleolle))
+* Fix version in source code [#97](https://github.com/liufengyun/hashdiff/issues/97) ([@liufengyun](https://github.com/liufengyun))
+
+## v1.1.1 2024-08-02
+
+* Fix bug in ignore_keys option [#88](https://github.com/liufengyun/hashdiff/issues/88) ([@Matzfan](https://github.com/Matzfan))
+* Exclude spec files from gem package [#94](https://github.com/liufengyun/hashdiff/issues/94) ([@amatsuda](https://github.com/amatsuda))
+
+## v1.1.0 2023-12-14
+
+* Add ignore_keys option ([#86](https://github.com/liufengyun/hashdiff/issues/86) [@Matzfan](https://github.com/Matzfan))
+* Remove pinned version of rake < 11
+* Bump rspec dep ~> 3.5
+* Bump rubocop dep >= 1.52.1
+* Bump rubocop-rspec dep > 1.16.0
+
+## v1.0.1 2020-02-25
+
+* Add indifferent option
+
+## v1.0.0 2019-06-06
+
+* Fix typo in readme ([#72](https://github.com/liufengyun/hashdiff/issues/72) [@koic](https://github.com/koic))
+* Fix Rubocop offence ([#73](https://github.com/liufengyun/hashdiff/issues/73) [@koic](https://github.com/koic))
+* Bumps version to v1.0.0 ([#74](https://github.com/liufengyun/hashdiff/issues/74) [@jfelchner](https://github.com/jfelchner))
+
+## v1.0.0.beta1 2019-06-06
+
+* fix warnings in ci ([#69](https://github.com/liufengyun/hashdiff/issues/69) [@y-yagi](https://github.com/y-yagi))
+* drop warnings of the constant change ([#70](https://github.com/liufengyun/hashdiff/issues/70) [@jfelchner](https://github.com/jfelchner))
+
+## v0.4.0 2019-05-28
+
+* refactoring ([#56](https://github.com/liufengyun/hashdiff/issues/56) [#57](https://github.com/liufengyun/hashdiff/issues/57) [#59](https://github.com/liufengyun/hashdiff/issues/59) [#61](https://github.com/liufengyun/hashdiff/issues/61) [@krzysiek1507](https://github.com/krzysiek1507))
+* fix typo in README ([#64](https://github.com/liufengyun/hashdiff/issues/64) [@pboling](https://github.com/pboling))
+* change HashDiff to Hashdiff ([#65](https://github.com/liufengyun/hashdiff/issues/65) [@jfelchner](https://github.com/jfelchner))
+
+## v0.3.9 2019-04-22
+
+* Performance tweak (thanks [@krzysiek1507](https://github.com/krzysiek1507): [#51](https://github.com/liufengyun/hashdiff/issues/51) [#52](https://github.com/liufengyun/hashdiff/issues/52) [#53](https://github.com/liufengyun/hashdiff/issues/53))
+
+## v0.3.8 2018-12-30
+
+* Add Rubocop and drops Ruby 1.9 support [#47](https://github.com/liufengyun/hashdiff/issues/47)
+
+## v0.3.7 2017-10-08
+
+* remove 1.8.7 support from gemspec [#39](https://github.com/liufengyun/hashdiff/issues/39)
+
+## v0.3.6 2017-08-22
+
+* add option `use_lcs` [#35](https://github.com/liufengyun/hashdiff/issues/35)
+
+## v0.3.5 2017-08-06
+
+* add option `array_path` [#34](https://github.com/liufengyun/hashdiff/issues/34)
+
+## v0.3.4 2017-05-01
+
+* performance improvement of `#similar?` [#31](https://github.com/liufengyun/hashdiff/issues/31)
+
+## v0.3.2 2016-12-27
+
+* replace `Fixnum` by `Integer` [#28](https://github.com/liufengyun/hashdiff/issues/28)
+
+## v0.3.1 2016-11-24
+
+* fix an error when a hash has mixed types [#26](https://github.com/liufengyun/hashdiff/issues/26)
+
+## v0.3.0 2016-2-11
+
+* support `:case_insensitive` option
+
+## v0.2.3 2015-11-5
+
+* improve performance of LCS algorithm [#12](https://github.com/liufengyun/hashdiff/issues/12)
+
+## v0.2.2 2014-10-6
+
+* make library 1.8.7 compatible
+
+## v0.2.1 2014-7-13
+
+* yield added/deleted keys for custom comparison
+
+## v0.2.0 2014-3-29
+
+* support custom comparison blocks
+* support `:strip`, `:numeric_tolerance` and `:strict` options
+
+## v0.1.0 2013-8-25
+
+* use options for parameters `:delimiter` and `:similarity` in interfaces
+
+## v0.0.6 2013-3-2
+
+* Add parameter for custom property-path delimiter.
+
+## v0.0.5 2012-7-1
+
+* fix a bug in judging whehter two objects are similiar.
+* add more spec test for `.best_diff`
+
+## v0.0.4 2012-6-24
+
+Main changes in this version is to output the whole object in addition & deletion, instead of recursely add/deletes the object.
+
+For example, `diff({a:2, c:[4, 5]}, {a:2}) will generate following output:
+
+    [['-', 'c', [4, 5]]]
+
+instead of following:
+
+    [['-', 'c[0]', 4], ['-', 'c[1]', 5], ['-', 'c', []]]

data/vendor/bundle/ruby/3.2.0/gems/hashdiff-1.2.1/hashdiff.gemspec

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+$LOAD_PATH << File.expand_path('lib', __dir__)
+require 'hashdiff/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'hashdiff'
+  s.version     = Hashdiff::VERSION
+  s.license     = 'MIT'
+  s.summary     = ' Hashdiff is a diff lib to compute the smallest difference between two hashes. '
+  s.description = ' Hashdiff is a diff lib to compute the smallest difference between two hashes. '
+
+  s.files         = `git ls-files`.split("\n").grep_v(%r{^spec/})
+  s.test_files    = `git ls-files -- Appraisals {spec}/*`.split("\n")
+
+  s.require_paths = ['lib']
+  s.required_ruby_version = Gem::Requirement.new('>= 2.0.0')
+
+  s.authors = ['Liu Fengyun']
+  s.email   = ['liufengyunchina@gmail.com']
+
+  s.homepage = 'https://github.com/liufengyun/hashdiff'
+
+  s.add_development_dependency('bluecloth')
+  s.add_development_dependency('rspec', '~> 3.5')
+  s.add_development_dependency('rubocop', '>= 1.52.1') # earliest version that works with Ruby 3.3
+  s.add_development_dependency('rubocop-rspec', '> 1.16.0') # https://github.com/rubocop/rubocop-rspec/issues/461
+  s.add_development_dependency('yard')
+
+  if s.respond_to?(:metadata)
+    s.metadata = {
+      'bug_tracker_uri' => 'https://github.com/liufengyun/hashdiff/issues',
+      'changelog_uri' => 'https://github.com/liufengyun/hashdiff/blob/master/changelog.md',
+      'documentation_uri' => 'https://www.rubydoc.info/gems/hashdiff',
+      'homepage_uri' => 'https://github.com/liufengyun/hashdiff',
+      'source_code_uri' => 'https://github.com/liufengyun/hashdiff'
+    }
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/hashdiff-1.2.1/lib/hashdiff/compare_hashes.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Hashdiff
+  # @private
+  # Used to compare hashes
+  class CompareHashes
+    class << self
+      def call(obj1, obj2, opts = {})
+        return [] if obj1.empty? && obj2.empty?
+
+        obj1_keys = obj1.keys
+        obj2_keys = obj2.keys
+        obj1_lookup = {}
+        obj2_lookup = {}
+
+        if opts[:indifferent]
+          obj1_lookup = obj1_keys.each_with_object({}) { |k, h| h[k.to_s] = k }
+          obj2_lookup = obj2_keys.each_with_object({}) { |k, h| h[k.to_s] = k }
+          obj1_keys = obj1_keys.map { |k| k.is_a?(Symbol) ? k.to_s : k }
+          obj2_keys = obj2_keys.map { |k| k.is_a?(Symbol) ? k.to_s : k }
+        end
+
+        added_keys = obj2_keys - obj1_keys
+        common_keys = obj1_keys & obj2_keys
+        deleted_keys = obj1_keys - obj2_keys
+
+        result = []
+
+        opts[:ignore_keys].each do |k|
+          added_keys.delete k
+          common_keys.delete k
+          deleted_keys.delete k
+        end
+
+        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
+          when :common
+            # recursive comparison for common keys
+            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)
+
+            k = opts[:indifferent] ? obj2_lookup[k] : k
+            custom_result = Hashdiff.custom_compare(opts[:comparison], change_key, nil, obj2[k])
+
+            if custom_result
+              result.concat(custom_result)
+            else
+              result << ['+', change_key, obj2[k]]
+            end
+          else
+            raise "Invalid type: #{type}"
+          end
+        end
+
+        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 }
+
+          # 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
+      end
+    end
+  end
+end