@ai-ecoverse/wasix-ruby 3.4.11-3 → 3.4.11-4

package/lib/ruby/3.4.11/rubygems/vendor/molinillo/lib/molinillo/resolver.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'dependency_graph'
-
-module Gem::Molinillo
-  # This class encapsulates a dependency resolver.
-  # The resolver is responsible for determining which set of dependencies to
-  # activate, with feedback from the {#specification_provider}
-  #
-  #
-  class Resolver
-    require_relative 'resolution'
-
-    # @return [SpecificationProvider] the specification provider used
-    #   in the resolution process
-    attr_reader :specification_provider
-
-    # @return [UI] the UI module used to communicate back to the user
-    #   during the resolution process
-    attr_reader :resolver_ui
-
-    # Initializes a new resolver.
-    # @param  [SpecificationProvider] specification_provider
-    #   see {#specification_provider}
-    # @param  [UI] resolver_ui
-    #   see {#resolver_ui}
-    def initialize(specification_provider, resolver_ui)
-      @specification_provider = specification_provider
-      @resolver_ui = resolver_ui
-    end
-
-    # Resolves the requested dependencies into a {DependencyGraph},
-    # locking to the base dependency graph (if specified)
-    # @param [Array] requested an array of 'requested' dependencies that the
-    #   {#specification_provider} can understand
-    # @param [DependencyGraph,nil] base the base dependency graph to which
-    #   dependencies should be 'locked'
-    def resolve(requested, base = DependencyGraph.new)
-      Resolution.new(specification_provider,
-                     resolver_ui,
-                     requested,
-                     base).
-        resolve
-    end
-  end
-end

package/lib/ruby/3.4.11/rubygems/vendor/molinillo/lib/molinillo/state.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-module Gem::Molinillo
-  # A state that a {Resolution} can be in
-  # @attr [String] name the name of the current requirement
-  # @attr [Array<Object>] requirements currently unsatisfied requirements
-  # @attr [DependencyGraph] activated the graph of activated dependencies
-  # @attr [Object] requirement the current requirement
-  # @attr [Object] possibilities the possibilities to satisfy the current requirement
-  # @attr [Integer] depth the depth of the resolution
-  # @attr [Hash] conflicts unresolved conflicts, indexed by dependency name
-  # @attr [Array<UnwindDetails>] unused_unwind_options unwinds for previous conflicts that weren't explored
-  ResolutionState = Struct.new(
-    :name,
-    :requirements,
-    :activated,
-    :requirement,
-    :possibilities,
-    :depth,
-    :conflicts,
-    :unused_unwind_options
-  )
-
-  class ResolutionState
-    # Returns an empty resolution state
-    # @return [ResolutionState] an empty state
-    def self.empty
-      new(nil, [], DependencyGraph.new, nil, nil, 0, {}, [])
-    end
-  end
-
-  # A state that encapsulates a set of {#requirements} with an {Array} of
-  # possibilities
-  class DependencyState < ResolutionState
-    # Removes a possibility from `self`
-    # @return [PossibilityState] a state with a single possibility,
-    #  the possibility that was removed from `self`
-    def pop_possibility_state
-      PossibilityState.new(
-        name,
-        requirements.dup,
-        activated,
-        requirement,
-        [possibilities.pop],
-        depth + 1,
-        conflicts.dup,
-        unused_unwind_options.dup
-      ).tap do |state|
-        state.activated.tag(state)
-      end
-    end
-  end
-
-  # A state that encapsulates a single possibility to fulfill the given
-  # {#requirement}
-  class PossibilityState < ResolutionState
-  end
-end

package/lib/ruby/3.4.11/rubygems/vendor/molinillo/lib/molinillo.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'molinillo/gem_metadata'
-require_relative 'molinillo/errors'
-require_relative 'molinillo/resolver'
-require_relative 'molinillo/modules/ui'
-require_relative 'molinillo/modules/specification_provider'
-
-# Gem::Molinillo is a generic dependency resolution algorithm.
-module Gem::Molinillo
-end

package/lib/ruby/3.4.11/rubygems/vendor/net-http/.document

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

package/lib/ruby/3.4.11/rubygems/vendor/net-http/lib/net/http/exceptions.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-module Gem::Net
-  # Gem::Net::HTTP exception class.
-  # You cannot use Gem::Net::HTTPExceptions directly; instead, you must use
-  # its subclasses.
-  module HTTPExceptions
-    def initialize(msg, res)   #:nodoc:
-      super msg
-      @response = res
-    end
-    attr_reader :response
-    alias data response    #:nodoc: obsolete
-  end
-
-  class HTTPError < ProtocolError
-    include HTTPExceptions
-  end
-
-  class HTTPRetriableError < ProtoRetriableError
-    include HTTPExceptions
-  end
-
-  class HTTPClientException < ProtoServerError
-    include HTTPExceptions
-  end
-
-  class HTTPFatalError < ProtoFatalError
-    include HTTPExceptions
-  end
-
-  # We cannot use the name "HTTPServerError", it is the name of the response.
-  HTTPServerException = HTTPClientException # :nodoc:
-  deprecate_constant(:HTTPServerException)
-end

package/lib/ruby/3.4.11/rubygems/vendor/net-http/lib/net/http/generic_request.rb

@@ -1,414 +0,0 @@
-# frozen_string_literal: true
-#
-# \HTTPGenericRequest is the parent of the Gem::Net::HTTPRequest class.
-#
-# Do not use this directly; instead, use a subclass of Gem::Net::HTTPRequest.
-#
-# == About the Examples
-#
-# :include: doc/net-http/examples.rdoc
-#
-class Gem::Net::HTTPGenericRequest
-
-  include Gem::Net::HTTPHeader
-
-  def initialize(m, reqbody, resbody, uri_or_path, initheader = nil) # :nodoc:
-    @method = m
-    @request_has_body = reqbody
-    @response_has_body = resbody
-
-    if Gem::URI === uri_or_path then
-      raise ArgumentError, "not an HTTP Gem::URI" unless Gem::URI::HTTP === uri_or_path
-      hostname = uri_or_path.hostname
-      raise ArgumentError, "no host component for Gem::URI" unless (hostname && hostname.length > 0)
-      @uri = uri_or_path.dup
-      host = @uri.hostname.dup
-      host << ":" << @uri.port.to_s if @uri.port != @uri.default_port
-      @path = uri_or_path.request_uri
-      raise ArgumentError, "no HTTP request path given" unless @path
-    else
-      @uri = nil
-      host = nil
-      raise ArgumentError, "no HTTP request path given" unless uri_or_path
-      raise ArgumentError, "HTTP request path is empty" if uri_or_path.empty?
-      @path = uri_or_path.dup
-    end
-
-    @decode_content = false
-
-    if Gem::Net::HTTP::HAVE_ZLIB then
-      if !initheader ||
-         !initheader.keys.any? { |k|
-           %w[accept-encoding range].include? k.downcase
-         } then
-        @decode_content = true if @response_has_body
-        initheader = initheader ? initheader.dup : {}
-        initheader["accept-encoding"] =
-          "gzip;q=1.0,deflate;q=0.6,identity;q=0.3"
-      end
-    end
-
-    initialize_http_header initheader
-    self['Accept'] ||= '*/*'
-    self['User-Agent'] ||= 'Ruby'
-    self['Host'] ||= host if host
-    @body = nil
-    @body_stream = nil
-    @body_data = nil
-  end
-
-  # Returns the string method name for the request:
-  #
-  #   Gem::Net::HTTP::Get.new(uri).method  # => "GET"
-  #   Gem::Net::HTTP::Post.new(uri).method # => "POST"
-  #
-  attr_reader :method
-
-  # Returns the string path for the request:
-  #
-  #   Gem::Net::HTTP::Get.new(uri).path # => "/"
-  #   Gem::Net::HTTP::Post.new('example.com').path # => "example.com"
-  #
-  attr_reader :path
-
-  # Returns the Gem::URI object for the request, or +nil+ if none:
-  #
-  #   Gem::Net::HTTP::Get.new(uri).uri
-  #   # => #<Gem::URI::HTTPS https://jsonplaceholder.typicode.com/>
-  #   Gem::Net::HTTP::Get.new('example.com').uri # => nil
-  #
-  attr_reader :uri
-
-  # Returns +false+ if the request's header <tt>'Accept-Encoding'</tt>
-  # has been set manually or deleted
-  # (indicating that the user intends to handle encoding in the response),
-  # +true+ otherwise:
-  #
-  #   req = Gem::Net::HTTP::Get.new(uri) # => #<Gem::Net::HTTP::Get GET>
-  #   req['Accept-Encoding']        # => "gzip;q=1.0,deflate;q=0.6,identity;q=0.3"
-  #   req.decode_content            # => true
-  #   req['Accept-Encoding'] = 'foo'
-  #   req.decode_content            # => false
-  #   req.delete('Accept-Encoding')
-  #   req.decode_content            # => false
-  #
-  attr_reader :decode_content
-
-  # Returns a string representation of the request:
-  #
-  #   Gem::Net::HTTP::Post.new(uri).inspect # => "#<Gem::Net::HTTP::Post POST>"
-  #
-  def inspect
-    "\#<#{self.class} #{@method}>"
-  end
-
-  ##
-  # Don't automatically decode response content-encoding if the user indicates
-  # they want to handle it.
-
-  def []=(key, val) # :nodoc:
-    @decode_content = false if key.downcase == 'accept-encoding'
-
-    super key, val
-  end
-
-  # Returns whether the request may have a body:
-  #
-  #   Gem::Net::HTTP::Post.new(uri).request_body_permitted? # => true
-  #   Gem::Net::HTTP::Get.new(uri).request_body_permitted?  # => false
-  #
-  def request_body_permitted?
-    @request_has_body
-  end
-
-  # Returns whether the response may have a body:
-  #
-  #   Gem::Net::HTTP::Post.new(uri).response_body_permitted? # => true
-  #   Gem::Net::HTTP::Head.new(uri).response_body_permitted? # => false
-  #
-  def response_body_permitted?
-    @response_has_body
-  end
-
-  def body_exist? # :nodoc:
-    warn "Gem::Net::HTTPRequest#body_exist? is obsolete; use response_body_permitted?", uplevel: 1 if $VERBOSE
-    response_body_permitted?
-  end
-
-  # Returns the string body for the request, or +nil+ if there is none:
-  #
-  #   req = Gem::Net::HTTP::Post.new(uri)
-  #   req.body # => nil
-  #   req.body = '{"title": "foo","body": "bar","userId": 1}'
-  #   req.body # => "{\"title\": \"foo\",\"body\": \"bar\",\"userId\": 1}"
-  #
-  attr_reader :body
-
-  # Sets the body for the request:
-  #
-  #   req = Gem::Net::HTTP::Post.new(uri)
-  #   req.body # => nil
-  #   req.body = '{"title": "foo","body": "bar","userId": 1}'
-  #   req.body # => "{\"title\": \"foo\",\"body\": \"bar\",\"userId\": 1}"
-  #
-  def body=(str)
-    @body = str
-    @body_stream = nil
-    @body_data = nil
-    str
-  end
-
-  # Returns the body stream object for the request, or +nil+ if there is none:
-  #
-  #   req = Gem::Net::HTTP::Post.new(uri)          # => #<Gem::Net::HTTP::Post POST>
-  #   req.body_stream                         # => nil
-  #   require 'stringio'
-  #   req.body_stream = StringIO.new('xyzzy') # => #<StringIO:0x0000027d1e5affa8>
-  #   req.body_stream                         # => #<StringIO:0x0000027d1e5affa8>
-  #
-  attr_reader :body_stream
-
-  # Sets the body stream for the request:
-  #
-  #   req = Gem::Net::HTTP::Post.new(uri)          # => #<Gem::Net::HTTP::Post POST>
-  #   req.body_stream                         # => nil
-  #   require 'stringio'
-  #   req.body_stream = StringIO.new('xyzzy') # => #<StringIO:0x0000027d1e5affa8>
-  #   req.body_stream                         # => #<StringIO:0x0000027d1e5affa8>
-  #
-  def body_stream=(input)
-    @body = nil
-    @body_stream = input
-    @body_data = nil
-    input
-  end
-
-  def set_body_internal(str)   #:nodoc: internal use only
-    raise ArgumentError, "both of body argument and HTTPRequest#body set" if str and (@body or @body_stream)
-    self.body = str if str
-    if @body.nil? && @body_stream.nil? && @body_data.nil? && request_body_permitted?
-      self.body = ''
-    end
-  end
-
-  #
-  # write
-  #
-
-  def exec(sock, ver, path)   #:nodoc: internal use only
-    if @body
-      send_request_with_body sock, ver, path, @body
-    elsif @body_stream
-      send_request_with_body_stream sock, ver, path, @body_stream
-    elsif @body_data
-      send_request_with_body_data sock, ver, path, @body_data
-    else
-      write_header sock, ver, path
-    end
-  end
-
-  def update_uri(addr, port, ssl) # :nodoc: internal use only
-    # reflect the connection and @path to @uri
-    return unless @uri
-
-    if ssl
-      scheme = 'https'
-      klass = Gem::URI::HTTPS
-    else
-      scheme = 'http'
-      klass = Gem::URI::HTTP
-    end
-
-    if host = self['host']
-      host.sub!(/:.*/m, '')
-    elsif host = @uri.host
-    else
-     host = addr
-    end
-    # convert the class of the Gem::URI
-    if @uri.is_a?(klass)
-      @uri.host = host
-      @uri.port = port
-    else
-      @uri = klass.new(
-        scheme, @uri.userinfo,
-        host, port, nil,
-        @uri.path, nil, @uri.query, nil)
-    end
-  end
-
-  private
-
-  class Chunker #:nodoc:
-    def initialize(sock)
-      @sock = sock
-      @prev = nil
-    end
-
-    def write(buf)
-      # avoid memcpy() of buf, buf can huge and eat memory bandwidth
-      rv = buf.bytesize
-      @sock.write("#{rv.to_s(16)}\r\n", buf, "\r\n")
-      rv
-    end
-
-    def finish
-      @sock.write("0\r\n\r\n")
-    end
-  end
-
-  def send_request_with_body(sock, ver, path, body)
-    self.content_length = body.bytesize
-    delete 'Transfer-Encoding'
-    supply_default_content_type
-    write_header sock, ver, path
-    wait_for_continue sock, ver if sock.continue_timeout
-    sock.write body
-  end
-
-  def send_request_with_body_stream(sock, ver, path, f)
-    unless content_length() or chunked?
-      raise ArgumentError,
-          "Content-Length not given and Transfer-Encoding is not `chunked'"
-    end
-    supply_default_content_type
-    write_header sock, ver, path
-    wait_for_continue sock, ver if sock.continue_timeout
-    if chunked?
-      chunker = Chunker.new(sock)
-      IO.copy_stream(f, chunker)
-      chunker.finish
-    else
-      IO.copy_stream(f, sock)
-    end
-  end
-
-  def send_request_with_body_data(sock, ver, path, params)
-    if /\Amultipart\/form-data\z/i !~ self.content_type
-      self.content_type = 'application/x-www-form-urlencoded'
-      return send_request_with_body(sock, ver, path, Gem::URI.encode_www_form(params))
-    end
-
-    opt = @form_option.dup
-    require 'securerandom' unless defined?(SecureRandom)
-    opt[:boundary] ||= SecureRandom.urlsafe_base64(40)
-    self.set_content_type(self.content_type, boundary: opt[:boundary])
-    if chunked?
-      write_header sock, ver, path
-      encode_multipart_form_data(sock, params, opt)
-    else
-      require 'tempfile'
-      file = Tempfile.new('multipart')
-      file.binmode
-      encode_multipart_form_data(file, params, opt)
-      file.rewind
-      self.content_length = file.size
-      write_header sock, ver, path
-      IO.copy_stream(file, sock)
-      file.close(true)
-    end
-  end
-
-  def encode_multipart_form_data(out, params, opt)
-    charset = opt[:charset]
-    boundary = opt[:boundary]
-    require 'securerandom' unless defined?(SecureRandom)
-    boundary ||= SecureRandom.urlsafe_base64(40)
-    chunked_p = chunked?
-
-    buf = +''
-    params.each do |key, value, h={}|
-      key = quote_string(key, charset)
-      filename =
-        h.key?(:filename) ? h[:filename] :
-        value.respond_to?(:to_path) ? File.basename(value.to_path) :
-        nil
-
-      buf << "--#{boundary}\r\n"
-      if filename
-        filename = quote_string(filename, charset)
-        type = h[:content_type] || 'application/octet-stream'
-        buf << "Content-Disposition: form-data; " \
-          "name=\"#{key}\"; filename=\"#{filename}\"\r\n" \
-          "Content-Type: #{type}\r\n\r\n"
-        if !out.respond_to?(:write) || !value.respond_to?(:read)
-          # if +out+ is not an IO or +value+ is not an IO
-          buf << (value.respond_to?(:read) ? value.read : value)
-        elsif value.respond_to?(:size) && chunked_p
-          # if +out+ is an IO and +value+ is a File, use IO.copy_stream
-          flush_buffer(out, buf, chunked_p)
-          out << "%x\r\n" % value.size if chunked_p
-          IO.copy_stream(value, out)
-          out << "\r\n" if chunked_p
-        else
-          # +out+ is an IO, and +value+ is not a File but an IO
-          flush_buffer(out, buf, chunked_p)
-          1 while flush_buffer(out, value.read(4096), chunked_p)
-        end
-      else
-        # non-file field:
-        #   HTML5 says, "The parts of the generated multipart/form-data
-        #   resource that correspond to non-file fields must not have a
-        #   Content-Type header specified."
-        buf << "Content-Disposition: form-data; name=\"#{key}\"\r\n\r\n"
-        buf << (value.respond_to?(:read) ? value.read : value)
-      end
-      buf << "\r\n"
-    end
-    buf << "--#{boundary}--\r\n"
-    flush_buffer(out, buf, chunked_p)
-    out << "0\r\n\r\n" if chunked_p
-  end
-
-  def quote_string(str, charset)
-    str = str.encode(charset, fallback:->(c){'&#%d;'%c.encode("UTF-8").ord}) if charset
-    str.gsub(/[\\"]/, '\\\\\&')
-  end
-
-  def flush_buffer(out, buf, chunked_p)
-    return unless buf
-    out << "%x\r\n"%buf.bytesize if chunked_p
-    out << buf
-    out << "\r\n" if chunked_p
-    buf.clear
-  end
-
-  def supply_default_content_type
-    return if content_type()
-    warn 'net/http: Content-Type did not set; using application/x-www-form-urlencoded', uplevel: 1 if $VERBOSE
-    set_content_type 'application/x-www-form-urlencoded'
-  end
-
-  ##
-  # Waits up to the continue timeout for a response from the server provided
-  # we're speaking HTTP 1.1 and are expecting a 100-continue response.
-
-  def wait_for_continue(sock, ver)
-    if ver >= '1.1' and @header['expect'] and
-        @header['expect'].include?('100-continue')
-      if sock.io.to_io.wait_readable(sock.continue_timeout)
-        res = Gem::Net::HTTPResponse.read_new(sock)
-        unless res.kind_of?(Gem::Net::HTTPContinue)
-          res.decode_content = @decode_content
-          throw :response, res
-        end
-      end
-    end
-  end
-
-  def write_header(sock, ver, path)
-    reqline = "#{@method} #{path} HTTP/#{ver}"
-    if /[\r\n]/ =~ reqline
-      raise ArgumentError, "A Request-Line must not contain CR or LF"
-    end
-    buf = +''
-    buf << reqline << "\r\n"
-    each_capitalized do |k,v|
-      buf << "#{k}: #{v}\r\n"
-    end
-    buf << "\r\n"
-    sock.write buf
-  end
-
-end
-