@pact-foundation/pact-cli-linux-x64 16.1.6 → 18.0.0

package/standalone/linux-x64-2.5.12/pact/lib/vendor/ruby/3.3.0/gems/webrick-1.9.1/webrick.gemspec

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-begin
-  require_relative 'lib/webrick/version'
-rescue LoadError
-  # for Ruby core repository
-  require_relative 'version'
-end
-
-Gem::Specification.new do |s|
-  s.name = "webrick"
-  s.version = WEBrick::VERSION
-  s.summary = "HTTP server toolkit"
-  s.description = "WEBrick is an HTTP server toolkit that can be configured as an HTTPS server, a proxy server, and a virtual-host server."
-
-  s.require_path = %w{lib}
-  s.files =  [
-    "Gemfile",
-    "LICENSE.txt",
-    "README.md",
-    "Rakefile",
-    "lib/webrick.rb",
-    "lib/webrick/accesslog.rb",
-    "lib/webrick/cgi.rb",
-    "lib/webrick/compat.rb",
-    "lib/webrick/config.rb",
-    "lib/webrick/cookie.rb",
-    "lib/webrick/htmlutils.rb",
-    "lib/webrick/httpauth.rb",
-    "lib/webrick/httpauth/authenticator.rb",
-    "lib/webrick/httpauth/basicauth.rb",
-    "lib/webrick/httpauth/digestauth.rb",
-    "lib/webrick/httpauth/htdigest.rb",
-    "lib/webrick/httpauth/htgroup.rb",
-    "lib/webrick/httpauth/htpasswd.rb",
-    "lib/webrick/httpauth/userdb.rb",
-    "lib/webrick/httpproxy.rb",
-    "lib/webrick/httprequest.rb",
-    "lib/webrick/httpresponse.rb",
-    "lib/webrick/https.rb",
-    "lib/webrick/httpserver.rb",
-    "lib/webrick/httpservlet.rb",
-    "lib/webrick/httpservlet/abstract.rb",
-    "lib/webrick/httpservlet/cgi_runner.rb",
-    "lib/webrick/httpservlet/cgihandler.rb",
-    "lib/webrick/httpservlet/erbhandler.rb",
-    "lib/webrick/httpservlet/filehandler.rb",
-    "lib/webrick/httpservlet/prochandler.rb",
-    "lib/webrick/httpstatus.rb",
-    "lib/webrick/httputils.rb",
-    "lib/webrick/httpversion.rb",
-    "lib/webrick/log.rb",
-    "lib/webrick/server.rb",
-    "lib/webrick/ssl.rb",
-    "lib/webrick/utils.rb",
-    "lib/webrick/version.rb",
-    "sig/accesslog.rbs",
-    "sig/cgi.rbs",
-    "sig/compat.rbs",
-    "sig/config.rbs",
-    "sig/cookie.rbs",
-    "sig/htmlutils.rbs",
-    "sig/httpauth.rbs",
-    "sig/httpauth/authenticator.rbs",
-    "sig/httpauth/basicauth.rbs",
-    "sig/httpauth/digestauth.rbs",
-    "sig/httpauth/htdigest.rbs",
-    "sig/httpauth/htgroup.rbs",
-    "sig/httpauth/htpasswd.rbs",
-    "sig/httpauth/userdb.rbs",
-    "sig/httpproxy.rbs",
-    "sig/httprequest.rbs",
-    "sig/httpresponse.rbs",
-    "sig/https.rbs",
-    "sig/httpserver.rbs",
-    "sig/httpservlet.rbs",
-    "sig/httpservlet/abstract.rbs",
-    "sig/httpservlet/cgi_runner.rbs",
-    "sig/httpservlet/cgihandler.rbs",
-    "sig/httpservlet/erbhandler.rbs",
-    "sig/httpservlet/filehandler.rbs",
-    "sig/httpservlet/prochandler.rbs",
-    "sig/httpstatus.rbs",
-    "sig/httputils.rbs",
-    "sig/httpversion.rbs",
-    "sig/log.rbs",
-    "sig/manifest.yaml",
-    "sig/server.rbs",
-    "sig/ssl.rbs",
-    "sig/utils.rbs",
-    "sig/version.rbs",
-    "webrick.gemspec",
-  ]
-  s.required_ruby_version = ">= 2.4.0"
-
-  s.authors = ["TAKAHASHI Masayoshi", "GOTOU YUUZOU", "Eric Wong"]
-  s.email = [nil, nil, 'normal@ruby-lang.org']
-  s.homepage = "https://github.com/ruby/webrick"
-  s.licenses = ["Ruby", "BSD-2-Clause"]
-
-  if s.respond_to?(:metadata=)
-    s.metadata = {
-      "bug_tracker_uri" => "https://github.com/ruby/webrick/issues",
-    }
-  end
-end

package/standalone/linux-x64-2.5.12/pact/lib/vendor/ruby/3.3.0/gems/zeitwerk-2.7.5/lib/zeitwerk/core_ext/kernel.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module Kernel
-  module_function
-
-  # Zeitwerk's main idea is to define autoloads for project constants, and then
-  # intercept them when triggered in this thin `Kernel#require` wrapper.
-  #
-  # That allows us to complete the circle, invoke callbacks, autovivify modules,
-  # define autoloads for just autoloaded namespaces, update internal state, etc.
-  #
-  # On the other hand, if you publish a new version of a gem that is now managed
-  # by Zeitwerk, client code can reference directly your classes and modules and
-  # should not require anything. But if someone has legacy require calls around,
-  # they will work as expected, and in a compatible way. This feature is by now
-  # EXPERIMENTAL and UNDOCUMENTED.
-  alias_method :zeitwerk_original_require, :require
-  class << self
-    alias_method :zeitwerk_original_require, :require
-  end
-
-  #: (String) -> bool
-  def require(path)
-    if loader = Zeitwerk::Registry.autoloads.registered?(path)
-      if path.end_with?(".rb")
-        required = zeitwerk_original_require(path)
-        loader.__on_file_autoloaded(path) if required
-        required
-      else
-        loader.__on_dir_autoloaded(path)
-        true
-      end
-    else
-      required = zeitwerk_original_require(path)
-      if required
-        abspath = $LOADED_FEATURES.last
-        if loader = Zeitwerk::Registry.autoloads.registered?(abspath)
-          loader.__on_file_autoloaded(abspath)
-        end
-      end
-      required
-    end
-  end
-
-  # By now, I have seen no way so far to decorate require_relative.
-  #
-  # For starters, at least in CRuby, require_relative does not delegate to
-  # require. Both require and require_relative delegate the bulk of their work
-  # to an internal C function called rb_require_safe. So, our require wrapper is
-  # not executed.
-  #
-  # On the other hand, we cannot use the aliasing technique above because
-  # require_relative receives a path relative to the directory of the file in
-  # which the call is performed. If a wrapper here invoked the original method,
-  # Ruby would resolve the relative path taking lib/zeitwerk as base directory.
-  #
-  # A workaround could be to extract the base directory from caller_locations,
-  # but what if someone else decorated require_relative before us? You can't
-  # really know with certainty where's the original call site in the stack.
-  #
-  # However, the main use case for require_relative is to load files from your
-  # own project. Projects managed by Zeitwerk don't do this for files managed by
-  # Zeitwerk, precisely.
-end

package/standalone/linux-x64-2.5.12/pact/lib/vendor/ruby/3.3.0/gems/zeitwerk-2.7.5/lib/zeitwerk/core_ext/module.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Zeitwerk::ConstAdded # :nodoc:
-  #: (Symbol) -> void
-  def const_added(cname)
-    if loader = Zeitwerk::Registry.explicit_namespaces.loader_for(self, cname)
-      namespace = const_get(cname, false)
-      cref = Zeitwerk::Cref.new(self, cname)
-
-      unless namespace.is_a?(Module)
-        raise Zeitwerk::Error, "#{cref} is expected to be a namespace, should be a class or module (got #{namespace.class})"
-      end
-
-      loader.__on_namespace_loaded(cref, namespace)
-    end
-    super
-  end
-
-  Module.prepend(self)
-end

package/standalone/linux-x64-2.5.12/pact/lib/vendor/ruby/3.3.0/gems/zeitwerk-2.7.5/lib/zeitwerk/cref/map.rb

@@ -1,159 +0,0 @@
-# frozen_string_literal: true
-
-# Description of the structure
-# ----------------------------
-#
-# This class emulates a hash table whose keys are of type Zeitwerk::Cref.
-#
-# It is a synchronized 2-level hash.
-#
-# The keys of the top one, stored in `@map`, are class and module objects, but
-# their hash code is forced to be their object IDs because class and module
-# objects may not be hashable (https://github.com/fxn/zeitwerk/issues/188).
-#
-# Then, each one of them stores a hash table with their constants and values.
-# Constants are stored as symbols.
-#
-# For example, if we store values 0, 1, and 2 for the crefs that would
-# correspond to `M::X`, `M::Y`, and `N::Z`, the map will look like this:
-#
-#   { M => { X: 0, Y: 1 }, N => { Z: 2 } }
-#
-# This structure is internal, so only the needed interface is implemented.
-#
-# Alternative approaches
-# -----------------------
-#
-# 1. We could also use a 1-level hash whose keys are constant paths. In the
-#    example above it would be:
-#
-#      { "M::X" => 0, "M::Y" => 1, "N::Z" => 2 }
-#
-#    The gem used this approach for several years.
-#
-#  2. Write a custom `hash`/`eql?` in Zeitwerk::Cref. Hash code would be
-#
-#       real_mod_hash(@mod) ^ @cname.hash
-#
-#     where `real_mod_hash(@mod)` would actually be a call to the real `hash`
-#     method in Module. Like what we do for module names to bypass overrides.
-#
-#  3. Similar to 2, but use
-#
-#       @mod.object_id ^ @cname.object_id
-#
-#     as hash code instead.
-#
-# Benchmarks
-# ----------
-#
-# Writing:
-#
-#   map - baseline
-#   (3) - 1.74x  slower
-#   (2) - 2.91x  slower
-#   (1) - 3.87x  slower
-#
-# Reading:
-#
-#   map - baseline
-#   (3) - 1.99x  slower
-#   (2) - 2.80x  slower
-#   (1) - 3.48x  slower
-#
-# Extra ball
-# ----------
-#
-# In addition to that, the map is synchronized and provides `delete_mod_cname`,
-# which is ad-hoc for the hot path in `const_added`, we do not need to create
-# unnecessary cref objects for constants we do not manage (but we do not know in
-# advance there).
-
-#: [Value]
-class Zeitwerk::Cref::Map # :nodoc: all
-  #: () -> void
-  def initialize
-    @map = {}
-    @map.compare_by_identity
-    @mutex = Mutex.new
-  end
-
-  #: (Zeitwerk::Cref, Value) -> Value
-  def []=(cref, value)
-    @mutex.synchronize do
-      cnames = (@map[cref.mod] ||= {})
-      cnames[cref.cname] = value
-    end
-  end
-
-  #: (Zeitwerk::Cref) -> Value?
-  def [](cref)
-    @mutex.synchronize do
-      @map[cref.mod]&.[](cref.cname)
-    end
-  end
-
-  #: (Zeitwerk::Cref, { () -> Value }) -> Value
-  def get_or_set(cref, &block)
-    @mutex.synchronize do
-      cnames = (@map[cref.mod] ||= {})
-      cnames.fetch(cref.cname) { cnames[cref.cname] = block.call }
-    end
-  end
-
-  #: (Zeitwerk::Cref) -> Value?
-  def delete(cref)
-    delete_mod_cname(cref.mod, cref.cname)
-  end
-
-  # Ad-hoc for loader_for, called from const_added. That is a hot path, I prefer
-  # to not create a cref in every call, since that is global.
-  #
-  #: (Module, Symbol) -> Value?
-  def delete_mod_cname(mod, cname)
-    @mutex.synchronize do
-      if cnames = @map[mod]
-        value = cnames.delete(cname)
-        @map.delete(mod) if cnames.empty?
-        value
-      end
-    end
-  end
-
-  #: (Value) -> void
-  def delete_by_value(value)
-    @mutex.synchronize do
-      @map.delete_if do |mod, cnames|
-        cnames.delete_if { _2 == value }
-        cnames.empty?
-      end
-    end
-  end
-
-  # Order of yielded crefs is undefined.
-  #
-  #: () { (Zeitwerk::Cref) -> void } -> void
-  def each_key
-    @mutex.synchronize do
-      @map.each do |mod, cnames|
-        cnames.each_key do |cname|
-          yield Zeitwerk::Cref.new(mod, cname)
-        end
-      end
-    end
-  end
-
-  #: () -> void
-  def clear
-    @mutex.synchronize do
-      @map.clear
-    end
-  end
-
-  #: () -> bool
-  def empty? # for tests
-    @mutex.synchronize do
-      @map.empty?
-    end
-  end
-end

package/standalone/linux-x64-2.5.12/pact/lib/vendor/ruby/3.3.0/gems/zeitwerk-2.7.5/lib/zeitwerk/cref.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-# This private class encapsulates pairs (mod, cname).
-#
-# Objects represent the constant `cname` in the class or module object `mod`,
-# and have API to manage them. Examples:
-#
-#   cref.path
-#   cref.set(value)
-#   cref.get
-#
-# The constant may or may not exist in `mod`.
-class Zeitwerk::Cref
-  require_relative "cref/map"
-
-  include Zeitwerk::RealModName
-
-  #: Module
-  attr_reader :mod
-
-  #: Symbol
-  attr_reader :cname
-
-  # The type of the first argument is Module because Class < Module, class
-  # objects are also valid.
-  #
-  #: (Module, Symbol) -> void
-  def initialize(mod, cname)
-    @mod   = mod
-    @cname = cname
-    @path  = nil
-  end
-
-  #: () -> String
-  def path
-    @path ||= Object == @mod ? @cname.name : "#{real_mod_name(@mod)}::#{@cname.name}".freeze
-  end
-  alias to_s path
-
-  #: () -> String?
-  def autoload?
-    @mod.autoload?(@cname, false)
-  end
-
-  #: (String) -> nil
-  def autoload(abspath)
-    @mod.autoload(@cname, abspath)
-  end
-
-  #: () -> bool
-  def defined?
-    @mod.const_defined?(@cname, false)
-  end
-
-  #: (top) -> top
-  def set(value)
-    @mod.const_set(@cname, value)
-  end
-
-  #: () -> top ! NameError
-  def get
-    @mod.const_get(@cname, false)
-  end
-
-  #: () -> void ! NameError
-  def remove
-    @mod.__send__(:remove_const, @cname)
-  end
-end

package/standalone/linux-x64-2.5.12/pact/lib/vendor/ruby/3.3.0/gems/zeitwerk-2.7.5/lib/zeitwerk/error.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Zeitwerk
-  class Error < StandardError
-  end
-
-  class ReloadingDisabledError < Error
-    #: () -> void
-    def initialize
-      super("can't reload, please call loader.enable_reloading before setup")
-    end
-  end
-
-  class NameError < ::NameError
-  end
-
-  class SetupRequired < Error
-    #: () -> void
-    def initialize
-      super("please, finish your configuration and call Zeitwerk::Loader#setup once all is ready")
-    end
-  end
-end

package/standalone/linux-x64-2.5.12/pact/lib/vendor/ruby/3.3.0/gems/zeitwerk-2.7.5/lib/zeitwerk/gem_inflector.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Zeitwerk
-  class GemInflector < Inflector
-    #: (String) -> void
-    def initialize(root_file)
-      namespace     = File.basename(root_file, ".rb")
-      root_dir      = File.dirname(root_file)
-      @version_file = File.join(root_dir, namespace, "version.rb")
-    end
-
-    #: (String, String) -> String
-    def camelize(basename, abspath)
-      abspath == @version_file ? "VERSION" : super
-    end
-  end
-end

package/standalone/linux-x64-2.5.12/pact/lib/vendor/ruby/3.3.0/gems/zeitwerk-2.7.5/lib/zeitwerk/gem_loader.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module Zeitwerk
-  # @private
-  class GemLoader < Loader
-    include RealModName
-
-    # Users should not create instances directly, the public interface is
-    # `Zeitwerk::Loader.for_gem`.
-    private_class_method :new
-
-    # @private
-    #: (String, namespace: Module, warn_on_extra_files: boolish) -> Zeitwerk::GemLoader
-    def self.__new(root_file, namespace:, warn_on_extra_files:)
-      new(root_file, namespace: namespace, warn_on_extra_files: warn_on_extra_files)
-    end
-
-    #: (String, namespace: Module, warn_on_extra_files: boolish) -> void
-    def initialize(root_file, namespace:, warn_on_extra_files:)
-      super()
-
-      @tag = File.basename(root_file, ".rb")
-      @tag = real_mod_name(namespace) + "-" + @tag unless namespace.equal?(Object)
-
-      @inflector           = GemInflector.new(root_file)
-      @root_file           = File.expand_path(root_file)
-      @root_dir            = File.dirname(root_file)
-      @warn_on_extra_files = warn_on_extra_files
-
-      push_dir(@root_dir, namespace: namespace)
-    end
-
-    #: () -> void
-    def setup
-      warn_on_extra_files if @warn_on_extra_files
-      super
-    end
-
-    private
-
-    #: () -> void
-    def warn_on_extra_files
-      expected_namespace_dir = @root_file.delete_suffix(".rb")
-
-      @fs.ls(@root_dir) do |basename, abspath, ftype|
-        next if abspath == @root_file
-        next if abspath == expected_namespace_dir
-
-        basename_without_ext = basename.delete_suffix(".rb")
-        cname = cname_for(basename_without_ext, abspath)
-
-        warn(<<~EOS)
-          WARNING: Zeitwerk defines the constant #{cname} after the #{ftype}
-
-              #{abspath}
-
-          To prevent that, please configure the loader to ignore it:
-
-              loader.ignore("\#{__dir__}/#{basename}")
-
-          Otherwise, there is a flag to silence this warning:
-
-              Zeitwerk::Loader.for_gem(warn_on_extra_files: false)
-        EOS
-      end
-    end
-  end
-end

package/standalone/linux-x64-2.5.12/pact/lib/vendor/ruby/3.3.0/gems/zeitwerk-2.7.5/lib/zeitwerk/inflector.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module Zeitwerk
-  class Inflector
-    # Very basic snake case -> camel case conversion.
-    #
-    #   inflector = Zeitwerk::Inflector.new
-    #   inflector.camelize("post", ...)             # => "Post"
-    #   inflector.camelize("users_controller", ...) # => "UsersController"
-    #   inflector.camelize("api", ...)              # => "Api"
-    #
-    # Takes into account hard-coded mappings configured with `inflect`.
-    #
-    #: (String, String) -> String
-    def camelize(basename, _abspath)
-      overrides[basename] || basename.split('_').each(&:capitalize!).join
-    end
-
-    # Configures hard-coded inflections:
-    #
-    #   inflector = Zeitwerk::Inflector.new
-    #   inflector.inflect(
-    #     "html_parser"   => "HTMLParser",
-    #     "mysql_adapter" => "MySQLAdapter"
-    #   )
-    #
-    #   inflector.camelize("html_parser", abspath)      # => "HTMLParser"
-    #   inflector.camelize("mysql_adapter", abspath)    # => "MySQLAdapter"
-    #   inflector.camelize("users_controller", abspath) # => "UsersController"
-    #
-    #: (Hash[String, String]) -> void
-    def inflect(inflections)
-      overrides.merge!(inflections)
-    end
-
-    private
-
-    # Hard-coded basename to constant name user maps that override the default
-    # inflection logic.
-    #
-    #: () -> Hash[String, String]
-    def overrides
-      @overrides ||= {}
-    end
-  end
-end

package/standalone/linux-x64-2.5.12/pact/lib/vendor/ruby/3.3.0/gems/zeitwerk-2.7.5/lib/zeitwerk/internal.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-# This is a private module.
-module Zeitwerk::Internal
-  #: (Symbol) -> void
-  def internal(method_name)
-    private method_name
-
-    mangled = "__#{method_name}"
-    alias_method mangled, method_name
-    public mangled
-  end
-end

package/standalone/linux-x64-2.5.12/pact/lib/vendor/ruby/3.3.0/gems/zeitwerk-2.7.5/lib/zeitwerk/loader/callbacks.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-module Zeitwerk::Loader::Callbacks # :nodoc: all
-  extend Zeitwerk::Internal
-
-  # Invoked from our decorated Kernel#require when a managed file is autoloaded.
-  #
-  #: (String) -> void ! Zeitwerk::NameError
-  internal def on_file_autoloaded(file)
-    cref = autoloads.delete(file)
-
-    Zeitwerk::Registry.autoloads.unregister(file)
-
-    if cref.defined?
-      log { "constant #{cref} loaded from file #{file}" }
-      to_unload[file] = cref if reloading_enabled?
-      run_on_load_callbacks(cref.path, cref.get, file) unless on_load_callbacks.empty?
-    else
-      msg = "expected file #{file} to define constant #{cref}, but didn't"
-      log { msg }
-
-      # Ruby still keeps the autoload defined, but we remove it because the
-      # contract in Zeitwerk is more strict.
-      cref.remove
-
-      # Since the expected constant was not defined, there is nothing to unload.
-      # However, if the exception is rescued and reloading is enabled, we still
-      # need to deleted the file from $LOADED_FEATURES.
-      to_unload[file] = cref if reloading_enabled?
-
-      raise Zeitwerk::NameError.new(msg, cref.cname)
-    end
-  end
-
-  # Invoked from our decorated Kernel#require when a managed directory is
-  # autoloaded.
-  #
-  #: (String) -> void
-  internal def on_dir_autoloaded(dir)
-    # Module#autoload does not serialize concurrent requires in CRuby < 3.2, and
-    # we handle directories ourselves without going through Kernel#require, so
-    # the callback needs to account for concurrency.
-    #
-    # Multi-threading would introduce a race condition here in which thread t1
-    # autovivifies the module, and while autoloads for its children are being
-    # set, thread t2 autoloads the same namespace.
-    #
-    # Without the mutex and subsequent delete call, t2 would reset the module.
-    # That not only would reassign the constant (undesirable per se) but, worse,
-    # the module object created by t2 wouldn't have any of the autoloads for its
-    # children, since t1 would have correctly deleted its namespace_dirs entry.
-    dirs_autoload_monitor.synchronize do
-      if cref = autoloads.delete(dir)
-        implicit_namespace = cref.set(Module.new)
-        log { "module #{cref} autovivified from directory #{dir}" }
-
-        to_unload[dir] = cref if reloading_enabled?
-
-        # We don't unregister `dir` in the registry because concurrent threads
-        # wouldn't find a loader associated to it in Kernel#require and would
-        # try to require the directory. Instead, we are going to keep track of
-        # these to be able to unregister later if eager loading.
-        autoloaded_dirs << dir
-
-        on_namespace_loaded(cref, implicit_namespace)
-
-        run_on_load_callbacks(cref.path, implicit_namespace, dir) unless on_load_callbacks.empty?
-      end
-    end
-  end
-
-  # Invoked when a namespace is created, either from const_added or from module
-  # autovivification. If the namespace has matching subdirectories, we descend
-  # into them now.
-  #
-  #: (Zeitwerk::Cref, Module) -> void
-  internal def on_namespace_loaded(cref, namespace)
-    if dirs = namespace_dirs.delete(cref)
-      dirs.each do |dir|
-        define_autoloads_for_dir(dir, namespace)
-      end
-    end
-  end
-
-  private
-
-  #: (String, top, String) -> void
-  def run_on_load_callbacks(cpath, value, abspath)
-    # Order matters. If present, run the most specific one.
-    callbacks = reloading_enabled? ? on_load_callbacks[cpath] : on_load_callbacks.delete(cpath)
-    callbacks&.each { |c| c.call(value, abspath) }
-
-    callbacks = on_load_callbacks[:ANY]
-    callbacks&.each { |c| c.call(cpath, value, abspath) }
-  end
-end