rubygems-update 3.4.22 → 3.5.1

data/lib/rubygems/local_remote_options.rb

@@ -13,7 +13,6 @@ require_relative "../rubygems"
 # Mixin methods for local and remote Gem::Command options.
 
 module Gem::LocalRemoteOptions
-
   ##
   # Allows Gem::OptionParser to handle HTTP URIs.
 
@@ -40,17 +39,17 @@ module Gem::LocalRemoteOptions
 
   def add_local_remote_options
     add_option(:"Local/Remote", "-l", "--local",
-               "Restrict operations to the LOCAL domain") do |value, options|
+               "Restrict operations to the LOCAL domain") do |_value, options|
       options[:domain] = :local
     end
 
     add_option(:"Local/Remote", "-r", "--remote",
-      "Restrict operations to the REMOTE domain") do |value, options|
+      "Restrict operations to the REMOTE domain") do |_value, options|
       options[:domain] = :remote
     end
 
     add_option(:"Local/Remote", "-b", "--both",
-               "Allow LOCAL and REMOTE operations") do |value, options|
+               "Allow LOCAL and REMOTE operations") do |_value, options|
       options[:domain] = :both
     end
 
@@ -67,8 +66,7 @@ module Gem::LocalRemoteOptions
   def add_bulk_threshold_option
     add_option(:"Local/Remote", "-B", "--bulk-threshold COUNT",
                "Threshold for switching to bulk",
-               "synchronization (default #{Gem.configuration.bulk_threshold})") do
-      |value, options|
+               "synchronization (default #{Gem.configuration.bulk_threshold})") do |value, _options|
       Gem.configuration.bulk_threshold = value.to_i
     end
   end
@@ -78,7 +76,7 @@ module Gem::LocalRemoteOptions
 
   def add_clear_sources_option
     add_option(:"Local/Remote", "--clear-sources",
-               "Clear the gem sources") do |value, options|
+               "Clear the gem sources") do |_value, options|
       Gem.sources = nil
       options[:sources_cleared] = true
     end
@@ -92,7 +90,7 @@ module Gem::LocalRemoteOptions
 
     add_option(:"Local/Remote", "-p", "--[no-]http-proxy [URL]", URI::HTTP,
                "Use HTTP proxy for remote operations") do |value, options|
-      options[:http_proxy] = (value == false) ? :no_proxy : value
+      options[:http_proxy] = value == false ? :no_proxy : value
       Gem.configuration[:http_proxy] = options[:http_proxy]
     end
   end
@@ -120,7 +118,7 @@ module Gem::LocalRemoteOptions
 
   def add_update_sources_option
     add_option(:Deprecated, "-u", "--[no-]update-sources",
-               "Update local source cache") do |value, options|
+               "Update local source cache") do |value, _options|
       Gem.configuration.update_sources = value
     end
   end
@@ -145,5 +143,4 @@ module Gem::LocalRemoteOptions
   def remote?
     options[:domain] == :remote || options[:domain] == :both
   end
-
 end

data/lib/rubygems/name_tuple.rb

@@ -6,14 +6,12 @@
 # wrap the data returned from the indexes.
 
 class Gem::NameTuple
-  def initialize(name, version, platform="ruby")
+  def initialize(name, version, platform=Gem::Platform::RUBY)
     @name = name
     @version = version
 
-    unless platform.is_a? Gem::Platform
-      platform = "ruby" if !platform || platform.empty?
-    end
-
+    platform &&= platform.to_s
+    platform = Gem::Platform::RUBY if !platform || platform.empty?
     @platform = platform
   end
 
@@ -32,7 +30,7 @@ class Gem::NameTuple
   # [name, version, platform] tuples.
 
   def self.to_basic(list)
-    list.map {|t| t.to_a }
+    list.map(&:to_a)
   end
 
   ##
@@ -49,11 +47,11 @@ class Gem::NameTuple
 
   def full_name
     case @platform
-    when nil, "ruby", ""
+    when nil, "", Gem::Platform::RUBY
       "#{@name}-#{@version}"
     else
       "#{@name}-#{@version}-#{@platform}"
-    end.dup.tap(&Gem::UNTAINT)
+    end
   end
 
   ##
@@ -87,7 +85,7 @@ class Gem::NameTuple
     "#<Gem::NameTuple #{@name}, #{@version}, #{@platform}>"
   end
 
-  alias to_s inspect # :nodoc:
+  alias_method :to_s, :inspect # :nodoc:
 
   def <=>(other)
     [@name, @version, Gem::Platform.sort_priority(@platform)] <=>

data/lib/rubygems/net/http.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "../net-http/lib/net/http"

data/lib/rubygems/net-http/.document

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

data/lib/rubygems/net-http/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (C) 1993-2013 Yukihiro Matsumoto. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/lib/rubygems/net-http/lib/net/http/backward.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+# for backward compatibility
+
+# :enddoc:
+
+class Gem::Net::HTTP
+  ProxyMod = ProxyDelta
+  deprecate_constant :ProxyMod
+end
+
+module Gem::Net::NetPrivate
+  HTTPRequest = ::Gem::Net::HTTPRequest
+  deprecate_constant :HTTPRequest
+end
+
+module Gem::Net
+  HTTPSession = HTTP
+
+  HTTPInformationCode  = HTTPInformation
+  HTTPSuccessCode      = HTTPSuccess
+  HTTPRedirectionCode  = HTTPRedirection
+  HTTPRetriableCode    = HTTPRedirection
+  HTTPClientErrorCode  = HTTPClientError
+  HTTPFatalErrorCode   = HTTPClientError
+  HTTPServerErrorCode  = HTTPServerError
+  HTTPResponseReceiver = HTTPResponse
+
+  HTTPResponceReceiver = HTTPResponse # Typo since 2001
+
+  deprecate_constant :HTTPSession,
+                     :HTTPInformationCode,
+                     :HTTPSuccessCode,
+                     :HTTPRedirectionCode,
+                     :HTTPRetriableCode,
+                     :HTTPClientErrorCode,
+                     :HTTPFatalErrorCode,
+                     :HTTPServerErrorCode,
+                     :HTTPResponseReceiver,
+                     :HTTPResponceReceiver
+end

data/lib/rubygems/net-http/lib/net/http/exceptions.rb

@@ -0,0 +1,34 @@
+# 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

data/lib/rubygems/net-http/lib/net/http/generic_request.rb

@@ -0,0 +1,414 @@
+# 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 URI === uri_or_path then
+      raise ArgumentError, "not an HTTP URI" unless URI::HTTP === uri_or_path
+      hostname = uri_or_path.hostname
+      raise ArgumentError, "no host component for 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 URI object for the request, or +nil+ if none:
+  #
+  #   Gem::Net::HTTP::Get.new(uri).uri
+  #   # => #<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 = URI::HTTPS
+    else
+      scheme = 'http'
+      klass = URI::HTTP
+    end
+
+    if host = self['host']
+      host.sub!(/:.*/m, '')
+    elsif host = @uri.host
+    else
+     host = addr
+    end
+    # convert the class of the 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, 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
+