@ai-ecoverse/wasix-ruby 3.4.11-1

package/lib/ruby/3.4.11/bundler/templates/newgem/test/minitest/test_newgem.rb.tt

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class <%= config[:minitest_constant_name] %> < Minitest::Test
+  def test_that_it_has_a_version_number
+    refute_nil ::<%= config[:constant_name] %>::VERSION
+  end
+
+  def test_it_does_something_useful
+    assert false
+  end
+end

package/lib/ruby/3.4.11/bundler/templates/newgem/test/test-unit/newgem_test.rb.tt

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class <%= config[:constant_name] %>Test < Test::Unit::TestCase
+  test "VERSION" do
+    assert do
+      ::<%= config[:constant_name] %>.const_defined?(:VERSION)
+    end
+  end
+
+  test "something useful" do
+    assert_equal("expected", "actual")
+  end
+end

package/lib/ruby/3.4.11/bundler/templates/newgem/test/test-unit/test_helper.rb.tt

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "<%= config[:namespaced_path] %>"
+
+require "test-unit"

package/lib/ruby/3.4.11/bundler/ui/rg_proxy.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "../ui"
+require "rubygems/user_interaction"
+
+module Bundler
+  module UI
+    class RGProxy < ::Gem::SilentUI
+      def initialize(ui)
+        @ui = ui
+        super()
+      end
+
+      def say(message)
+        @ui&.debug(message)
+      end
+    end
+  end
+end

package/lib/ruby/3.4.11/bundler/ui/shell.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require_relative "../vendored_thor"
+
+module Bundler
+  module UI
+    class Shell
+      LEVELS = %w[silent error warn confirm info debug].freeze
+      OUTPUT_STREAMS = [:stdout, :stderr].freeze
+
+      attr_writer :shell
+      attr_reader :output_stream
+
+      def initialize(options = {})
+        Thor::Base.shell = options["no-color"] ? Thor::Shell::Basic : nil
+        @shell = Thor::Base.shell.new
+        @level = ENV["DEBUG"] ? "debug" : "info"
+        @warning_history = []
+        @output_stream = :stdout
+      end
+
+      def add_color(string, *color)
+        @shell.set_color(string, *color)
+      end
+
+      def info(msg = nil, newline = nil)
+        return unless info?
+
+        tell_me(msg || yield, nil, newline)
+      end
+
+      def confirm(msg = nil, newline = nil)
+        return unless confirm?
+
+        tell_me(msg || yield, :green, newline)
+      end
+
+      def warn(msg = nil, newline = nil, color = :yellow)
+        return unless warn?
+        return if @warning_history.include? msg
+        @warning_history << msg
+
+        tell_err(msg || yield, color, newline)
+      end
+
+      def error(msg = nil, newline = nil, color = :red)
+        return unless error?
+
+        tell_err(msg || yield, color, newline)
+      end
+
+      def debug(msg = nil, newline = nil)
+        return unless debug?
+
+        tell_me(msg || yield, nil, newline)
+      end
+
+      def info?
+        level("info")
+      end
+
+      def confirm?
+        level("confirm")
+      end
+
+      def warn?
+        level("warn")
+      end
+
+      def error?
+        level("error")
+      end
+
+      def debug?
+        level("debug")
+      end
+
+      def quiet?
+        level("quiet")
+      end
+
+      def ask(msg)
+        @shell.ask(msg)
+      end
+
+      def yes?(msg)
+        @shell.yes?(msg)
+      end
+
+      def no?(msg)
+        @shell.no?(msg)
+      end
+
+      def level=(level)
+        raise ArgumentError unless LEVELS.include?(level.to_s)
+        @level = level.to_s
+      end
+
+      def level(name = nil)
+        return @level unless name
+        unless index = LEVELS.index(name)
+          raise "#{name.inspect} is not a valid level"
+        end
+        index <= LEVELS.index(@level)
+      end
+
+      def output_stream=(symbol)
+        raise ArgumentError unless OUTPUT_STREAMS.include?(symbol)
+        @output_stream = symbol
+      end
+
+      def trace(e, newline = nil, force = false)
+        return unless debug? || force
+        msg = "#{e.class}: #{e.message}\n#{e.backtrace.join("\n  ")}"
+        tell_err(msg, nil, newline)
+      end
+
+      def silence(&blk)
+        with_level("silent", &blk)
+      end
+
+      def progress(&blk)
+        with_output_stream(:stderr, &blk)
+      end
+
+      def unprinted_warnings
+        []
+      end
+
+      private
+
+      # valimism
+      def tell_me(msg, color = nil, newline = nil)
+        return tell_err(msg, color, newline) if output_stream == :stderr
+
+        msg = word_wrap(msg) if newline.is_a?(Hash) && newline[:wrap]
+        if newline.nil?
+          @shell.say(msg, color)
+        else
+          @shell.say(msg, color, newline)
+        end
+      end
+
+      def tell_err(message, color = nil, newline = nil)
+        return if @shell.send(:stderr).closed?
+
+        newline = !message.to_s.match?(/( |\t)\Z/) if newline.nil?
+        message = word_wrap(message) if newline.is_a?(Hash) && newline[:wrap]
+
+        color = nil if color && !$stderr.tty?
+
+        buffer = @shell.send(:prepare_message, message, *color)
+        buffer << "\n" if newline && !message.to_s.end_with?("\n")
+
+        @shell.send(:stderr).print(buffer)
+        @shell.send(:stderr).flush
+      end
+
+      def strip_leading_spaces(text)
+        spaces = text[/\A\s+/, 0]
+        spaces ? text.gsub(/#{spaces}/, "") : text
+      end
+
+      def word_wrap(text, line_width = Thor::Terminal.terminal_width)
+        strip_leading_spaces(text).split("\n").collect do |line|
+          line.length > line_width ? line.gsub(/(.{1,#{line_width}})(\s+|$)/, "\\1\n").strip : line
+        end * "\n"
+      end
+
+      def with_level(level)
+        original = @level
+        @level = level
+        yield
+      ensure
+        @level = original
+      end
+
+      def with_output_stream(symbol)
+        original = output_stream
+        self.output_stream = symbol
+        yield
+      ensure
+        @output_stream = original
+      end
+    end
+  end
+end

package/lib/ruby/3.4.11/bundler/ui/silent.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Bundler
+  module UI
+    class Silent
+      attr_writer :shell
+
+      def initialize
+        @warnings = []
+      end
+
+      def add_color(string, color)
+        string
+      end
+
+      def info(message = nil, newline = nil)
+      end
+
+      def confirm(message = nil, newline = nil)
+      end
+
+      def warn(message = nil, newline = nil)
+        @warnings |= [message]
+      end
+
+      def error(message = nil, newline = nil)
+      end
+
+      def debug(message = nil, newline = nil)
+      end
+
+      def confirm?
+        false
+      end
+
+      def error?
+        false
+      end
+
+      def debug?
+        false
+      end
+
+      def info?
+        false
+      end
+
+      def quiet?
+        false
+      end
+
+      def warn?
+        false
+      end
+
+      def output_stream=(_symbol)
+      end
+
+      def output_stream
+        nil
+      end
+
+      def ask(message)
+      end
+
+      def yes?(msg)
+        raise "Cannot ask yes? with a silent shell"
+      end
+
+      def no?(msg)
+        raise "Cannot ask no? with a silent shell"
+      end
+
+      def level=(name)
+      end
+
+      def level(name = nil)
+      end
+
+      def trace(message, newline = nil, force = false)
+      end
+
+      def silence
+        yield
+      end
+
+      def progress
+        yield
+      end
+
+      def unprinted_warnings
+        @warnings
+      end
+    end
+  end
+end

package/lib/ruby/3.4.11/bundler/ui.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Bundler
+  module UI
+    autoload :RGProxy, File.expand_path("ui/rg_proxy", __dir__)
+    autoload :Shell,   File.expand_path("ui/shell", __dir__)
+    autoload :Silent,  File.expand_path("ui/silent", __dir__)
+  end
+end

package/lib/ruby/3.4.11/bundler/uri_credentials_filter.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Bundler
+  module URICredentialsFilter
+    module_function
+
+    def credential_filtered_uri(uri_to_anonymize)
+      return uri_to_anonymize if uri_to_anonymize.nil?
+      uri = uri_to_anonymize.dup
+      if uri.is_a?(String)
+        return uri if File.exist?(uri)
+
+        require_relative "vendored_uri"
+        uri = Gem::URI(uri)
+      end
+
+      if uri.userinfo
+        # oauth authentication
+        if uri.password == "x-oauth-basic" || uri.password == "x" || uri.password.nil?
+          # URI as string does not display with password if no user is set
+          oauth_designation = uri.password
+          uri.user = oauth_designation
+        end
+        uri.password = nil
+      end
+      return uri.to_s if uri_to_anonymize.is_a?(String)
+      uri
+    rescue Gem::URI::InvalidURIError # uri is not canonical uri scheme
+      uri
+    end
+
+    def credential_filtered_string(str_to_filter, uri)
+      return str_to_filter if uri.nil? || str_to_filter.nil?
+      str_with_no_credentials = str_to_filter.dup
+      anonymous_uri_str = credential_filtered_uri(uri).to_s
+      uri_str = uri.to_s
+      if anonymous_uri_str != uri_str
+        str_with_no_credentials = str_with_no_credentials.gsub(uri_str, anonymous_uri_str)
+      end
+      str_with_no_credentials
+    end
+  end
+end

package/lib/ruby/3.4.11/bundler/uri_normalizer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Bundler
+  module URINormalizer
+    module_function
+
+    # Normalizes uri to a consistent version, either with or without trailing
+    # slash.
+    #
+    # TODO: Currently gem sources are locked with a trailing slash, while git
+    # sources are locked without a trailing slash. This should be normalized but
+    # the inconsistency is there for now to avoid changing all lockfiles
+    # including GIT sources. We could normalize this on the next major.
+    #
+    def normalize_suffix(uri, trailing_slash: true)
+      if trailing_slash
+        uri.end_with?("/") ? uri : "#{uri}/"
+      else
+        uri.end_with?("/") ? uri.delete_suffix("/") : uri
+      end
+    end
+  end
+end

package/lib/ruby/3.4.11/bundler/vendor/.document

@@ -0,0 +1 @@
+# Vendored files do not need to be documented

package/lib/ruby/3.4.11/bundler/vendor/connection_pool/.document

@@ -0,0 +1 @@
+# Vendored files do not need to be documented

package/lib/ruby/3.4.11/bundler/vendor/connection_pool/lib/connection_pool/timed_stack.rb

@@ -0,0 +1,224 @@
+##
+# The TimedStack manages a pool of homogeneous connections (or any resource
+# you wish to manage).  Connections are created lazily up to a given maximum
+# number.
+
+# Examples:
+#
+#    ts = TimedStack.new(1) { MyConnection.new }
+#
+#    # fetch a connection
+#    conn = ts.pop
+#
+#    # return a connection
+#    ts.push conn
+#
+#    conn = ts.pop
+#    ts.pop timeout: 5
+#    #=> raises Bundler::ConnectionPool::TimeoutError after 5 seconds
+
+class Bundler::ConnectionPool::TimedStack
+  attr_reader :max
+
+  ##
+  # Creates a new pool with +size+ connections that are created from the given
+  # +block+.
+
+  def initialize(size = 0, &block)
+    @create_block = block
+    @created = 0
+    @que = []
+    @max = size
+    @mutex = Thread::Mutex.new
+    @resource = Thread::ConditionVariable.new
+    @shutdown_block = nil
+  end
+
+  ##
+  # Returns +obj+ to the stack.  +options+ is ignored in TimedStack but may be
+  # used by subclasses that extend TimedStack.
+
+  def push(obj, options = {})
+    @mutex.synchronize do
+      if @shutdown_block
+        @created -= 1 unless @created == 0
+        @shutdown_block.call(obj)
+      else
+        store_connection obj, options
+      end
+
+      @resource.broadcast
+    end
+  end
+  alias_method :<<, :push
+
+  ##
+  # Retrieves a connection from the stack.  If a connection is available it is
+  # immediately returned.  If no connection is available within the given
+  # timeout a Bundler::ConnectionPool::TimeoutError is raised.
+  #
+  # +:timeout+ is the only checked entry in +options+ and is preferred over
+  # the +timeout+ argument (which will be removed in a future release).  Other
+  # options may be used by subclasses that extend TimedStack.
+
+  def pop(timeout = 0.5, options = {})
+    options, timeout = timeout, 0.5 if Hash === timeout
+    timeout = options.fetch :timeout, timeout
+
+    deadline = current_time + timeout
+    @mutex.synchronize do
+      loop do
+        raise Bundler::ConnectionPool::PoolShuttingDownError if @shutdown_block
+        return fetch_connection(options) if connection_stored?(options)
+
+        connection = try_create(options)
+        return connection if connection
+
+        to_wait = deadline - current_time
+        raise Bundler::ConnectionPool::TimeoutError, "Waited #{timeout} sec, #{length}/#{@max} available" if to_wait <= 0
+        @resource.wait(@mutex, to_wait)
+      end
+    end
+  end
+
+  ##
+  # Shuts down the TimedStack by passing each connection to +block+ and then
+  # removing it from the pool. Attempting to checkout a connection after
+  # shutdown will raise +Bundler::ConnectionPool::PoolShuttingDownError+ unless
+  # +:reload+ is +true+.
+
+  def shutdown(reload: false, &block)
+    raise ArgumentError, "shutdown must receive a block" unless block
+
+    @mutex.synchronize do
+      @shutdown_block = block
+      @resource.broadcast
+
+      shutdown_connections
+      @shutdown_block = nil if reload
+    end
+  end
+
+  ##
+  # Reaps connections that were checked in more than +idle_seconds+ ago.
+  def reap(idle_seconds, &block)
+    raise ArgumentError, "reap must receive a block" unless block
+    raise ArgumentError, "idle_seconds must be a number" unless idle_seconds.is_a?(Numeric)
+    raise Bundler::ConnectionPool::PoolShuttingDownError if @shutdown_block
+
+    idle.times do
+      conn =
+        @mutex.synchronize do
+          raise Bundler::ConnectionPool::PoolShuttingDownError if @shutdown_block
+
+          reserve_idle_connection(idle_seconds)
+        end
+      break unless conn
+
+      block.call(conn)
+    end
+  end
+
+  ##
+  # Returns +true+ if there are no available connections.
+
+  def empty?
+    (@created - @que.length) >= @max
+  end
+
+  ##
+  # The number of connections available on the stack.
+
+  def length
+    @max - @created + @que.length
+  end
+
+  ##
+  # The number of connections created and available on the stack.
+  def idle
+    @que.length
+  end
+
+  private
+
+  def current_time
+    Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+
+  ##
+  # This is an extension point for TimedStack and is called with a mutex.
+  #
+  # This method must returns true if a connection is available on the stack.
+
+  def connection_stored?(options = nil)
+    !@que.empty?
+  end
+
+  ##
+  # This is an extension point for TimedStack and is called with a mutex.
+  #
+  # This method must return a connection from the stack.
+
+  def fetch_connection(options = nil)
+    @que.pop&.first
+  end
+
+  ##
+  # This is an extension point for TimedStack and is called with a mutex.
+  #
+  # This method must shut down all connections on the stack.
+
+  def shutdown_connections(options = nil)
+    while connection_stored?(options)
+      conn = fetch_connection(options)
+      @created -= 1 unless @created == 0
+      @shutdown_block.call(conn)
+    end
+  end
+
+  ##
+  # This is an extension point for TimedStack and is called with a mutex.
+  #
+  # This method returns the oldest idle connection if it has been idle for more than idle_seconds.
+  # This requires that the stack is kept in order of checked in time (oldest first).
+
+  def reserve_idle_connection(idle_seconds)
+    return unless idle_connections?(idle_seconds)
+
+    @created -= 1 unless @created == 0
+
+    @que.shift.first
+  end
+
+  ##
+  # This is an extension point for TimedStack and is called with a mutex.
+  #
+  # Returns true if the first connection in the stack has been idle for more than idle_seconds
+
+  def idle_connections?(idle_seconds)
+    connection_stored? && (current_time - @que.first.last > idle_seconds)
+  end
+
+  ##
+  # This is an extension point for TimedStack and is called with a mutex.
+  #
+  # This method must return +obj+ to the stack.
+
+  def store_connection(obj, options = nil)
+    @que.push [obj, current_time]
+  end
+
+  ##
+  # This is an extension point for TimedStack and is called with a mutex.
+  #
+  # This method must create a connection if and only if the total number of
+  # connections allowed has not been met.
+
+  def try_create(options = nil)
+    unless @created == @max
+      object = @create_block.call
+      @created += 1
+      object
+    end
+  end
+end

package/lib/ruby/3.4.11/bundler/vendor/connection_pool/lib/connection_pool/version.rb

@@ -0,0 +1,3 @@
+class Bundler::ConnectionPool
+  VERSION = "2.5.0"
+end

package/lib/ruby/3.4.11/bundler/vendor/connection_pool/lib/connection_pool/wrapper.rb

@@ -0,0 +1,56 @@
+class Bundler::ConnectionPool
+  class Wrapper < ::BasicObject
+    METHODS = [:with, :pool_shutdown, :wrapped_pool]
+
+    def initialize(options = {}, &block)
+      @pool = options.fetch(:pool) { ::Bundler::ConnectionPool.new(options, &block) }
+    end
+
+    def wrapped_pool
+      @pool
+    end
+
+    def with(&block)
+      @pool.with(&block)
+    end
+
+    def pool_shutdown(&block)
+      @pool.shutdown(&block)
+    end
+
+    def pool_size
+      @pool.size
+    end
+
+    def pool_available
+      @pool.available
+    end
+
+    def respond_to?(id, *args)
+      METHODS.include?(id) || with { |c| c.respond_to?(id, *args) }
+    end
+
+    # rubocop:disable Style/MissingRespondToMissing
+    if ::RUBY_VERSION >= "3.0.0"
+      def method_missing(name, *args, **kwargs, &block)
+        with do |connection|
+          connection.send(name, *args, **kwargs, &block)
+        end
+      end
+    elsif ::RUBY_VERSION >= "2.7.0"
+      ruby2_keywords def method_missing(name, *args, &block)
+        with do |connection|
+          connection.send(name, *args, &block)
+        end
+      end
+    else
+      def method_missing(name, *args, &block)
+        with do |connection|
+          connection.send(name, *args, &block)
+        end
+      end
+    end
+    # rubocop:enable Style/MethodMissingSuper
+    # rubocop:enable Style/MissingRespondToMissing
+  end
+end