rubygems-update 3.4.10 → 3.5.22

data/lib/rubygems/vendor/uri/lib/uri/rfc3986_parser.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+module Gem::URI
+  class RFC3986_Parser # :nodoc:
+    # Gem::URI defined in RFC3986
+    HOST = %r[
+      (?<IP-literal>\[(?:
+          (?<IPv6address>
+            (?:\h{1,4}:){6}
+            (?<ls32>\h{1,4}:\h{1,4}
+            | (?<IPv4address>(?<dec-octet>[1-9]\d|1\d{2}|2[0-4]\d|25[0-5]|\d)
+                \.\g<dec-octet>\.\g<dec-octet>\.\g<dec-octet>)
+            )
+          | ::(?:\h{1,4}:){5}\g<ls32>
+          | \h{1,4}?::(?:\h{1,4}:){4}\g<ls32>
+          | (?:(?:\h{1,4}:)?\h{1,4})?::(?:\h{1,4}:){3}\g<ls32>
+          | (?:(?:\h{1,4}:){,2}\h{1,4})?::(?:\h{1,4}:){2}\g<ls32>
+          | (?:(?:\h{1,4}:){,3}\h{1,4})?::\h{1,4}:\g<ls32>
+          | (?:(?:\h{1,4}:){,4}\h{1,4})?::\g<ls32>
+          | (?:(?:\h{1,4}:){,5}\h{1,4})?::\h{1,4}
+          | (?:(?:\h{1,4}:){,6}\h{1,4})?::
+          )
+        | (?<IPvFuture>v\h++\.[!$&-.0-9:;=A-Z_a-z~]++)
+        )\])
+    | \g<IPv4address>
+    | (?<reg-name>(?:%\h\h|[!$&-.0-9;=A-Z_a-z~])*+)
+    ]x
+
+    USERINFO = /(?:%\h\h|[!$&-.0-9:;=A-Z_a-z~])*+/
+
+    SCHEME = %r[[A-Za-z][+\-.0-9A-Za-z]*+].source
+    SEG = %r[(?:%\h\h|[!$&-.0-9:;=@A-Z_a-z~/])].source
+    SEG_NC = %r[(?:%\h\h|[!$&-.0-9;=@A-Z_a-z~])].source
+    FRAGMENT = %r[(?:%\h\h|[!$&-.0-9:;=@A-Z_a-z~/?])*+].source
+
+    RFC3986_URI = %r[\A
+    (?<seg>#{SEG}){0}
+    (?<Gem::URI>
+      (?<scheme>#{SCHEME}):
+      (?<hier-part>//
+        (?<authority>
+          (?:(?<userinfo>#{USERINFO.source})@)?
+          (?<host>#{HOST.source.delete(" \n")})
+          (?::(?<port>\d*+))?
+        )
+        (?<path-abempty>(?:/\g<seg>*+)?)
+      | (?<path-absolute>/((?!/)\g<seg>++)?)
+      | (?<path-rootless>(?!/)\g<seg>++)
+      | (?<path-empty>)
+      )
+      (?:\?(?<query>[^\#]*+))?
+      (?:\#(?<fragment>#{FRAGMENT}))?
+    )\z]x
+
+    RFC3986_relative_ref = %r[\A
+    (?<seg>#{SEG}){0}
+    (?<relative-ref>
+      (?<relative-part>//
+        (?<authority>
+          (?:(?<userinfo>#{USERINFO.source})@)?
+          (?<host>#{HOST.source.delete(" \n")}(?<!/))?
+          (?::(?<port>\d*+))?
+        )
+        (?<path-abempty>(?:/\g<seg>*+)?)
+      | (?<path-absolute>/\g<seg>*+)
+      | (?<path-noscheme>#{SEG_NC}++(?:/\g<seg>*+)?)
+      | (?<path-empty>)
+      )
+      (?:\?(?<query>[^#]*+))?
+      (?:\#(?<fragment>#{FRAGMENT}))?
+    )\z]x
+    attr_reader :regexp
+
+    def initialize
+      @regexp = default_regexp.each_value(&:freeze).freeze
+    end
+
+    def split(uri) #:nodoc:
+      begin
+        uri = uri.to_str
+      rescue NoMethodError
+        raise InvalidURIError, "bad Gem::URI(is not Gem::URI?): #{uri.inspect}"
+      end
+      uri.ascii_only? or
+        raise InvalidURIError, "Gem::URI must be ascii only #{uri.dump}"
+      if m = RFC3986_URI.match(uri)
+        query = m["query"]
+        scheme = m["scheme"]
+        opaque = m["path-rootless"]
+        if opaque
+          opaque << "?#{query}" if query
+          [ scheme,
+            nil, # userinfo
+            nil, # host
+            nil, # port
+            nil, # registry
+            nil, # path
+            opaque,
+            nil, # query
+            m["fragment"]
+          ]
+        else # normal
+          [ scheme,
+            m["userinfo"],
+            m["host"],
+            m["port"],
+            nil, # registry
+            (m["path-abempty"] ||
+             m["path-absolute"] ||
+             m["path-empty"]),
+            nil, # opaque
+            query,
+            m["fragment"]
+          ]
+        end
+      elsif m = RFC3986_relative_ref.match(uri)
+        [ nil, # scheme
+          m["userinfo"],
+          m["host"],
+          m["port"],
+          nil, # registry,
+          (m["path-abempty"] ||
+           m["path-absolute"] ||
+           m["path-noscheme"] ||
+           m["path-empty"]),
+          nil, # opaque
+          m["query"],
+          m["fragment"]
+        ]
+      else
+        raise InvalidURIError, "bad Gem::URI(is not Gem::URI?): #{uri.inspect}"
+      end
+    end
+
+    def parse(uri) # :nodoc:
+      Gem::URI.for(*self.split(uri), self)
+    end
+
+
+    def join(*uris) # :nodoc:
+      uris[0] = convert_to_uri(uris[0])
+      uris.inject :merge
+    end
+
+    @@to_s = Kernel.instance_method(:to_s)
+    if @@to_s.respond_to?(:bind_call)
+      def inspect
+        @@to_s.bind_call(self)
+      end
+    else
+      def inspect
+        @@to_s.bind(self).call
+      end
+    end
+
+    private
+
+    def default_regexp # :nodoc:
+      {
+        SCHEME: %r[\A#{SCHEME}\z]o,
+        USERINFO: %r[\A#{USERINFO}\z]o,
+        HOST: %r[\A#{HOST}\z]o,
+        ABS_PATH: %r[\A/#{SEG}*+\z]o,
+        REL_PATH: %r[\A(?!/)#{SEG}++\z]o,
+        QUERY: %r[\A(?:%\h\h|[!$&-.0-9:;=@A-Z_a-z~/?])*+\z],
+        FRAGMENT: %r[\A#{FRAGMENT}\z]o,
+        OPAQUE: %r[\A(?:[^/].*)?\z],
+        PORT: /\A[\x09\x0a\x0c\x0d ]*+\d*[\x09\x0a\x0c\x0d ]*\z/,
+      }
+    end
+
+    def convert_to_uri(uri)
+      if uri.is_a?(Gem::URI::Generic)
+        uri
+      elsif uri = String.try_convert(uri)
+        parse(uri)
+      else
+        raise ArgumentError,
+          "bad argument (expected Gem::URI object or Gem::URI string)"
+      end
+    end
+
+  end # class Parser
+end # module Gem::URI

data/lib/rubygems/vendor/uri/lib/uri/version.rb

@@ -0,0 +1,6 @@
+module Gem::URI
+  # :stopdoc:
+  VERSION_CODE = '001301'.freeze
+  VERSION = VERSION_CODE.scan(/../).collect{|n| n.to_i}.join('.').freeze
+  # :startdoc:
+end

data/lib/rubygems/vendor/uri/lib/uri/ws.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: false
+# = uri/ws.rb
+#
+# Author:: Matt Muller <mamuller@amazon.com>
+# License:: You can redistribute it and/or modify it under the same term as Ruby.
+#
+# See Gem::URI for general documentation
+#
+
+require_relative 'generic'
+
+module Gem::URI
+
+  #
+  # The syntax of WS URIs is defined in RFC6455 section 3.
+  #
+  # Note that the Ruby Gem::URI library allows WS URLs containing usernames and
+  # passwords. This is not legal as per the RFC, but used to be
+  # supported in Internet Explorer 5 and 6, before the MS04-004 security
+  # update. See <URL:http://support.microsoft.com/kb/834489>.
+  #
+  class WS < Generic
+    # A Default port of 80 for Gem::URI::WS.
+    DEFAULT_PORT = 80
+
+    # An Array of the available components for Gem::URI::WS.
+    COMPONENT = %i[
+      scheme
+      userinfo host port
+      path
+      query
+    ].freeze
+
+    #
+    # == Description
+    #
+    # Creates a new Gem::URI::WS object from components, with syntax checking.
+    #
+    # The components accepted are userinfo, host, port, path, and query.
+    #
+    # The components should be provided either as an Array, or as a Hash
+    # with keys formed by preceding the component names with a colon.
+    #
+    # If an Array is used, the components must be passed in the
+    # order <code>[userinfo, host, port, path, query]</code>.
+    #
+    # Example:
+    #
+    #     uri = Gem::URI::WS.build(host: 'www.example.com', path: '/foo/bar')
+    #
+    #     uri = Gem::URI::WS.build([nil, "www.example.com", nil, "/path", "query"])
+    #
+    # Currently, if passed userinfo components this method generates
+    # invalid WS URIs as per RFC 1738.
+    #
+    def self.build(args)
+      tmp = Util.make_components_hash(self, args)
+      super(tmp)
+    end
+
+    #
+    # == Description
+    #
+    # Returns the full path for a WS Gem::URI, as required by Net::HTTP::Get.
+    #
+    # If the Gem::URI contains a query, the full path is Gem::URI#path + '?' + Gem::URI#query.
+    # Otherwise, the path is simply Gem::URI#path.
+    #
+    # Example:
+    #
+    #     uri = Gem::URI::WS.build(path: '/foo/bar', query: 'test=true')
+    #     uri.request_uri #  => "/foo/bar?test=true"
+    #
+    def request_uri
+      return unless @path
+
+      url = @query ? "#@path?#@query" : @path.dup
+      url.start_with?(?/.freeze) ? url : ?/ + url
+    end
+  end
+
+  register_scheme 'WS', WS
+end

data/lib/rubygems/vendor/uri/lib/uri/wss.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: false
+# = uri/wss.rb
+#
+# Author:: Matt Muller <mamuller@amazon.com>
+# License:: You can redistribute it and/or modify it under the same term as Ruby.
+#
+# See Gem::URI for general documentation
+#
+
+require_relative 'ws'
+
+module Gem::URI
+
+  # The default port for WSS URIs is 443, and the scheme is 'wss:' rather
+  # than 'ws:'. Other than that, WSS URIs are identical to WS URIs;
+  # see Gem::URI::WS.
+  class WSS < WS
+    # A Default port of 443 for Gem::URI::WSS
+    DEFAULT_PORT = 443
+  end
+
+  register_scheme 'WSS', WSS
+end

data/lib/rubygems/vendor/uri/lib/uri.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: false
+# Gem::URI is a module providing classes to handle Uniform Resource Identifiers
+# (RFC2396[http://tools.ietf.org/html/rfc2396]).
+#
+# == Features
+#
+# * Uniform way of handling URIs.
+# * Flexibility to introduce custom Gem::URI schemes.
+# * Flexibility to have an alternate Gem::URI::Parser (or just different patterns
+#   and regexp's).
+#
+# == Basic example
+#
+#   require 'rubygems/vendor/uri/lib/uri'
+#
+#   uri = Gem::URI("http://foo.com/posts?id=30&limit=5#time=1305298413")
+#   #=> #<Gem::URI::HTTP http://foo.com/posts?id=30&limit=5#time=1305298413>
+#
+#   uri.scheme    #=> "http"
+#   uri.host      #=> "foo.com"
+#   uri.path      #=> "/posts"
+#   uri.query     #=> "id=30&limit=5"
+#   uri.fragment  #=> "time=1305298413"
+#
+#   uri.to_s      #=> "http://foo.com/posts?id=30&limit=5#time=1305298413"
+#
+# == Adding custom URIs
+#
+#   module Gem::URI
+#     class RSYNC < Generic
+#       DEFAULT_PORT = 873
+#     end
+#     register_scheme 'RSYNC', RSYNC
+#   end
+#   #=> Gem::URI::RSYNC
+#
+#   Gem::URI.scheme_list
+#   #=> {"FILE"=>Gem::URI::File, "FTP"=>Gem::URI::FTP, "HTTP"=>Gem::URI::HTTP,
+#   #    "HTTPS"=>Gem::URI::HTTPS, "LDAP"=>Gem::URI::LDAP, "LDAPS"=>Gem::URI::LDAPS,
+#   #    "MAILTO"=>Gem::URI::MailTo, "RSYNC"=>Gem::URI::RSYNC}
+#
+#   uri = Gem::URI("rsync://rsync.foo.com")
+#   #=> #<Gem::URI::RSYNC rsync://rsync.foo.com>
+#
+# == RFC References
+#
+# A good place to view an RFC spec is http://www.ietf.org/rfc.html.
+#
+# Here is a list of all related RFC's:
+# - RFC822[http://tools.ietf.org/html/rfc822]
+# - RFC1738[http://tools.ietf.org/html/rfc1738]
+# - RFC2255[http://tools.ietf.org/html/rfc2255]
+# - RFC2368[http://tools.ietf.org/html/rfc2368]
+# - RFC2373[http://tools.ietf.org/html/rfc2373]
+# - RFC2396[http://tools.ietf.org/html/rfc2396]
+# - RFC2732[http://tools.ietf.org/html/rfc2732]
+# - RFC3986[http://tools.ietf.org/html/rfc3986]
+#
+# == Class tree
+#
+# - Gem::URI::Generic (in uri/generic.rb)
+#   - Gem::URI::File - (in uri/file.rb)
+#   - Gem::URI::FTP - (in uri/ftp.rb)
+#   - Gem::URI::HTTP - (in uri/http.rb)
+#     - Gem::URI::HTTPS - (in uri/https.rb)
+#   - Gem::URI::LDAP - (in uri/ldap.rb)
+#     - Gem::URI::LDAPS - (in uri/ldaps.rb)
+#   - Gem::URI::MailTo - (in uri/mailto.rb)
+# - Gem::URI::Parser - (in uri/common.rb)
+# - Gem::URI::REGEXP - (in uri/common.rb)
+#   - Gem::URI::REGEXP::PATTERN - (in uri/common.rb)
+# - Gem::URI::Util - (in uri/common.rb)
+# - Gem::URI::Error - (in uri/common.rb)
+#   - Gem::URI::InvalidURIError - (in uri/common.rb)
+#   - Gem::URI::InvalidComponentError - (in uri/common.rb)
+#   - Gem::URI::BadURIError - (in uri/common.rb)
+#
+# == Copyright Info
+#
+# Author:: Akira Yamada <akira@ruby-lang.org>
+# Documentation::
+#   Akira Yamada <akira@ruby-lang.org>
+#   Dmitry V. Sabanin <sdmitry@lrn.ru>
+#   Vincent Batts <vbatts@hashbangbash.com>
+# License::
+#  Copyright (c) 2001 akira yamada <akira@ruby-lang.org>
+#  You can redistribute it and/or modify it under the same term as Ruby.
+#
+
+module Gem::URI
+end
+
+require_relative 'uri/version'
+require_relative 'uri/common'
+require_relative 'uri/generic'
+require_relative 'uri/file'
+require_relative 'uri/ftp'
+require_relative 'uri/http'
+require_relative 'uri/https'
+require_relative 'uri/ldap'
+require_relative 'uri/ldaps'
+require_relative 'uri/mailto'
+require_relative 'uri/ws'
+require_relative 'uri/wss'

data/lib/rubygems/vendored_molinillo.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "vendor/molinillo/lib/molinillo"

data/lib/rubygems/vendored_net_http.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# Ruby 3.3 and RubyGems 3.5 is already load Gem::Timeout from lib/rubygems/net/http.rb
+# We should avoid to load it again
+require_relative "vendor/net-http/lib/net/http" unless defined?(Gem::Net::HTTP)

data/lib/rubygems/vendored_optparse.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "vendor/optparse/lib/optparse"

data/lib/rubygems/vendored_securerandom.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module Gem::Random; end
+require_relative "vendor/securerandom/lib/securerandom"

data/lib/rubygems/vendored_timeout.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# Ruby 3.3 and RubyGems 3.5 is already load Gem::Timeout from lib/rubygems/timeout.rb
+# We should avoid to load it again
+require_relative "vendor/timeout/lib/timeout" unless defined?(Gem::Timeout)

data/lib/rubygems/vendored_tsort.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "vendor/tsort/lib/tsort"

data/lib/rubygems/version.rb

@@ -131,7 +131,7 @@ require_relative "deprecate"
 #
 # == Preventing Version Catastrophe:
 #
-# From: http://blog.zenspider.com/2008/10/rubygems-howto-preventing-cata.html
+# From: https://www.zenspider.com/ruby/2008/10/rubygems-how-to-preventing-catastrophe.html
 #
 # Let's say you're depending on the fnord gem version 2.y.z. If you
 # specify your dependency as ">= 2.0.0" then, you're good, right? What
@@ -156,16 +156,16 @@ class Gem::Version
   include Comparable
 
   VERSION_PATTERN = '[0-9]+(?>\.[0-9a-zA-Z]+)*(-[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?' # :nodoc:
-  ANCHORED_VERSION_PATTERN = /\A\s*(#{VERSION_PATTERN})?\s*\z/.freeze # :nodoc:
+  ANCHORED_VERSION_PATTERN = /\A\s*(#{VERSION_PATTERN})?\s*\z/ # :nodoc:
 
   ##
   # A string representation of this Version.
 
   def version
-    @version.dup
+    @version
   end
 
-  alias to_s version
+  alias_method :to_s, :version
 
   ##
   # True if the +version+ string matches RubyGems' requirements.
@@ -173,7 +173,7 @@ class Gem::Version
   def self.correct?(version)
     nil_versions_are_discouraged! if version.nil?
 
-    !!(version.to_s =~ ANCHORED_VERSION_PATTERN)
+    ANCHORED_VERSION_PATTERN.match?(version.to_s)
   end
 
   ##
@@ -201,7 +201,7 @@ class Gem::Version
   @@release = {}
 
   def self.new(version) # :nodoc:
-    return super unless Gem::Version == self
+    return super unless self == Gem::Version
 
     @@all[version] ||= super
   end
@@ -224,9 +224,17 @@ class Gem::Version
     end
 
     # If version is an empty string convert it to 0
-    version = 0 if version.is_a?(String) && version =~ /\A\s*\Z/
+    version = 0 if version.is_a?(String) && /\A\s*\Z/.match?(version)
+
+    @version = version.to_s
 
-    @version = version.to_s.strip.gsub("-",".pre.")
+    # optimization to avoid allocation when given an integer, since we know
+    # it's to_s won't have any spaces or dashes
+    unless version.is_a?(Integer)
+      @version = @version.strip
+      @version.gsub!("-",".pre.")
+    end
+    @version = -@version
     @segments = nil
   end
 
@@ -252,7 +260,7 @@ class Gem::Version
   # same precision. Version "1.0" is not the same as version "1".
 
   def eql?(other)
-    self.class === other && @version == other._version
+    self.class === other && @version == other.version
   end
 
   def hash # :nodoc:
@@ -284,7 +292,7 @@ class Gem::Version
   end
 
   def yaml_initialize(tag, map) # :nodoc:
-    @version = map["version"]
+    @version = -map["version"]
     @segments = nil
     @hash = nil
   end
@@ -302,7 +310,7 @@ class Gem::Version
 
   def prerelease?
     unless instance_variable_defined? :@prerelease
-      @prerelease = !!(@version =~ /[a-zA-Z]/)
+      @prerelease = /[a-zA-Z]/.match?(version)
     end
     @prerelease
   end
@@ -354,7 +362,7 @@ class Gem::Version
     return self <=> self.class.new(other) if (String === other) && self.class.correct?(other)
 
     return unless Gem::Version === other
-    return 0 if @version == other._version || canonical_segments == other.canonical_segments
+    return 0 if @version == other.version || canonical_segments == other.canonical_segments
 
     lhsegments = canonical_segments
     rhsegments = other.canonical_segments
@@ -366,7 +374,8 @@ class Gem::Version
     i = 0
 
     while i <= limit
-      lhs, rhs = lhsegments[i] || 0, rhsegments[i] || 0
+      lhs = lhsegments[i] || 0
+      rhs = rhsegments[i] || 0
       i += 1
 
       next      if lhs == rhs
@@ -376,42 +385,40 @@ class Gem::Version
       return lhs <=> rhs
     end
 
-    return 0
+    0
   end
 
+  # remove trailing zeros segments before first letter or at the end of the version
   def canonical_segments
-    @canonical_segments ||=
-      _split_segments.map! do |segments|
-        segments.reverse_each.drop_while {|s| s == 0 }.reverse
-      end.reduce(&:concat)
+    @canonical_segments ||= begin
+      # remove trailing 0 segments, using dot or letter as anchor
+      # may leave a trailing dot which will be ignored by partition_segments
+      canonical_version = @version.sub(/(?<=[a-zA-Z.])[.0]+\z/, "")
+      # remove 0 segments before the first letter in a prerelease version
+      canonical_version.sub!(/(?<=\.|\A)[0.]+(?=[a-zA-Z])/, "") if prerelease?
+      partition_segments(canonical_version)
+    end
   end
 
   def freeze
     prerelease?
+    _segments
     canonical_segments
     super
   end
 
   protected
 
-  def _version
-    @version
-  end
-
   def _segments
     # segments is lazy so it can pick up version values that come from
     # old marshaled versions, which don't go through marshal_load.
     # since this version object is cached in @@all, its @segments should be frozen
-
-    @segments ||= @version.scan(/[0-9]+|[a-z]+/i).map do |s|
-      /^\d+$/ =~ s ? s.to_i : s
-    end.freeze
+    @segments ||= partition_segments(@version)
   end
 
-  def _split_segments
-    string_start = _segments.index {|s| s.is_a?(String) }
-    string_segments = segments
-    numeric_segments = string_segments.slice!(0, string_start || string_segments.size)
-    return numeric_segments, string_segments
+  def partition_segments(ver)
+    ver.scan(/\d+|[a-z]+/i).map! do |s|
+      /\A\d/.match?(s) ? s.to_i : -s
+    end.freeze
   end
 end

data/lib/rubygems/version_option.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 #--
 # Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
 # All rights reserved.
@@ -11,7 +12,6 @@ require_relative "../rubygems"
 # Mixin methods for --version and --platform Gem::Command options.
 
 module Gem::VersionOption
-
   ##
   # Add the --platform option to the option parser.
 
@@ -25,8 +25,7 @@ module Gem::VersionOption
     end
 
     add_option("--platform PLATFORM", Gem::Platform,
-               "Specify the platform of gem to #{task}", *wrap) do
-                 |value, options|
+               "Specify the platform of gem to #{task}", *wrap) do |value, options|
       unless options[:added_platform]
         Gem.platforms = [Gem::Platform::RUBY]
         options[:added_platform] = true
@@ -56,8 +55,7 @@ module Gem::VersionOption
     end
 
     add_option("-v", "--version VERSION", Gem::Requirement,
-               "Specify version of gem to #{task}", *wrap) do
-                 |value, options|
+               "Specify version of gem to #{task}", *wrap) do |value, options|
       # Allow handling for multiple --version operators
       if options[:version] && !options[:version].none?
         options[:version].concat([value])