rubygems-update 3.4.10 → 3.5.22

data/lib/rubygems/resolver.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative "dependency"
 require_relative "exceptions"
 require_relative "util/list"
@@ -10,7 +11,7 @@ require_relative "util/list"
 # all the requirements.
 
 class Gem::Resolver
-  require_relative "resolver/molinillo"
+  require_relative "vendored_molinillo"
 
   ##
   # If the DEBUG_RESOLVER environment variable is set then debugging mode is
@@ -37,8 +38,6 @@ class Gem::Resolver
   ##
   # List of dependencies that could not be found in the configured sources.
 
-  attr_reader :missing
-
   attr_reader :stats
 
   ##
@@ -48,8 +47,7 @@ class Gem::Resolver
   attr_accessor :skip_gems
 
   ##
-  # When a missing dependency, don't stop. Just go on and record what was
-  # missing.
+  #
 
   attr_accessor :soft_missing
 
@@ -105,7 +103,6 @@ class Gem::Resolver
     @development         = false
     @development_shallow = false
     @ignore_dependencies = false
-    @missing             = []
     @skip_gems           = {}
     @soft_missing        = false
     @stats               = Gem::Resolver::Stats.new
@@ -114,7 +111,7 @@ class Gem::Resolver
   def explain(stage, *data) # :nodoc:
     return unless DEBUG_RESOLVER
 
-    d = data.map {|x| x.pretty_inspect }.join(", ")
+    d = data.map(&:pretty_inspect).join(", ")
     $stderr.printf "%10s %s\n", stage.to_s.upcase, d
   end
 
@@ -144,7 +141,7 @@ class Gem::Resolver
     activation_request =
       Gem::Resolver::ActivationRequest.new spec, dep, possible
 
-    return spec, activation_request
+    [spec, activation_request]
   end
 
   def requests(s, act, reqs=[]) # :nodoc:
@@ -170,7 +167,7 @@ class Gem::Resolver
     reqs
   end
 
-  include Molinillo::UI
+  include Gem::Molinillo::UI
 
   def output
     @output ||= debug? ? $stdout : File.open(IO::NULL, "w")
@@ -180,15 +177,14 @@ class Gem::Resolver
     DEBUG_RESOLVER
   end
 
-  include Molinillo::SpecificationProvider
+  include Gem::Molinillo::SpecificationProvider
 
   ##
   # Proceed with resolution! Returns an array of ActivationRequest objects.
 
   def resolve
-    locking_dg = Molinillo::DependencyGraph.new
-    Molinillo::Resolver.new(self, self).resolve(@needed.map {|d| DependencyRequest.new d, nil }, locking_dg).tsort.map(&:payload).compact
-  rescue Molinillo::VersionConflict => e
+    Gem::Molinillo::Resolver.new(self, self).resolve(@needed.map {|d| DependencyRequest.new d, nil }).tsort.map(&:payload).compact
+  rescue Gem::Molinillo::VersionConflict => e
     conflict = e.conflicts.values.first
     raise Gem::DependencyResolutionError, Conflict.new(conflict.requirement_trees.first.first, conflict.existing, conflict.requirement)
   ensure
@@ -212,7 +208,7 @@ class Gem::Resolver
 
     matching_platform = select_local_platforms all
 
-    return matching_platform, all
+    [matching_platform, all]
   end
 
   ##
@@ -227,7 +223,6 @@ class Gem::Resolver
   def search_for(dependency)
     possibles, all = find_possible(dependency)
     if !@soft_missing && possibles.empty?
-      @missing << dependency
       exc = Gem::UnsatisfiableDependencyError.new dependency, all
       exc.errors = @set.errors
       raise exc
@@ -246,7 +241,7 @@ class Gem::Resolver
 
     sources.each do |source|
       groups[source].
-        sort_by {|spec| [spec.version, spec.platform =~ Gem::Platform.local ? 1 : 0] }.
+        sort_by {|spec| [spec.version, spec.platform =~ Gem::Platform.local ? 1 : 0] }. # rubocop:disable Performance/RegexpMatch
         map {|spec| ActivationRequest.new spec, dependency }.
         each {|activation_request| activation_requests << activation_request }
     end
@@ -274,7 +269,6 @@ class Gem::Resolver
   end
 
   def allow_missing?(dependency)
-    @missing << dependency
     @soft_missing
   end
 

data/lib/rubygems/s3_uri_signer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "openssl"
 
 ##
@@ -10,7 +12,7 @@ class Gem::S3URISigner
     end
 
     def to_s # :nodoc:
-      "#{super}"
+      super.to_s
     end
   end
 
@@ -20,7 +22,7 @@ class Gem::S3URISigner
     end
 
     def to_s # :nodoc:
-      "#{super}"
+      super.to_s
     end
   end
 
@@ -32,7 +34,7 @@ class Gem::S3URISigner
 
   ##
   # Signs S3 URI using query-params according to the reference: https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html
-  def sign(expiration = 86400)
+  def sign(expiration = 86_400)
     s3_config = fetch_s3_config
 
     current_time = Time.now.utc
@@ -47,7 +49,7 @@ class Gem::S3URISigner
     string_to_sign = generate_string_to_sign(date_time, credential_info, canonical_request)
     signature = generate_signature(s3_config, date, string_to_sign)
 
-    URI.parse("https://#{canonical_host}#{uri.path}?#{query_params}&X-Amz-Signature=#{signature}")
+    Gem::URI.parse("https://#{canonical_host}#{uri.path}?#{query_params}&X-Amz-Signature=#{signature}")
   end
 
   private
@@ -134,11 +136,11 @@ class Gem::S3URISigner
   end
 
   def base64_uri_escape(str)
-    str.gsub(/[\+\/=\n]/, BASE64_URI_TRANSLATE)
+    str.gsub(%r{[\+/=\n]}, BASE64_URI_TRANSLATE)
   end
 
   def ec2_metadata_credentials_json
-    require "net/http"
+    require_relative "vendored_net_http"
     require_relative "request"
     require_relative "request/connection_pools"
     require "json"
@@ -150,13 +152,13 @@ class Gem::S3URISigner
   end
 
   def ec2_metadata_request(url)
-    uri = URI(url)
+    uri = Gem::URI(url)
     @request_pool ||= create_request_pool(uri)
-    request = Gem::Request.new(uri, Net::HTTP::Get, nil, @request_pool)
+    request = Gem::Request.new(uri, Gem::Net::HTTP::Get, nil, @request_pool)
     response = request.fetch
 
     case response
-    when Net::HTTPOK then
+    when Gem::Net::HTTPOK then
       JSON.parse(response.body)
     else
       raise InstanceProfileError.new("Unable to fetch AWS metadata from #{uri}: #{response.message} #{response.code}")
@@ -170,6 +172,6 @@ class Gem::S3URISigner
   end
 
   BASE64_URI_TRANSLATE = { "+" => "%2B", "/" => "%2F", "=" => "%3D", "\n" => "" }.freeze
-  EC2_IAM_INFO = "http://169.254.169.254/latest/meta-data/iam/info".freeze
-  EC2_IAM_SECURITY_CREDENTIALS = "http://169.254.169.254/latest/meta-data/iam/security-credentials/".freeze
+  EC2_IAM_INFO = "http://169.254.169.254/latest/meta-data/iam/info"
+  EC2_IAM_SECURITY_CREDENTIALS = "http://169.254.169.254/latest/meta-data/iam/security-credentials/"
 end

data/lib/rubygems/safe_marshal/elements.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Gem
+  module SafeMarshal
+    module Elements
+      class Element
+      end
+
+      class Symbol < Element
+        def initialize(name)
+          @name = name
+        end
+        attr_reader :name
+      end
+
+      class UserDefined < Element
+        def initialize(name, binary_string)
+          @name = name
+          @binary_string = binary_string
+        end
+
+        attr_reader :name, :binary_string
+      end
+
+      class UserMarshal < Element
+        def initialize(name, data)
+          @name = name
+          @data = data
+        end
+
+        attr_reader :name, :data
+      end
+
+      class String < Element
+        def initialize(str)
+          @str = str
+        end
+
+        attr_reader :str
+      end
+
+      class Hash < Element
+        def initialize(pairs)
+          @pairs = pairs
+        end
+
+        attr_reader :pairs
+      end
+
+      class HashWithDefaultValue < Hash
+        def initialize(pairs, default)
+          super(pairs)
+          @default = default
+        end
+
+        attr_reader :default
+      end
+
+      class Array < Element
+        def initialize(elements)
+          @elements = elements
+        end
+
+        attr_reader :elements
+      end
+
+      class Integer < Element
+        def initialize(int)
+          @int = int
+        end
+
+        attr_reader :int
+      end
+
+      class True < Element
+        def initialize
+        end
+        TRUE = new.freeze
+      end
+
+      class False < Element
+        def initialize
+        end
+
+        FALSE = new.freeze
+      end
+
+      class WithIvars < Element
+        def initialize(object, ivars)
+          @object = object
+          @ivars = ivars
+        end
+
+        attr_reader :object, :ivars
+      end
+
+      class Object < Element
+        def initialize(name)
+          @name = name
+        end
+        attr_reader :name
+      end
+
+      class Nil < Element
+        NIL = new.freeze
+      end
+
+      class ObjectLink < Element
+        def initialize(offset)
+          @offset = offset
+        end
+        attr_reader :offset
+      end
+
+      class SymbolLink < Element
+        def initialize(offset)
+          @offset = offset
+        end
+        attr_reader :offset
+      end
+
+      class Float < Element
+        def initialize(string)
+          @string = string
+        end
+        attr_reader :string
+      end
+
+      class Bignum < Element # rubocop:disable Lint/UnifiedInteger
+        def initialize(sign, data)
+          @sign = sign
+          @data = data
+        end
+        attr_reader :sign, :data
+      end
+
+      class UserClass < Element
+        def initialize(name, wrapped_object)
+          @name = name
+          @wrapped_object = wrapped_object
+        end
+        attr_reader :name, :wrapped_object
+      end
+    end
+  end
+end

data/lib/rubygems/safe_marshal/reader.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+require_relative "elements"
+
+module Gem
+  module SafeMarshal
+    class Reader
+      class Error < StandardError
+      end
+
+      class UnsupportedVersionError < Error
+      end
+
+      class UnconsumedBytesError < Error
+      end
+
+      class NotImplementedError < Error
+      end
+
+      class EOFError < Error
+      end
+
+      def initialize(io)
+        @io = io
+      end
+
+      def read!
+        read_header
+        root = read_element
+        raise UnconsumedBytesError unless @io.eof?
+        root
+      end
+
+      private
+
+      MARSHAL_VERSION = [Marshal::MAJOR_VERSION, Marshal::MINOR_VERSION].map(&:chr).join.freeze
+      private_constant :MARSHAL_VERSION
+
+      def read_header
+        v = @io.read(2)
+        raise UnsupportedVersionError, "Unsupported marshal version #{v.bytes.map(&:ord).join(".")}, expected #{Marshal::MAJOR_VERSION}.#{Marshal::MINOR_VERSION}" unless v == MARSHAL_VERSION
+      end
+
+      def read_byte
+        @io.getbyte
+      end
+
+      def read_integer
+        b = read_byte
+
+        case b
+        when 0x00
+          0
+        when 0x01
+          read_byte
+        when 0x02
+          read_byte | (read_byte << 8)
+        when 0x03
+          read_byte | (read_byte << 8) | (read_byte << 16)
+        when 0x04
+          read_byte | (read_byte << 8) | (read_byte << 16) | (read_byte << 24)
+        when 0xFC
+          read_byte | (read_byte << 8) | (read_byte << 16) | (read_byte << 24) | -0x100000000
+        when 0xFD
+          read_byte | (read_byte << 8) | (read_byte << 16) | -0x1000000
+        when 0xFE
+          read_byte | (read_byte << 8) | -0x10000
+        when 0xFF
+          read_byte | -0x100
+        when nil
+          raise EOFError, "Unexpected EOF"
+        else
+          signed = (b ^ 128) - 128
+          if b >= 128
+            signed + 5
+          else
+            signed - 5
+          end
+        end
+      end
+
+      def read_element
+        type = read_byte
+        case type
+        when 34 then read_string # ?"
+        when 48 then read_nil # ?0
+        when 58 then read_symbol # ?:
+        when 59 then read_symbol_link # ?;
+        when 64 then read_object_link # ?@
+        when 70 then read_false # ?F
+        when 73 then read_object_with_ivars # ?I
+        when 84 then read_true # ?T
+        when 85 then read_user_marshal # ?U
+        when 91 then read_array # ?[
+        when 102 then read_float # ?f
+        when 105 then Elements::Integer.new(read_integer) # ?i
+        when 108 then read_bignum # ?l
+        when 111 then read_object # ?o
+        when 117 then read_user_defined # ?u
+        when 123 then read_hash # ?{
+        when 125 then read_hash_with_default_value # ?}
+        when 101 then read_extended_object # ?e
+        when 99 then read_class # ?c
+        when 109 then read_module # ?m
+        when 77 then read_class_or_module # ?M
+        when 100 then read_data # ?d
+        when 47 then read_regexp # ?/
+        when 83 then read_struct # ?S
+        when 67 then read_user_class # ?C
+        when nil
+          raise EOFError, "Unexpected EOF"
+        else
+          raise Error, "Unknown marshal type discriminator #{type.chr.inspect} (#{type})"
+        end
+      end
+
+      STRING_E_SYMBOL = Elements::Symbol.new("E").freeze
+      private_constant :STRING_E_SYMBOL
+
+      def read_symbol
+        len = read_integer
+        if len == 1
+          byte = read_byte
+          if byte == 69 # ?E
+            STRING_E_SYMBOL
+          else
+            Elements::Symbol.new(byte.chr)
+          end
+        else
+          name = -@io.read(len)
+          Elements::Symbol.new(name)
+        end
+      end
+
+      EMPTY_STRING = Elements::String.new("".b.freeze).freeze
+      private_constant :EMPTY_STRING
+
+      def read_string
+        length = read_integer
+        return EMPTY_STRING if length == 0
+        str = @io.read(length)
+        Elements::String.new(str)
+      end
+
+      def read_true
+        Elements::True::TRUE
+      end
+
+      def read_false
+        Elements::False::FALSE
+      end
+
+      def read_user_defined
+        name = read_element
+        binary_string = @io.read(read_integer)
+        Elements::UserDefined.new(name, binary_string)
+      end
+
+      EMPTY_ARRAY = Elements::Array.new([].freeze).freeze
+      private_constant :EMPTY_ARRAY
+
+      def read_array
+        length = read_integer
+        return EMPTY_ARRAY if length == 0
+        elements = Array.new(length) do
+          read_element
+        end
+        Elements::Array.new(elements)
+      end
+
+      def read_object_with_ivars
+        object = read_element
+        ivars = Array.new(read_integer) do
+          [read_element, read_element]
+        end
+        Elements::WithIvars.new(object, ivars)
+      end
+
+      def read_symbol_link
+        offset = read_integer
+        Elements::SymbolLink.new(offset)
+      end
+
+      def read_user_marshal
+        name = read_element
+        data = read_element
+        Elements::UserMarshal.new(name, data)
+      end
+
+      # profiling bundle install --full-index shows that
+      # offset 6 is by far the most common object link,
+      # so we special case it to avoid allocating a new
+      # object a third of the time.
+      # the following are all the object links that
+      # appear more than 10000 times in my profiling
+
+      OBJECT_LINKS = {
+        6 => Elements::ObjectLink.new(6).freeze,
+        30 => Elements::ObjectLink.new(30).freeze,
+        81 => Elements::ObjectLink.new(81).freeze,
+        34 => Elements::ObjectLink.new(34).freeze,
+        38 => Elements::ObjectLink.new(38).freeze,
+        50 => Elements::ObjectLink.new(50).freeze,
+        91 => Elements::ObjectLink.new(91).freeze,
+        42 => Elements::ObjectLink.new(42).freeze,
+        46 => Elements::ObjectLink.new(46).freeze,
+        150 => Elements::ObjectLink.new(150).freeze,
+        100 => Elements::ObjectLink.new(100).freeze,
+        104 => Elements::ObjectLink.new(104).freeze,
+        108 => Elements::ObjectLink.new(108).freeze,
+        242 => Elements::ObjectLink.new(242).freeze,
+        246 => Elements::ObjectLink.new(246).freeze,
+        139 => Elements::ObjectLink.new(139).freeze,
+        143 => Elements::ObjectLink.new(143).freeze,
+        114 => Elements::ObjectLink.new(114).freeze,
+        308 => Elements::ObjectLink.new(308).freeze,
+        200 => Elements::ObjectLink.new(200).freeze,
+        54 => Elements::ObjectLink.new(54).freeze,
+        62 => Elements::ObjectLink.new(62).freeze,
+        1_286_245 => Elements::ObjectLink.new(1_286_245).freeze,
+      }.freeze
+      private_constant :OBJECT_LINKS
+
+      def read_object_link
+        offset = read_integer
+        OBJECT_LINKS[offset] || Elements::ObjectLink.new(offset)
+      end
+
+      EMPTY_HASH = Elements::Hash.new([].freeze).freeze
+      private_constant :EMPTY_HASH
+
+      def read_hash
+        length = read_integer
+        return EMPTY_HASH if length == 0
+        pairs = Array.new(length) do
+          [read_element, read_element]
+        end
+        Elements::Hash.new(pairs)
+      end
+
+      def read_hash_with_default_value
+        pairs = Array.new(read_integer) do
+          [read_element, read_element]
+        end
+        default = read_element
+        Elements::HashWithDefaultValue.new(pairs, default)
+      end
+
+      def read_object
+        name = read_element
+        object = Elements::Object.new(name)
+        ivars = Array.new(read_integer) do
+          [read_element, read_element]
+        end
+        Elements::WithIvars.new(object, ivars)
+      end
+
+      def read_nil
+        Elements::Nil::NIL
+      end
+
+      def read_float
+        string = @io.read(read_integer)
+        Elements::Float.new(string)
+      end
+
+      def read_bignum
+        sign = read_byte
+        data = @io.read(read_integer * 2)
+        Elements::Bignum.new(sign, data)
+      end
+
+      def read_extended_object
+        raise NotImplementedError, "Reading Marshal objects of type extended_object is not implemented"
+      end
+
+      def read_class
+        raise NotImplementedError, "Reading Marshal objects of type class is not implemented"
+      end
+
+      def read_module
+        raise NotImplementedError, "Reading Marshal objects of type module is not implemented"
+      end
+
+      def read_class_or_module
+        raise NotImplementedError, "Reading Marshal objects of type class_or_module is not implemented"
+      end
+
+      def read_data
+        raise NotImplementedError, "Reading Marshal objects of type data is not implemented"
+      end
+
+      def read_regexp
+        raise NotImplementedError, "Reading Marshal objects of type regexp is not implemented"
+      end
+
+      def read_struct
+        raise NotImplementedError, "Reading Marshal objects of type struct is not implemented"
+      end
+
+      def read_user_class
+        name = read_element
+        wrapped_object = read_element
+        Elements::UserClass.new(name, wrapped_object)
+      end
+    end
+  end
+end

data/lib/rubygems/safe_marshal/visitors/stream_printer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "visitor"
+
+module Gem::SafeMarshal
+  module Visitors
+    class StreamPrinter < Visitor
+      def initialize(io, indent: "")
+        @io = io
+        @indent = indent
+        @level = 0
+      end
+
+      def visit(target)
+        @io.write("#{@indent * @level}#{target.class}")
+        target.instance_variables.each do |ivar|
+          value = target.instance_variable_get(ivar)
+          next if Elements::Element === value || Array === value
+          @io.write(" #{ivar}=#{value.inspect}")
+        end
+        @io.write("\n")
+        begin
+          @level += 1
+          super
+        ensure
+          @level -= 1
+        end
+      end
+    end
+  end
+end