rubygems-update 3.5.3 → 3.7.1

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

@@ -0,0 +1,206 @@
+# 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
+
+    # Compatibility for RFC2396 parser
+    def extract(str, schemes = nil, &block) # :nodoc:
+      warn "Gem::URI::RFC3986_PARSER.extract is obsolete. Use Gem::URI::RFC2396_PARSER.extract explicitly.", uplevel: 1 if $VERBOSE
+      RFC2396_PARSER.extract(str, schemes, &block)
+    end
+
+    # Compatibility for RFC2396 parser
+    def make_regexp(schemes = nil) # :nodoc:
+      warn "Gem::URI::RFC3986_PARSER.make_regexp is obsolete. Use Gem::URI::RFC2396_PARSER.make_regexp explicitly.", uplevel: 1 if $VERBOSE
+      RFC2396_PARSER.make_regexp(schemes)
+    end
+
+    # Compatibility for RFC2396 parser
+    def escape(str, unsafe = nil) # :nodoc:
+      warn "Gem::URI::RFC3986_PARSER.escape is obsolete. Use Gem::URI::RFC2396_PARSER.escape explicitly.", uplevel: 1 if $VERBOSE
+      unsafe ? RFC2396_PARSER.escape(str, unsafe) : RFC2396_PARSER.escape(str)
+    end
+
+    # Compatibility for RFC2396 parser
+    def unescape(str, escaped = nil) # :nodoc:
+      warn "Gem::URI::RFC3986_PARSER.unescape is obsolete. Use Gem::URI::RFC2396_PARSER.unescape explicitly.", uplevel: 1 if $VERBOSE
+      escaped ? RFC2396_PARSER.unescape(str, escaped) : RFC2396_PARSER.unescape(str)
+    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 = '010003'.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[https://www.rfc-editor.org/rfc/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[https://www.rfc-editor.org/rfc/rfc822]
+# - RFC1738[https://www.rfc-editor.org/rfc/rfc1738]
+# - RFC2255[https://www.rfc-editor.org/rfc/rfc2255]
+# - RFC2368[https://www.rfc-editor.org/rfc/rfc2368]
+# - RFC2373[https://www.rfc-editor.org/rfc/rfc2373]
+# - RFC2396[https://www.rfc-editor.org/rfc/rfc2396]
+# - RFC2732[https://www.rfc-editor.org/rfc/rfc2732]
+# - RFC3986[https://www.rfc-editor.org/rfc/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,3 @@
+# frozen_string_literal: true
+
+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

@@ -288,7 +288,10 @@ class Gem::Version
   # 1.3.5 and earlier) compatibility.
 
   def marshal_load(array)
-    initialize array[0]
+    string = array[0]
+    raise TypeError, "wrong version string" unless string.is_a?(String)
+
+    initialize string
   end
 
   def yaml_initialize(tag, map) # :nodoc:
@@ -297,10 +300,6 @@ class Gem::Version
     @hash = nil
   end
 
-  def to_yaml_properties # :nodoc:
-    ["@version"]
-  end
-
   def encode_with(coder) # :nodoc:
     coder.add "version", @version
   end
@@ -369,13 +368,13 @@ class Gem::Version
 
     lhsize = lhsegments.size
     rhsize = rhsegments.size
-    limit  = (lhsize > rhsize ? lhsize : rhsize) - 1
+    limit  = (lhsize > rhsize ? rhsize : lhsize)
 
     i = 0
 
-    while i <= limit
-      lhs = lhsegments[i] || 0
-      rhs = rhsegments[i] || 0
+    while i < limit
+      lhs = lhsegments[i]
+      rhs = rhsegments[i]
       i += 1
 
       next      if lhs == rhs
@@ -385,6 +384,24 @@ class Gem::Version
       return lhs <=> rhs
     end
 
+    lhs = lhsegments[i]
+
+    if lhs.nil?
+      rhs = rhsegments[i]
+
+      while i < rhsize
+        return 1 if String === rhs
+        return -1 unless rhs.zero?
+        rhs = rhsegments[i += 1]
+      end
+    else
+      while i < lhsize
+        return -1 if String === lhs
+        return 1 unless lhs.zero?
+        lhs = lhsegments[i += 1]
+      end
+    end
+
     0
   end
 

data/lib/rubygems/yaml_serializer.rb

@@ -41,7 +41,7 @@ module Gem
     HASH_REGEX = /
       ^
       ([ ]*) # indentations
-      (.+) # key
+      ([^#]+) # key excludes comment char '#'
       (?::(?=(?:\s|$))) # :  (without the lookahead the #key includes this when : is present in value)
       [ ]?
       (['"]?) # optional opening quote
@@ -58,7 +58,8 @@ module Gem
       str.split(/\r?\n/) do |line|
         if match = HASH_REGEX.match(line)
           indent, key, quote, val = match.captures
-          convert_to_backward_compatible_key!(key)
+          val = strip_comment(val)
+
           depth = indent.size / 2
           if quote.empty? && val.empty?
             new_hash = {}
@@ -72,6 +73,8 @@ module Gem
           end
         elsif match = ARRAY_REGEX.match(line)
           _, val = match.captures
+          val = strip_comment(val)
+
           last_hash[last_empty_key] = [] unless last_hash[last_empty_key].is_a?(Array)
 
           last_hash[last_empty_key].push(val)
@@ -80,14 +83,16 @@ module Gem
       res
     end
 
-    # for settings' keys
-    def convert_to_backward_compatible_key!(key)
-      key << "/" if /https?:/i.match?(key) && !%r{/\Z}.match?(key)
-      key.gsub!(".", "__")
+    def strip_comment(val)
+      if val.include?("#") && !val.start_with?("#")
+        val.split("#", 2).first.strip
+      else
+        val
+      end
     end
 
     class << self
-      private :dump_hash, :convert_to_backward_compatible_key!
+      private :dump_hash
     end
   end
 end