rubygems-update 4.0.21 → 4.1.0.beta1

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

@@ -22,6 +22,7 @@
 
 require_relative '../../../net-protocol/lib/net/protocol'
 require_relative '../../../uri/lib/uri'
+require_relative '../../../resolv/lib/resolv'
 autoload :OpenSSL, 'openssl'
 
 module Gem::Net   #:nodoc:
@@ -723,7 +724,7 @@ module Gem::Net   #:nodoc:
   class HTTP < Protocol
 
     # :stopdoc:
-    VERSION = "0.7.0"
+    VERSION = "0.9.1"
     HTTPVersion = '1.1'
     begin
       require 'zlib'
@@ -1178,6 +1179,7 @@ module Gem::Net   #:nodoc:
       @debug_output = options[:debug_output]
       @response_body_encoding = options[:response_body_encoding]
       @ignore_eof = options[:ignore_eof]
+      @tcpsocket_supports_open_timeout = nil
 
       @proxy_from_env = false
       @proxy_uri      = nil
@@ -1320,6 +1322,9 @@ module Gem::Net   #:nodoc:
     # Sets the proxy password;
     # see {Proxy Server}[rdoc-ref:Gem::Net::HTTP@Proxy+Server].
     attr_writer :proxy_pass
+
+    # Sets whether the proxy uses SSL;
+    # see {Proxy Server}[rdoc-ref:Gem::Net::HTTP@Proxy+Server].
     attr_writer :proxy_use_ssl
 
     # Returns the IP address for the connection.
@@ -1526,33 +1531,10 @@ module Gem::Net   #:nodoc:
       :verify_depth,
       :verify_mode,
       :verify_hostname,
-    ] # :nodoc:
+    ].freeze # :nodoc:
 
     SSL_IVNAMES = SSL_ATTRIBUTES.map { |a| "@#{a}".to_sym }.freeze # :nodoc:
 
-    # Resolv::IPv4::Regex and Resolv::IPv6::Regex, copied from resolv 0.7.1 rather
-    # than required, so that net/http does not load a DNS resolver just to keep an
-    # IP address literal out of the Server Name Indication.
-    # https://github.com/ruby/resolv/blob/v0.7.1/lib/resolv.rb
-    ipv4_octet = /0|1(?:[0-9][0-9]?)?|2(?:[0-4][0-9]?|5[0-5]?|[6-9])?|[3-9][0-9]?/
-    hex16 = /[0-9A-Fa-f]{1,4}/
-    hex16_group = /(?:#{hex16}(?::#{hex16})*)?/
-    dotted_quad = /\d+\.\d+\.\d+\.\d+/
-    zone_id = /%[-0-9A-Za-z._~]+/
-
-    IPV4_ADDRESS = /\A(?:#{ipv4_octet})\.(?:#{ipv4_octet})\.(?:#{ipv4_octet})\.(?:#{ipv4_octet})\z/ # :nodoc:
-
-    IPV6_ADDRESS = /\A(?:
-        (?:#{hex16}:){7}#{hex16}                                            # a:b:c:d:e:f:g:h
-      | #{hex16_group}::#{hex16_group}                                      # a::b
-      | (?:#{hex16}:){6}#{dotted_quad}                                      # a:b:c:d:e:f:w.x.y.z
-      | #{hex16_group}::(?:#{hex16}:)*#{dotted_quad}                        # a::b:w.x.y.z
-      | [Ff][Ee]80(?::#{hex16}){7}#{zone_id}                                # fe80:b:c:d:e:f:g:h%em1
-      | [Ff][Ee]80:(?:#{hex16_group}::#{hex16_group}|:#{hex16_group})?:#{hex16}#{zone_id} # fe80::b%em1
-    )\z/x # :nodoc:
-
-    private_constant :IPV4_ADDRESS, :IPV6_ADDRESS
-
     # Sets or returns the path to a CA certification file in PEM format.
     attr_accessor :ca_file
 
@@ -1654,6 +1636,21 @@ module Gem::Net   #:nodoc:
       self
     end
 
+    # Finishes the \HTTP session:
+    #
+    #   http = Gem::Net::HTTP.new(hostname)
+    #   http.start
+    #   http.started? # => true
+    #   http.finish   # => nil
+    #   http.started? # => false
+    #
+    # Raises IOError if not in a session.
+    def finish
+      raise IOError, 'HTTP session not yet started' unless started?
+      do_finish
+    end
+
+    # :stopdoc:
     def do_start
       connect
       @started = true
@@ -1676,14 +1673,15 @@ module Gem::Net   #:nodoc:
       end
 
       debug "opening connection to #{conn_addr}:#{conn_port}..."
-      s = Gem::Timeout.timeout(@open_timeout, Gem::Net::OpenTimeout) {
-        begin
-          TCPSocket.open(conn_addr, conn_port, @local_host, @local_port)
-        rescue => e
-          raise e, "Failed to open TCP connection to " +
-            "#{conn_addr}:#{conn_port} (#{e.message})"
+      begin
+        s = timeouted_connect(conn_addr, conn_port)
+      rescue => e
+        if (defined?(IO::TimeoutError) && e.is_a?(IO::TimeoutError)) || e.is_a?(Errno::ETIMEDOUT)  # for compatibility with previous versions
+          e = Gem::Net::OpenTimeout.new(e)
         end
-      }
+        raise e, "Failed to open TCP connection to " +
+          "#{conn_addr}:#{conn_port} (#{e.message})"
+      end
       s.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
       debug "opened"
       if use_ssl?
@@ -1736,7 +1734,7 @@ module Gem::Net   #:nodoc:
 
         # Server Name Indication (SNI) RFC 3546/6066
         case @address
-        when IPV4_ADDRESS, IPV6_ADDRESS
+        when Gem::Resolv::IPv4::Regex, Gem::Resolv::IPv6::Regex
           # don't set SNI, as IP addresses in SNI is not valid
           # per RFC 6066, section 3.
 
@@ -1776,23 +1774,30 @@ module Gem::Net   #:nodoc:
     end
     private :connect
 
-    def on_connect
+    tcp_socket_parameters = TCPSocket.instance_method(:initialize).parameters
+    TCP_SOCKET_NEW_HAS_OPEN_TIMEOUT = if tcp_socket_parameters != [[:rest]]
+      tcp_socket_parameters.include?([:key, :open_timeout])
+    else
+      # Use Socket.tcp to find out since there is no parameters information for TCPSocket#initialize
+      # See discussion in https://github.com/ruby/net-http/pull/224
+      Socket.method(:tcp).parameters.include?([:key, :open_timeout])
     end
-    private :on_connect
+    private_constant :TCP_SOCKET_NEW_HAS_OPEN_TIMEOUT
 
-    # Finishes the \HTTP session:
-    #
-    #   http = Gem::Net::HTTP.new(hostname)
-    #   http.start
-    #   http.started? # => true
-    #   http.finish   # => nil
-    #   http.started? # => false
-    #
-    # Raises IOError if not in a session.
-    def finish
-      raise IOError, 'HTTP session not yet started' unless started?
-      do_finish
+    def timeouted_connect(conn_addr, conn_port)
+      if TCP_SOCKET_NEW_HAS_OPEN_TIMEOUT
+        TCPSocket.open(conn_addr, conn_port, @local_host, @local_port, open_timeout: @open_timeout)
+      else
+        Gem::Timeout.timeout(@open_timeout, Gem::Net::OpenTimeout) {
+          TCPSocket.open(conn_addr, conn_port, @local_host, @local_port)
+        }
+      end
+    end
+    private :timeouted_connect
+
+    def on_connect
     end
+    private :on_connect
 
     def do_finish
       @started = false
@@ -1843,6 +1848,8 @@ module Gem::Net   #:nodoc:
       }
     end
 
+    # :startdoc:
+
     class << HTTP
       # Returns true if self is a class which was created by HTTP::Proxy.
       def proxy_class?
@@ -1937,6 +1944,7 @@ module Gem::Net   #:nodoc:
     alias proxyport proxy_port      #:nodoc: obsolete
 
     private
+    # :stopdoc:
 
     def unescape(value)
       require 'cgi/escape'
@@ -1965,6 +1973,7 @@ module Gem::Net   #:nodoc:
         path
       end
     end
+    # :startdoc:
 
     #
     # HTTP operations
@@ -2419,7 +2428,9 @@ module Gem::Net   #:nodoc:
       res
     end
 
-    IDEMPOTENT_METHODS_ = %w/GET HEAD PUT DELETE OPTIONS TRACE/ # :nodoc:
+    # :stopdoc:
+
+    IDEMPOTENT_METHODS_ = %w/GET HEAD PUT DELETE OPTIONS TRACE/.freeze # :nodoc:
 
     def transport_request(req)
       count = 0
@@ -2576,7 +2587,7 @@ module Gem::Net   #:nodoc:
     alias_method :D, :debug
   end
 
-  # for backward compatibility until Ruby 3.5
+  # for backward compatibility until Ruby 4.0
   # https://bugs.ruby-lang.org/issues/20900
   # https://github.com/bblimke/webmock/pull/1081
   HTTPSession = HTTP

data/lib/rubygems/vendor/optparse/lib/optparse.rb

@@ -426,8 +426,9 @@ require 'set' unless defined?(Set)
 #
 class Gem::OptionParser
   # The version string
-  VERSION = "0.8.0"
-  Version = VERSION # for compatibility
+  VERSION = "0.8.1"
+  # An alias for compatibility
+  Version = VERSION
 
   # :stopdoc:
   NoArgument = [NO_ARGUMENT = :NONE, nil].freeze
@@ -471,7 +472,6 @@ class Gem::OptionParser
       Completion.candidate(key, icase, pat, &method(:each))
     end
 
-    public
     def complete(key, icase = false, pat = nil)
       candidates = candidate(key, icase, pat, &method(:each)).sort_by {|k, v, kn| kn.size}
       if candidates.size == 1
@@ -561,7 +561,7 @@ class Gem::OptionParser
     # Parses +arg+ and returns rest of +arg+ and matched portion to the
     # argument pattern. Yields when the pattern doesn't match substring.
     #
-    def parse_arg(arg) # :nodoc:
+    private def parse_arg(arg) # :nodoc:
       pattern or return nil, [arg]
       unless m = pattern.match(arg)
         yield(InvalidArgument, arg)
@@ -579,14 +579,13 @@ class Gem::OptionParser
       yield(InvalidArgument, arg) # didn't match whole arg
       return arg[s.length..-1], m
     end
-    private :parse_arg
 
     #
     # Parses argument, converts and returns +arg+, +block+ and result of
     # conversion. Yields at semi-error condition instead of raising an
     # exception.
     #
-    def conv_arg(arg, val = []) # :nodoc:
+    private def conv_arg(arg, val = []) # :nodoc:
       v, = *val
       if conv
         val = conv.call(*val)
@@ -598,7 +597,6 @@ class Gem::OptionParser
       end
       return arg, block, val
     end
-    private :conv_arg
 
     #
     # Produces the summary text. Each line of the summary is yielded to the
@@ -882,14 +880,13 @@ class Gem::OptionParser
     # +lopts+::  Long style option list.
     # +nlopts+:: Negated long style options list.
     #
-    def update(sw, sopts, lopts, nsw = nil, nlopts = nil) # :nodoc:
+    private def update(sw, sopts, lopts, nsw = nil, nlopts = nil) # :nodoc:
       sopts.each {|o| @short[o] = sw} if sopts
       lopts.each {|o| @long[o] = sw} if lopts
       nlopts.each {|o| @long[o] = nsw} if nsw and nlopts
       used = @short.invert.update(@long.invert)
       @list.delete_if {|o| Switch === o and !used[o]}
     end
-    private :update
 
     #
     # Inserts +switch+ at the head of the list, and associates short, long
@@ -1458,14 +1455,13 @@ XXX
   # +prv+:: Previously specified argument.
   # +msg+:: Exception message.
   #
-  def notwice(obj, prv, msg) # :nodoc:
+  private def notwice(obj, prv, msg) # :nodoc:
     unless !prv or prv == obj
       raise(ArgumentError, "argument #{msg} given twice: #{obj}",
             ParseError.filter_backtrace(caller(2)))
     end
     obj
   end
-  private :notwice
 
   SPLAT_PROC = proc {|*a| a.length <= 1 ? a.first : a} # :nodoc:
 
@@ -1732,7 +1728,7 @@ XXX
     parse_in_order(argv, setter, **keywords, &nonopt)
   end
 
-  def parse_in_order(argv = default_argv, setter = nil, exact: require_exact, **, &nonopt)  # :nodoc:
+  private def parse_in_order(argv = default_argv, setter = nil, exact: require_exact, **, &nonopt)  # :nodoc:
     opt, arg, val, rest = nil
     nonopt ||= proc {|a| throw :terminate, a}
     argv.unshift(arg) if arg = catch(:terminate) {
@@ -1823,10 +1819,9 @@ XXX
 
     argv
   end
-  private :parse_in_order
 
   # Calls callback with _val_.
-  def callback!(cb, max_arity, *args) # :nodoc:
+  private def callback!(cb, max_arity, *args) # :nodoc:
     args.compact!
 
     if (size = args.size) < max_arity and cb.to_proc.lambda?
@@ -1836,7 +1831,6 @@ XXX
     end
     cb.call(*args)
   end
-  private :callback!
 
   #
   # Parses command line arguments +argv+ in permutation mode and returns
@@ -1950,24 +1944,22 @@ XXX
   # Traverses @stack, sending each element method +id+ with +args+ and
   # +block+.
   #
-  def visit(id, *args, &block) # :nodoc:
+  private def visit(id, *args, &block) # :nodoc:
     @stack.reverse_each do |el|
       el.__send__(id, *args, &block)
     end
     nil
   end
-  private :visit
 
   #
   # Searches +key+ in @stack for +id+ hash and returns or yields the result.
   #
-  def search(id, key) # :nodoc:
+  private def search(id, key) # :nodoc:
     block_given = block_given?
     visit(:search, id, key) do |k|
       return block_given ? yield(k) : k
     end
   end
-  private :search
 
   #
   # Completes shortened long style option switch and returns pair of
@@ -1978,7 +1970,7 @@ XXX
   # +icase+:: Search case insensitive if true.
   # +pat+::   Optional pattern for completion.
   #
-  def complete(typ, opt, icase = false, *pat) # :nodoc:
+  private def complete(typ, opt, icase = false, *pat) # :nodoc:
     if pat.empty?
       search(typ, opt) {|sw| return [sw, opt]} # exact match or...
     end
@@ -1988,7 +1980,6 @@ XXX
     exc = ambiguous ? AmbiguousOption : InvalidOption
     raise exc.new(opt, additional: proc {|o| additional_message(typ, o)})
   end
-  private :complete
 
   #
   # Returns additional info.
@@ -2323,42 +2314,42 @@ XXX
   # Raises when ambiguously completable string is encountered.
   #
   class AmbiguousOption < ParseError
-    const_set(:Reason, 'ambiguous option')
+    Reason = 'ambiguous option'    # :nodoc:
   end
 
   #
   # Raises when there is an argument for a switch which takes no argument.
   #
   class NeedlessArgument < ParseError
-    const_set(:Reason, 'needless argument')
+    Reason = 'needless argument'    # :nodoc:
   end
 
   #
   # Raises when a switch with mandatory argument has no argument.
   #
   class MissingArgument < ParseError
-    const_set(:Reason, 'missing argument')
+    Reason = 'missing argument'    # :nodoc:
   end
 
   #
   # Raises when switch is undefined.
   #
   class InvalidOption < ParseError
-    const_set(:Reason, 'invalid option')
+    Reason = 'invalid option'    # :nodoc:
   end
 
   #
   # Raises when the given argument does not match required format.
   #
   class InvalidArgument < ParseError
-    const_set(:Reason, 'invalid argument')
+    Reason = 'invalid argument'    # :nodoc:
   end
 
   #
   # Raises when the given argument word can't be completed uniquely.
   #
   class AmbiguousArgument < InvalidArgument
-    const_set(:Reason, 'ambiguous argument')
+    Reason = 'ambiguous argument'    # :nodoc:
   end
 
   #
@@ -2457,9 +2448,11 @@ XXX
   # and DecimalNumeric. See Acceptable argument classes (in source code).
   #
   module Acceptables
-    const_set(:DecimalInteger, Gem::OptionParser::DecimalInteger)
-    const_set(:OctalInteger, Gem::OptionParser::OctalInteger)
-    const_set(:DecimalNumeric, Gem::OptionParser::DecimalNumeric)
+    # :stopdoc:
+    DecimalInteger = Gem::OptionParser::DecimalInteger
+    OctalInteger = Gem::OptionParser::OctalInteger
+    DecimalNumeric = Gem::OptionParser::DecimalNumeric
+    # :startdoc:
   end
 end
 

data/{bundler/lib/bundler → lib/rubygems}/vendor/pub_grub/lib/pub_grub/assignment.rb

@@ -1,4 +1,4 @@
-module Bundler::PubGrub
+module Gem::PubGrub
   class Assignment
     attr_reader :term, :cause, :decision_level, :index
     def initialize(term, cause, decision_level, index)

data/{bundler/lib/bundler → lib/rubygems}/vendor/pub_grub/lib/pub_grub/basic_package_source.rb

@@ -1,10 +1,10 @@
 require_relative 'version_constraint'
 require_relative 'incompatibility'
 
-module Bundler::PubGrub
+module Gem::PubGrub
   # Types:
   #
-  # Where possible, Bundler::PubGrub will accept user-defined types, so long as they quack.
+  # Where possible, Gem::PubGrub will accept user-defined types, so long as they quack.
   #
   # ## "Package":
   #
@@ -32,7 +32,7 @@ module Bundler::PubGrub
   #
   # This class represents the requirement one package has on another. It is
   # returned by dependencies_for(package, version) and will be passed to
-  # parse_dependency to convert it to a format Bundler::PubGrub understands.
+  # parse_dependency to convert it to a format Gem::PubGrub understands.
   #
   # It must also have a reasonable definition of #==
   #
@@ -59,13 +59,13 @@ module Bundler::PubGrub
 
     # Override me!
     #
-    # Convert a (user-defined) dependency into a format Bundler::PubGrub understands.
+    # Convert a (user-defined) dependency into a format Gem::PubGrub understands.
     #
     # Package is passed to this method but for many implementations is not
     # needed.
     #
-    # Returns: either a Bundler::PubGrub::VersionRange, Bundler::PubGrub::VersionUnion, or a
-    #   Bundler::PubGrub::VersionConstraint
+    # Returns: either a Gem::PubGrub::VersionRange, Gem::PubGrub::VersionUnion, or a
+    #   Gem::PubGrub::VersionConstraint
     def parse_dependency(package, dependency)
       raise NotImplementedError
     end
@@ -155,7 +155,7 @@ module Bundler::PubGrub
         dep_constraint = parse_dependency(dep_package, dep_constraint_name)
         if !dep_constraint
           # falsey indicates this dependency was invalid
-          cause = Bundler::PubGrub::Incompatibility::InvalidDependency.new(dep_package, dep_constraint_name)
+          cause = Gem::PubGrub::Incompatibility::InvalidDependency.new(dep_package, dep_constraint_name)
           return [Incompatibility.new([Term.new(self_constraint, true)], cause: cause)]
         elsif !dep_constraint.is_a?(VersionConstraint)
           # Upgrade range/union to VersionConstraint

data/{bundler/lib/bundler → lib/rubygems}/vendor/pub_grub/lib/pub_grub/failure_writer.rb

@@ -1,4 +1,4 @@
-module Bundler::PubGrub
+module Gem::PubGrub
   class FailureWriter
     def initialize(root)
       @root = root

data/{bundler/lib/bundler → lib/rubygems}/vendor/pub_grub/lib/pub_grub/incompatibility.rb

@@ -1,4 +1,4 @@
-module Bundler::PubGrub
+module Gem::PubGrub
   class Incompatibility
     ConflictCause = Struct.new(:incompatibility, :satisfier) do
       alias_method :conflict, :incompatibility
@@ -61,11 +61,11 @@ module Bundler::PubGrub
         "(root dependency)"
       when :dependency
         "#{terms[0].to_s(allow_every: true)} depends on #{terms[1].invert}"
-      when Bundler::PubGrub::Incompatibility::InvalidDependency
+      when Gem::PubGrub::Incompatibility::InvalidDependency
         "#{terms[0].to_s(allow_every: true)} depends on unknown package #{cause.package}"
-      when Bundler::PubGrub::Incompatibility::NoVersions
+      when Gem::PubGrub::Incompatibility::NoVersions
         "no versions satisfy #{cause.constraint}"
-      when Bundler::PubGrub::Incompatibility::ConflictCause
+      when Gem::PubGrub::Incompatibility::ConflictCause
         if failure?
           "version solving has failed"
         elsif terms.length == 1

data/{bundler/lib/bundler → lib/rubygems}/vendor/pub_grub/lib/pub_grub/package.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Bundler::PubGrub
+module Gem::PubGrub
   class Package
 
     attr_reader :name

data/{bundler/lib/bundler → lib/rubygems}/vendor/pub_grub/lib/pub_grub/partial_solution.rb

@@ -1,6 +1,6 @@
 require_relative 'assignment'
 
-module Bundler::PubGrub
+module Gem::PubGrub
   class PartialSolution
     attr_reader :assignments, :decisions
     attr_reader :attempted_solutions

data/{bundler/lib/bundler → lib/rubygems}/vendor/pub_grub/lib/pub_grub/rubygems.rb

@@ -1,4 +1,4 @@
-module Bundler::PubGrub
+module Gem::PubGrub
   module RubyGems
     extend self
 
@@ -30,7 +30,7 @@ module Bundler::PubGrub
     end
 
     def requirement_to_constraint(package, requirement)
-      Bundler::PubGrub::VersionConstraint.new(package, range: requirement_to_range(requirement))
+      Gem::PubGrub::VersionConstraint.new(package, range: requirement_to_range(requirement))
     end
 
     def parse_range(dep)
@@ -39,7 +39,7 @@ module Bundler::PubGrub
 
     def parse_constraint(package, dep)
       range = parse_range(dep)
-      Bundler::PubGrub::VersionConstraint.new(package, range: range)
+      Gem::PubGrub::VersionConstraint.new(package, range: range)
     end
   end
 end

data/{bundler/lib/bundler → lib/rubygems}/vendor/pub_grub/lib/pub_grub/solve_failure.rb

@@ -1,6 +1,6 @@
 require_relative 'failure_writer'
 
-module Bundler::PubGrub
+module Gem::PubGrub
   class SolveFailure < StandardError
     attr_reader :incompatibility
 

data/{bundler/lib/bundler → lib/rubygems}/vendor/pub_grub/lib/pub_grub/static_package_source.rb

@@ -4,7 +4,7 @@ require_relative 'version_constraint'
 require_relative 'incompatibility'
 require_relative 'basic_package_source'
 
-module Bundler::PubGrub
+module Gem::PubGrub
   class StaticPackageSource < BasicPackageSource
     class DSL
       def initialize(packages, root_deps)
@@ -27,7 +27,7 @@ module Bundler::PubGrub
 
       # Exclude redundant self-referencing dependencies
       def clean_deps(name, version, deps)
-        deps.reject {|dep_name, req| name == dep_name && Bundler::PubGrub::RubyGems.parse_range(req).include?(version) }
+        deps.reject {|dep_name, req| name == dep_name && Gem::PubGrub::RubyGems.parse_range(req).include?(version) }
       end
     end
 
@@ -55,7 +55,7 @@ module Bundler::PubGrub
     def parse_dependency(package, dependency)
       return false unless @packages.key?(package)
 
-      Bundler::PubGrub::RubyGems.parse_constraint(package, dependency)
+      Gem::PubGrub::RubyGems.parse_constraint(package, dependency)
     end
   end
 end

data/{bundler/lib/bundler → lib/rubygems}/vendor/pub_grub/lib/pub_grub/strategy.rb

@@ -1,4 +1,4 @@
-module Bundler::PubGrub
+module Gem::PubGrub
   class Strategy
     def initialize(source)
       @source = source
@@ -27,7 +27,7 @@ module Bundler::PubGrub
       versions = @source.versions_for(package, range)
 
       indexes = @version_indexes[package]
-      versions.min_by { |version| indexes[version] }
+      versions.min_by { |version| indexes[version] || Float::INFINITY }
     end
 
     def next_term_to_try_from(unsatisfied)

data/{bundler/lib/bundler → lib/rubygems}/vendor/pub_grub/lib/pub_grub/term.rb

@@ -1,4 +1,4 @@
-module Bundler::PubGrub
+module Gem::PubGrub
   class Term
     attr_reader :package, :constraint, :positive
 

data/{bundler/lib/bundler → lib/rubygems}/vendor/pub_grub/lib/pub_grub/version.rb

@@ -1,3 +1,3 @@
-module Bundler::PubGrub
+module Gem::PubGrub
   VERSION = "0.5.0"
 end

data/{bundler/lib/bundler → lib/rubygems}/vendor/pub_grub/lib/pub_grub/version_constraint.rb

@@ -1,11 +1,11 @@
 require_relative 'version_range'
 
-module Bundler::PubGrub
+module Gem::PubGrub
   class VersionConstraint
     attr_reader :package, :range
 
-    # @param package [Bundler::PubGrub::Package]
-    # @param range [Bundler::PubGrub::VersionRange]
+    # @param package [Gem::PubGrub::Package]
+    # @param range [Gem::PubGrub::VersionRange]
     def initialize(package, range: nil)
       @package = package
       @range = range

data/{bundler/lib/bundler → lib/rubygems}/vendor/pub_grub/lib/pub_grub/version_range.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Bundler::PubGrub
+module Gem::PubGrub
   class VersionRange
     attr_reader :min, :max, :include_min, :include_max
 

data/{bundler/lib/bundler → lib/rubygems}/vendor/pub_grub/lib/pub_grub/version_solver.rb

@@ -4,14 +4,14 @@ require_relative 'incompatibility'
 require_relative 'solve_failure'
 require_relative 'strategy'
 
-module Bundler::PubGrub
+module Gem::PubGrub
   class VersionSolver
     attr_reader :logger
     attr_reader :source
     attr_reader :solution
     attr_reader :strategy
 
-    def initialize(source:, root: Package.root, strategy: Strategy.new(source), logger: Bundler::PubGrub.logger)
+    def initialize(source:, root: Package.root, strategy: Strategy.new(source), logger: Gem::PubGrub.logger)
       @logger = logger
 
       @source = source

data/{bundler/lib/bundler → lib/rubygems}/vendor/pub_grub/lib/pub_grub/version_union.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Bundler::PubGrub
+module Gem::PubGrub
   class VersionUnion
     attr_reader :ranges