acfs 2.0.0 → 2.2.1

data/vendor/bundle/ruby/4.0.0/gems/docile-1.4.1/README.md

@@ -0,0 +1,409 @@
+# Docile
+
+[![Gem Version](https://img.shields.io/gem/v/docile.svg)](https://rubygems.org/gems/docile)
+[![Gem Downloads](https://img.shields.io/gem/dt/docile.svg)](https://rubygems.org/gems/docile)
+
+[![Join the chat at https://gitter.im/ms-ati/docile](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/ms-ati/docile?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![Yard Docs](http://img.shields.io/badge/yard-docs-blue.svg)](http://rubydoc.info/github/ms-ati/docile)
+
+[![Build Status](https://github.com/ms-ati/docile/actions/workflows/main.yml/badge.svg)](https://github.com/ms-ati/docile/actions/workflows/main.yml)
+[![Code Coverage](https://img.shields.io/codecov/c/github/ms-ati/docile.svg)](https://codecov.io/github/ms-ati/docile)
+[![Maintainability](https://api.codeclimate.com/v1/badges/79ca631bc123f7b83b34/maintainability)](https://codeclimate.com/github/ms-ati/docile/maintainability)
+
+Ruby makes it possible to create very expressive **Domain Specific
+Languages**, or **DSL**'s for short. However, it requires some deep knowledge and
+somewhat hairy meta-programming to get the interface just right.
+
+"Docile" means *Ready to accept control or instruction; submissive* [[1]]
+
+Instead of each Ruby project reinventing this wheel, let's make our Ruby DSL
+coding a bit more docile...
+
+[1]: http://www.google.com/search?q=docile+definition   "Google"
+
+## Usage
+
+### Basic: Ruby [Array](http://ruby-doc.org/core-3.0.0/Array.html) as DSL
+
+Let's say that we want to make a DSL for modifying Array objects.
+Wouldn't it be great if we could just treat the methods of Array as a DSL?
+
+```ruby
+with_array([]) do
+  push 1
+  push 2
+  pop
+  push 3
+end
+#=> [1, 3]
+```
+
+No problem, just define the method `with_array` like this:
+
+```ruby
+def with_array(arr=[], &block)
+  Docile.dsl_eval(arr, &block)
+end
+```
+
+Easy!
+
+### Next step: Allow helper methods to call DSL methods
+
+What if, in our use of the methods of Array as a DSL, we want to extract
+helper methods which in turn call DSL methods?
+
+```ruby
+def pop_sum_and_push(n)
+  sum = 0
+  n.times { sum += pop }
+  push sum
+end
+
+Docile.dsl_eval([]) do
+  push 5
+  push 6
+  pop_sum_and_push(2)
+end
+#=> [11]
+```
+
+Without Docile, you may find this sort of code extraction to be more
+challenging.
+
+### Wait! Can't I do that with just `instance_eval` or `instance_exec`?
+
+Good question!
+
+In short: **No**. 
+
+Not if you want the code in the block to be able to refer to anything
+the block would normally have access to from the surrounding context.
+
+Let's be very specific. Docile internally uses `instance_exec` (see [execution.rb#26](lib/docile/execution.rb#L26)), adding a small layer to support referencing *local variables*, *instance variables*, and *methods* from the _block's context_ **or** the target _object's context_, interchangeably. This is "**the hard part**", where most folks making a DSL in Ruby throw up their hands.
+
+For example:
+
+```ruby
+class ContextOfBlock
+  def example_of_contexts
+    @block_instance_var = 1
+    block_local_var = 2
+
+    with_array do
+      push @block_instance_var
+      push block_local_var
+      pop
+      push block_sees_this_method 
+    end
+  end
+  
+  def block_sees_this_method
+    3
+  end  
+
+  def with_array(&block)
+    {
+      docile: Docile.dsl_eval([], &block),
+      instance_eval: ([].instance_eval(&block) rescue $!),
+      instance_exec: ([].instance_exec(&block) rescue $!)
+    }  
+  end
+end
+
+ContextOfBlock.new.example_of_contexts
+#=> {
+      :docile=>[1, 3],
+      :instance_eval=>#<NameError: undefined local variable or method `block_sees_this_method' for [nil]:Array>,
+      :instance_exec=>#<NameError: undefined local variable or method `block_sees_this_method' for [nil]:Array>
+    }
+```
+
+As you can see, it won't be possible to call methods or access instance variables defined in the block's context using just the raw `instance_eval` or `instance_exec` methods. And in fact, Docile goes further, making it easy to maintain this support even in multi-layered DSLs.
+
+### Build a Pizza
+
+Mutating (changing) an Array instance is fine, but what usually makes a good DSL is a [Builder Pattern][2].
+
+For example, let's say you want a DSL to specify how you want to build a Pizza:
+
+```ruby
+@sauce_level = :extra
+
+pizza do
+  cheese
+  pepperoni
+  sauce @sauce_level
+end
+#=> #<Pizza:0x00001009dc398 @cheese=true, @pepperoni=true, @bacon=false, @sauce=:extra>
+```
+
+And let's say we have a PizzaBuilder, which builds a Pizza like this:
+
+```ruby
+Pizza = Struct.new(:cheese, :pepperoni, :bacon, :sauce)
+
+class PizzaBuilder
+  def cheese(v=true); @cheese = v; self; end
+  def pepperoni(v=true); @pepperoni = v; self; end
+  def bacon(v=true); @bacon = v; self; end
+  def sauce(v=nil); @sauce = v; self; end
+  def build
+    Pizza.new(!!@cheese, !!@pepperoni, !!@bacon, @sauce)
+  end
+end
+
+PizzaBuilder.new.cheese.pepperoni.sauce(:extra).build
+#=> #<Pizza:0x00001009dc398 @cheese=true, @pepperoni=true, @bacon=false, @sauce=:extra>
+```
+
+Then implement your DSL like this:
+
+```ruby
+def pizza(&block)
+  Docile.dsl_eval(PizzaBuilder.new, &block).build
+end
+```
+
+It's just that easy!
+
+[2]: http://stackoverflow.com/questions/328496/when-would-you-use-the-builder-pattern  "Builder Pattern"
+
+### Multi-level and Recursive DSLs
+
+Docile is a very easy way to write a multi-level DSL in Ruby, even for
+a [recursive data structure such as a tree][4]:
+
+```ruby
+Person = Struct.new(:name, :mother, :father)
+
+person {
+  name 'John Smith'
+  mother {
+    name 'Mary Smith'
+  }
+  father {
+    name 'Tom Smith'
+    mother {
+      name 'Jane Smith'
+    }
+  }
+}
+
+#=> #<struct Person name="John Smith",
+#                   mother=#<struct Person name="Mary Smith", mother=nil, father=nil>,
+#                   father=#<struct Person name="Tom Smith",
+#                                          mother=#<struct Person name="Jane Smith", mother=nil, father=nil>,
+#                                          father=nil>>
+```
+
+See the full [person tree example][4] for details.
+
+[4]: https://gist.github.com/ms-ati/2bb17bdf10a430faba98
+
+### Block parameters
+
+Parameters can be passed to the DSL block.
+
+Supposing you want to make some sort of cheap [Sinatra][3] knockoff:
+
+```ruby
+@last_request = nil
+respond '/path' do |request|
+  puts "Request received: #{request}"
+  @last_request = request
+end
+
+def ride bike
+  # Play with your new bike
+end
+
+respond '/new_bike' do |bike|
+  ride(bike)
+end
+```
+
+You'd put together a dispatcher something like this:
+
+```ruby
+require 'singleton'
+
+class DispatchScope
+  def a_method_you_can_call_from_inside_the_block
+    :useful_huh?
+  end
+end
+
+class MessageDispatch
+  include Singleton
+
+  def initialize
+    @responders = {}
+  end
+
+  def add_responder path, &block
+    @responders[path] = block
+  end
+
+  def dispatch path, request
+    Docile.dsl_eval(DispatchScope.new, request, &@responders[path])
+  end
+end
+
+def respond path, &handler
+  MessageDispatch.instance.add_responder path, handler
+end
+
+def send_request path, request
+  MessageDispatch.instance.dispatch path, request
+end
+```
+
+[3]: http://www.sinatrarb.com "Sinatra"
+
+### Functional-Style Immutable DSL Objects
+
+Sometimes, you want to use an object as a DSL, but it doesn't quite fit the
+[imperative](http://en.wikipedia.org/wiki/Imperative_programming) pattern shown
+above.
+
+Instead of methods like
+[Array#push](http://www.ruby-doc.org/core-3.0.0/Array.html#method-i-push), which
+modifies the object at hand, it has methods like
+[String#reverse](http://www.ruby-doc.org/core-3.0.0/String.html#method-i-reverse),
+which returns a new object without touching the original. Perhaps it's even
+[frozen](http://www.ruby-doc.org/core-3.0.0/Object.html#method-i-freeze) in
+order to enforce [immutability](http://en.wikipedia.org/wiki/Immutable_object).
+
+Wouldn't it be great if we could just treat these methods as a DSL as well?
+
+```ruby
+s = "I'm immutable!".freeze
+
+with_immutable_string(s) do
+  reverse
+  upcase
+end
+#=> "!ELBATUMMI M'I"
+
+s
+#=> "I'm immutable!"
+```
+
+No problem, just define the method `with_immutable_string` like this:
+
+```ruby
+def with_immutable_string(str="", &block)
+  Docile.dsl_eval_immutable(str, &block)
+end
+```
+
+All set!
+
+### Accessing the block's return value
+
+Sometimes you might want to access the return value of your provided block,
+as opposed to the DSL object itself. In these cases, use
+`dsl_eval_with_block_return`. It behaves exactly like `dsl_eval`, but returns
+the output from executing the block, rather than the DSL object.
+
+```ruby
+arr = []
+with_array(arr) do
+  push "a"
+  push "b"
+  push "c"
+  length
+end
+#=> 3
+
+arr
+#=> ["a", "b", "c"]
+```
+
+```ruby
+def with_array(arr=[], &block)
+  Docile.dsl_eval_with_block_return(arr, &block)
+end
+```
+
+## Features
+
+  1.  Method lookup falls back from the DSL object to the block's context
+  2.  Local variable lookup falls back from the DSL object to the block's
+        context
+  3.  Instance variables are from the block's context only
+  4.  Nested DSL evaluation, correctly chaining method and variable handling
+        from the inner to the outer DSL scopes
+  5.  Alternatives for both imperative and functional styles of DSL objects
+
+## Installation
+
+``` bash
+$ gem install docile
+```
+
+## Links
+* [Source](https://github.com/ms-ati/docile)
+* [Documentation](http://rubydoc.info/gems/docile)
+* [Bug Tracker](https://github.com/ms-ati/docile/issues)
+
+## Status
+
+Works on [all currently supported ruby versions](https://github.com/ms-ati/docile/blob/master/.github/workflows/main.yml),
+or so [Github Actions](https://github.com/ms-ati/docile/actions)
+tells us.
+
+Used by some pretty cool gems to implement their DSLs, notably including
+[SimpleCov](https://github.com/colszowka/simplecov). Keep an eye out for new
+gems using Docile at the
+[Ruby Toolbox](https://www.ruby-toolbox.com/projects/docile).
+
+## Release Policy
+
+Docile releases follow
+[Semantic Versioning 2.0.0](https://semver.org/spec/v2.0.0.html).
+
+## Note on Patches/Pull Requests
+
+  * Fork the project.
+  * Setup your development environment with:
+      `gem install bundler; bundle install`
+  * Make your feature addition or bug fix.
+  * Add tests for it. This is important so I don't break it in a future version
+      unintentionally.
+  * Commit, do not mess with rakefile, version, or history.
+      (if you want to have your own version, that is fine but bump version in a
+      commit by itself I can ignore when I pull)
+  * Send me a pull request. Bonus points for topic branches.
+
+## Releasing
+
+To make a new release of `Docile` to
+[RubyGems](https://rubygems.org/gems/docile), first install the release
+dependencies (e.g. `rake`) as follows:
+
+```shell
+bundle config set --local with 'release'
+bundle install
+```
+
+Then carry out these steps:
+
+1. Update `HISTORY.md`:
+    - Add an entry for the upcoming version _x.y.z_
+    - Move content from _Unreleased_ to the upcoming version _x.y.z_
+    - Commit with title `Update HISTORY.md for x.y.z`
+
+2. Update `lib/docile/version.rb`
+    - Replace with upcoming version _x.y.z_
+    - Commit with title `Bump version to x.y.z`
+
+3. `bundle exec rake release`
+
+## Copyright & License
+
+Copyright (c) 2012-2024 Marc Siegel.
+
+Licensed under the [MIT License](http://choosealicense.com/licenses/mit/),
+see [LICENSE](LICENSE) for details.

data/vendor/bundle/ruby/4.0.0/gems/docile-1.4.1/docile.gemspec

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "lib/docile/version"
+
+Gem::Specification.new do |s|
+  s.name        = "docile"
+  s.version     = Docile::VERSION
+  s.author      = "Marc Siegel"
+  s.email       = "marc@usainnov.com"
+  s.homepage    = "https://ms-ati.github.io/docile/"
+  s.summary     = "Docile keeps your Ruby DSLs tame and well-behaved."
+  s.description = "Docile treats the methods of a given ruby object as a DSL "\
+                  "(domain specific language) within a given block. \n\n"\
+                  "Killer feature: you can also reference methods, instance "\
+                  "variables, and local variables from the original (non-DSL) "\
+                  "context within the block. \n\n"\
+                  "Docile releases follow Semantic Versioning as defined at "\
+                  "semver.org."
+  s.license     = "MIT"
+
+  # Specify oldest supported Ruby version (2.5 to support JRuby 9.2.17.0)
+  s.required_ruby_version = ">= 2.5.0"
+
+  # Files included in the gem
+  s.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  s.require_paths = ["lib"]
+
+  s.metadata = {
+    "homepage_uri" => "https://ms-ati.github.io/docile/",
+    "changelog_uri" => "https://github.com/ms-ati/docile/blob/main/HISTORY.md",
+    "source_code_uri" => "https://github.com/ms-ati/docile",
+    "rubygems_mfa_required" => "true",
+  }
+end

data/vendor/bundle/ruby/{3.4.0/gems/drb-2.2.1 → 4.0.0/gems/drb-2.2.3}/drb.gemspec

@@ -18,6 +18,8 @@ Gem::Specification.new do |spec|
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] =
+    "#{spec.homepage}/releases/tag/v#{spec.version}"
 
   spec.files         = %w[
     LICENSE.txt
@@ -29,7 +31,6 @@ Gem::Specification.new do |spec|
     lib/drb/extserv.rb
     lib/drb/extservm.rb
     lib/drb/gw.rb
-    lib/drb/invokemethod.rb
     lib/drb/observer.rb
     lib/drb/ssl.rb
     lib/drb/timeridconv.rb

data/vendor/bundle/ruby/{3.4.0/gems/ethon-0.16.0 → 4.0.0/gems/ethon-0.18.0}/CHANGELOG.md

@@ -2,7 +2,49 @@
 
 ## Master
 
-[Full Changelog](https://github.com/typhoeus/ethon/compare/v0.15.0...master)
+[Full Changelog](https://github.com/typhoeus/ethon/compare/v0.18.0...master)
+
+## 0.18.0
+
+[Full Changelog](https://github.com/typhoeus/ethon/compare/v0.17.0...v0.18.0)
+
+* Fixed verbose mode attempting to print binary SSL data by replacing it with a summary.
+  ([Felipe Mesquita](https://github.com/felipedmesquita), [#265](https://github.com/typhoeus/ethon/pull/265))
+* Fixed `on_headers` callbacks being called once per header line instead of once for all headers.
+  ([Felipe Mesquita](https://github.com/felipedmesquita), [#264](https://github.com/typhoeus/ethon/pull/264))
+* Stabilized test server boot on macOS by fixing IPv6/IPv4 localhost resolution and preventing orphaned processes.
+  ([Geremia Taglialatela](https://github.com/tagliala), [#261](https://github.com/typhoeus/ethon/pull/261))
+* Added `logger` to runtime dependencies for Ruby 3.5+ compatibility.
+  ([Geremia Taglialatela](https://github.com/tagliala), [#259](https://github.com/typhoeus/ethon/pull/259))
+* Opted-in for MFA requirement explicitly by adding `rubygems_mfa_required` metadata.
+  ([Geremia Taglialatela](https://github.com/tagliala), [#257](https://github.com/typhoeus/ethon/pull/257))
+* Removed redundant encoding and require_relative checks.
+  ([Geremia Taglialatela](https://github.com/tagliala), [#258](https://github.com/typhoeus/ethon/pull/258))
+
+## 0.17.0
+
+[Full Changelog](https://github.com/typhoeus/ethon/compare/v0.16.0...v0.17.0)
+
+* Require Ruby 2.6+ and simplify Gemfile.
+  ([Felipe Mesquita](https://github.com/felipedmesquita), [#255](https://github.com/typhoeus/ethon/pull/255))
+* Fixed mismatched libcurl error codes in `easy_codes` array.
+  ([Felipe Mesquita](https://github.com/felipedmesquita), [#253](https://github.com/typhoeus/ethon/pull/253))
+* Add Ruby 3.3 and 3.4, remove Ruby 2.5 from CI matrix.
+  ([Felipe Mesquita](https://github.com/felipedmesquita), [#252](https://github.com/typhoeus/ethon/pull/252))
+* Skip test due to libcurl 8.7.x bug in CURLINFO_REQUEST_SIZE.
+  ([Felipe Mesquita](https://github.com/felipedmesquita), [#251](https://github.com/typhoeus/ethon/pull/251))
+* Use `Rackup::Handler.default` for Rack 3 compatibility.
+  ([Vít Ondruch](https://github.com/voxik), [#244](https://github.com/typhoeus/ethon/pull/244))
+* Add Ruby 3.1 and 3.2 to the test matrix.
+  ([Orien Madgwick](https://github.com/orien), [#228](https://github.com/typhoeus/ethon/pull/228))
+* Remove development and test files from the gem package.
+  ([Orien Madgwick](https://github.com/orien), [#227](https://github.com/typhoeus/ethon/pull/227))
+* Fix missing parenthesis in example.
+  ([Aleksey Tsalolikhin](https://github.com/atsalolikhin-spokeo), [#226](https://github.com/typhoeus/ethon/pull/226))
+
+## 0.16.0
+
+[Full Changelog](https://github.com/typhoeus/ethon/compare/v0.15.0...v0.16.0)
 
 * Added `redirect_url` value to available informations and `Easy::Mirror`.
   ([Adrien Rey-Jarthon](https://github.com/jarthod)

data/vendor/bundle/ruby/{3.4.0/gems/ethon-0.16.0 → 4.0.0/gems/ethon-0.18.0}/README.md

@@ -87,7 +87,7 @@ easy.http_request("www.example.com/get", :get, { http_version: :httpv2_0 })
 easy.http_request("www.example.com/get", :get, { http_version: :httpv2_prior_knowledge })
 
 # To set the server to use http2 with https and http1 with http, send the following:
-easy.http_request("www.example.com/get", :get, { http_version: :httpv2_tls }
+easy.http_request("www.example.com/get", :get, { http_version: :httpv2_tls })
 
 multi.add(easy)
 multi.perform

data/vendor/bundle/ruby/4.0.0/gems/ethon-0.18.0/ethon.gemspec

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'ethon/version'
+
+Gem::Specification.new do |s|
+  s.name         = "ethon"
+  s.version      = Ethon::VERSION
+  s.platform     = Gem::Platform::RUBY
+  s.authors      = ["Hans Hasselberg"]
+  s.email        = ["me@hans.io"]
+  s.homepage     = "https://github.com/typhoeus/ethon"
+  s.summary      = "Libcurl wrapper."
+  s.description  = "Very lightweight libcurl wrapper."
+
+  s.required_ruby_version = ">= 2.6"
+  s.license = 'MIT'
+
+  s.add_dependency('ffi', ['>= 1.15.0'])
+  s.add_dependency('logger')
+
+  s.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |file|
+      file.start_with?(*%w[. Gemfile Guardfile Rakefile profile spec])
+    end
+  end
+  s.require_path = 'lib'
+
+  s.metadata              = {
+    'bug_tracker_uri'       => 'https://github.com/typhoeus/ethon/issues',
+    'changelog_uri'         => "https://github.com/typhoeus/ethon/blob/v#{s.version}/CHANGELOG.md",
+    'documentation_uri'     => "https://www.rubydoc.info/gems/ethon/#{s.version}",
+    'rubygems_mfa_required' => 'true',
+    'source_code_uri'       => "https://github.com/typhoeus/ethon/tree/v#{s.version}"
+  }
+end

data/vendor/bundle/ruby/{3.4.0/gems/ffi-1.17.1-x86_64-linux-gnu → 4.0.0/gems/ffi-1.17.4-x86_64-linux-gnu}/CHANGELOG.md

@@ -1,3 +1,45 @@
+1.17.4 / 2026-03-26
+-------------------
+
+Fixed:
+* Fix union by-value ABI mismatch with float and double types on ARM64 and X86_64.
+  See #1177 and #1178 for details.
+* Exclude libffi files, which are unnecessary. #1176
+
+
+1.17.3 / 2025-12-29
+-------------------
+
+Fixed:
+* Opt-in for MFA requirement explicitly. #1159
+* Fix type signature for FFI::AutoPointer#initialize, FFI::StructByReference#native_type and FFI::Struct#auto_ptr . #1158
+* Fix function signature of function_call in FFI trampoline. #1154
+  It failed on `aarch64-mingw-ucrt`.
+* Add workaround for segmentation faults on `aarch64-mingw-ucrt`. #1154
+* Call super in `Library#freeze` . #1154
+* Deny duplication of AutoPointer per #dup and #clone . #1173
+  They led to double free before.
+
+Added:
+* Add binary gems for Ruby-4.0, now providing binary gems for Ruby-3.0 to 4.0.
+* Add msys2_mingw_dependencies for Windows Mingw for automatic installation of libffi. #1143
+* Mark callback dispatcher thread as fork safe for Puma. #1156
+* Add missing FFI::Platform module and LastError signatures. #1169
+
+Removed:
+* Drop fat binary gems for Ruby < 3.0
+* Remove `FFI::TypesGenerator` from distributed gems. #1164
+* Remove libffi build dir after install, safing some install space. #1157
+
+
+1.17.2 / 2025-04-15
+-------------------
+
+Fixed:
+* #1144, #1145 Update libffi to 3.4.8 to fix installation issues on latest Macos on ARM64
+* Various adjustments to run the specs cleanly on Ruby-3.5 master branch.
+
+
 1.17.1 / 2024-12-30
 -------------------
 

data/vendor/bundle/ruby/{3.4.0/gems/ffi-1.17.1-x86_64-linux-gnu → 4.0.0/gems/ffi-1.17.4-x86_64-linux-gnu}/README.md

@@ -33,6 +33,7 @@ MyLib.puts 'Hello, World using libc!'
 
 For less minimalistic and more examples you may look at:
 
+* The [documentation](https://www.rubydoc.info/gems/ffi)
 * the `samples/` folder
 * the examples on the [wiki](https://github.com/ffi/ffi/wiki)
 * the projects using FFI listed on the wiki: https://github.com/ffi/ffi/wiki/projects-using-ffi

data/vendor/bundle/ruby/{3.4.0/gems/ffi-1.17.1-x86_64-linux-gnu → 4.0.0/gems/ffi-1.17.4-x86_64-linux-gnu}/ffi.gemspec

@@ -15,13 +15,16 @@ Gem::Specification.new do |s|
     s.metadata['wiki_uri'] = 'https://github.com/ffi/ffi/wiki'
     s.metadata['source_code_uri'] = 'https://github.com/ffi/ffi/'
     s.metadata['mailing_list_uri'] = 'http://groups.google.com/group/ruby-ffi'
+    s.metadata['rubygems_mfa_required'] = 'true'
   end
   s.files = `git ls-files -z`.split("\x0").reject do |f|
-    f =~ /^(\.|bench|gen|libtest|nbproject|spec)/
+    f =~ /^(\.|bench|gen|libtest|nbproject|spec|rakelib)/
   end
 
   # Add libffi git files
-  lfs = `git --git-dir ext/ffi_c/libffi/.git ls-files -z`.split("\x0")
+  lfs = `git --git-dir ext/ffi_c/libffi/.git ls-files -z`.split("\x0").reject do |f|
+    f =~ /^(\.|testsuite)/
+  end
   # Add autoconf generated files of libffi
   lfs += %w[ compile configure config.guess config.sub install-sh ltmain.sh missing fficonfig.h.in ]
   # Add automake generated files of libffi
@@ -35,8 +38,6 @@ Gem::Specification.new do |s|
   s.license = 'BSD-3-Clause'
   s.require_paths << 'ext/ffi_c'
   s.required_ruby_version = '>= 2.5'
-  s.add_development_dependency 'rake', '~> 13.0'
-  s.add_development_dependency 'rake-compiler', '~> 1.1'
-  s.add_development_dependency 'rake-compiler-dock', '~> 1.0'
-  s.add_development_dependency 'rspec', '~> 2.14.1'
+
+  s.metadata['msys2_mingw_dependencies'] = 'libffi'
 end

data/vendor/bundle/ruby/{3.4.0/gems/hashdiff-1.1.2 → 4.0.0/gems/hashdiff-1.2.1}/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.