rubygems-update 2.6.0 → 3.4.22

data/lib/rubygems/util/list.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Gem
   class List
     include Enumerable
@@ -25,7 +26,7 @@ module Gem
       List.new value, self
     end
 
-    def pretty_print q # :nodoc:
+    def pretty_print(q) # :nodoc:
       q.pp to_a
     end
 

data/lib/rubygems/util.rb

@@ -1,21 +1,28 @@
 # frozen_string_literal: true
+
+require_relative "deprecate"
+
 ##
 # This module contains various utility methods as module methods.
 
 module Gem::Util
 
-  @silent_mutex = nil
-
   ##
   # Zlib::GzipReader wrapper that unzips +data+.
 
   def self.gunzip(data)
-    require 'zlib'
-    require 'stringio'
-    data = StringIO.new(data, 'r')
-
-    unzipped = Zlib::GzipReader.new(data).read
-    unzipped.force_encoding Encoding::BINARY if Object.const_defined? :Encoding
+    require "zlib"
+    require "stringio"
+    data = StringIO.new(data, "r")
+
+    gzip_reader = begin
+                    Zlib::GzipReader.new(data)
+                  rescue Zlib::GzipFile::Error => e
+                    raise e.class, e.inspect, e.backtrace
+                  end
+
+    unzipped = gzip_reader.read
+    unzipped.force_encoding Encoding::BINARY
     unzipped
   end
 
@@ -23,12 +30,14 @@ module Gem::Util
   # Zlib::GzipWriter wrapper that zips +data+.
 
   def self.gzip(data)
-    require 'zlib'
-    require 'stringio'
-    zipped = StringIO.new(String.new, 'w')
-    zipped.set_encoding Encoding::BINARY if Object.const_defined? :Encoding
+    require "zlib"
+    require "stringio"
+    zipped = StringIO.new(String.new, "w")
+    zipped.set_encoding Encoding::BINARY
 
-    Zlib::GzipWriter.wrap zipped do |io| io.write data end
+    Zlib::GzipWriter.wrap zipped do |io|
+      io.write data
+    end
 
     zipped.string
   end
@@ -37,98 +46,74 @@ module Gem::Util
   # A Zlib::Inflate#inflate wrapper
 
   def self.inflate(data)
-    require 'zlib'
+    require "zlib"
     Zlib::Inflate.inflate data
   end
 
   ##
-  # This calls IO.popen where it accepts an array for a +command+ (Ruby 1.9+)
-  # and implements an IO.popen-like behavior where it does not accept an array
-  # for a command.
+  # This calls IO.popen and reads the result
 
-  def self.popen *command
+  def self.popen(*command)
     IO.popen command, &:read
-  rescue TypeError # ruby 1.8 only supports string command
-    r, w = IO.pipe
-
-    pid = fork do
-      STDIN.close
-      STDOUT.reopen w
-
-      exec(*command)
-    end
-
-    w.close
-
-    begin
-      return r.read
-    ensure
-      Process.wait pid
-    end
   end
 
-  NULL_DEVICE = defined?(IO::NULL) ? IO::NULL : Gem.win_platform? ? 'NUL' : '/dev/null'
-
   ##
   # Invokes system, but silences all output.
 
-  def self.silent_system *command
-    opt = {:out => NULL_DEVICE, :err => [:child, :out]}
+  def self.silent_system(*command)
+    opt = { :out => IO::NULL, :err => [:child, :out] }
     if Hash === command.last
       opt.update(command.last)
       cmds = command[0...-1]
     else
       cmds = command.dup
     end
-    return system(*(cmds << opt))
-  rescue TypeError
-    require 'thread'
-
-    @silent_mutex ||= Mutex.new
+    system(*(cmds << opt))
+  end
 
-    null_device = NULL_DEVICE
+  class << self
+    extend Gem::Deprecate
 
-    @silent_mutex.synchronize do
-      begin
-        stdout = STDOUT.dup
-        stderr = STDERR.dup
-
-        STDOUT.reopen null_device, 'w'
-        STDERR.reopen null_device, 'w'
-
-        return system(*command)
-      ensure
-        STDOUT.reopen stdout
-        STDERR.reopen stderr
-        stdout.close
-        stderr.close
-      end
-    end
+    rubygems_deprecate :silent_system
   end
 
   ##
   # Enumerates the parents of +directory+.
 
-  def self.traverse_parents directory
+  def self.traverse_parents(directory, &block)
     return enum_for __method__, directory unless block_given?
 
     here = File.expand_path directory
-    start = here
+    loop do
+      begin
+        Dir.chdir here, &block
+      rescue StandardError
+        Errno::EACCES
+      end
 
-    Dir.chdir start
+      new_here = File.expand_path("..", here)
+      return if new_here == here # toplevel
+      here = new_here
+    end
+  end
 
-    begin
-      loop do
-        yield here
+  ##
+  # Globs for files matching +pattern+ inside of +directory+,
+  # returning absolute paths to the matching files.
 
-        Dir.chdir '..'
+  def self.glob_files_in_dir(glob, base_path)
+    Dir.glob(glob, base: base_path).map! {|f| File.expand_path(f, base_path) }
+  end
 
-        return if Dir.pwd == here # toplevel
+  ##
+  # Corrects +path+ (usually returned by `URI.parse().path` on Windows), that
+  # comes with a leading slash.
 
-        here = Dir.pwd
-      end
-    ensure
-      Dir.chdir start
+  def self.correct_for_windows_path(path)
+    if path[0].chr == "/" && path[1].chr =~ /[a-z]/i && path[2].chr == ":"
+      path[1..-1]
+    else
+      path
     end
   end
 

data/lib/rubygems/validator.rb

@@ -1,45 +1,22 @@
 # frozen_string_literal: true
+
 #--
 # Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
 # All rights reserved.
 # See LICENSE.txt for permissions.
 #++
 
-require 'rubygems/package'
-require 'rubygems/installer'
+require_relative "package"
+require_relative "installer"
 
 ##
 # Validator performs various gem file and gem database validation
 
 class Gem::Validator
-
   include Gem::UserInteraction
 
   def initialize # :nodoc:
-    require 'find'
-  end
-
-  ##
-  # Given a gem file's contents, validates against its own MD5 checksum
-  # gem_data:: [String] Contents of the gem file
-
-  def verify_gem(gem_data)
-    # TODO remove me? The code here only validate an MD5SUM that was
-    # in some old formatted gems, but hasn't been for a long time.
-  end
-
-  ##
-  # Given the path to a gem file, validates against its own MD5 checksum
-  #
-  # gem_path:: [String] Path to gem file
-
-  def verify_gem_file(gem_path)
-    open gem_path, Gem.binary_mode do |file|
-      gem_data = file.read
-      verify_gem gem_data
-    end
-  rescue Errno::ENOENT, Errno::EINVAL
-    raise Gem::VerificationError, "missing gem file #{gem_path}"
+    require "find"
   end
 
   private
@@ -48,9 +25,9 @@ class Gem::Validator
     installed_files = []
 
     Find.find gem_directory do |file_name|
-      fn = file_name[gem_directory.size..file_name.size-1].sub(/^\//, "")
+      fn = file_name[gem_directory.size..file_name.size - 1].sub(/^\//, "")
       installed_files << fn unless
-        fn =~ /CVS/ || fn.empty? || File.directory?(file_name)
+        fn.empty? || fn.include?("CVS") || File.directory?(file_name)
     end
 
     installed_files
@@ -62,7 +39,7 @@ class Gem::Validator
   # Describes a problem with a file in a gem.
 
   ErrorData = Struct.new :path, :problem do
-    def <=> other # :nodoc:
+    def <=>(other) # :nodoc:
       return nil unless self.class === other
 
       [path, problem] <=> [other.path, other.problem]
@@ -83,7 +60,7 @@ class Gem::Validator
   # TODO needs further cleanup
 
   def alien(gems=[])
-    errors = Hash.new { |h,k| h[k] = {} }
+    errors = Hash.new {|h,k| h[k] = {} }
 
     Gem::Specification.each do |spec|
       next unless gems.include? spec.name unless gems.empty?
@@ -94,50 +71,50 @@ class Gem::Validator
       spec_path     = spec.spec_file
       gem_directory = spec.full_gem_path
 
-      unless File.directory? gem_directory then
+      unless File.directory? gem_directory
         errors[gem_name][spec.full_name] =
           "Gem registered but doesn't exist at #{gem_directory}"
         next
       end
 
-      unless File.exist? spec_path then
+      unless File.exist? spec_path
         errors[gem_name][spec_path] = "Spec file missing for installed gem"
       end
 
       begin
-        verify_gem_file(gem_path)
+        unless File.readable?(gem_path)
+          raise Gem::VerificationError, "missing gem file #{gem_path}"
+        end
 
         good, gone, unreadable = nil, nil, nil, nil
 
-        open gem_path, Gem.binary_mode do |file|
+        File.open gem_path, Gem.binary_mode do |file|
           package = Gem::Package.new gem_path
 
-          good, gone = package.contents.partition { |file_name|
+          good, gone = package.contents.partition do |file_name|
             File.exist? File.join(gem_directory, file_name)
-          }
+          end
 
           gone.sort.each do |path|
             errors[gem_name][path] = "Missing file"
           end
 
-          good, unreadable = good.partition { |file_name|
+          good, unreadable = good.partition do |file_name|
             File.readable? File.join(gem_directory, file_name)
-          }
+          end
 
           unreadable.sort.each do |path|
             errors[gem_name][path] = "Unreadable file"
           end
 
           good.each do |entry, data|
-            begin
-              next unless data # HACK `gem check -a mkrf`
+            next unless data # HACK: `gem check -a mkrf`
 
-              source = File.join gem_directory, entry['path']
+            source = File.join gem_directory, entry["path"]
 
-              open source, Gem.binary_mode do |f|
-                unless f.read == data then
-                  errors[gem_name][entry['path']] = "Modified from original"
-                end
+            File.open source, Gem.binary_mode do |f|
+              unless f.read == data
+                errors[gem_name][entry["path"]] = "Modified from original"
               end
             end
           end
@@ -163,4 +140,3 @@ class Gem::Validator
     errors
   end
 end
-

data/lib/rubygems/version.rb

@@ -1,4 +1,7 @@
 # frozen_string_literal: true
+
+require_relative "deprecate"
+
 ##
 # The Version class processes string versions into comparable
 # values. A version string should normally be a series of numbers
@@ -128,7 +131,7 @@
 #
 # == 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
@@ -150,12 +153,10 @@
 # a zero to give a sensible result.
 
 class Gem::Version
-  autoload :Requirement, 'rubygems/requirement'
-
   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/ # :nodoc:
+  ANCHORED_VERSION_PATTERN = /\A\s*(#{VERSION_PATTERN})?\s*\z/.freeze # :nodoc:
 
   ##
   # A string representation of this Version.
@@ -169,8 +170,10 @@ class Gem::Version
   ##
   # True if the +version+ string matches RubyGems' requirements.
 
-  def self.correct? version
-    version.to_s =~ ANCHORED_VERSION_PATTERN
+  def self.correct?(version)
+    nil_versions_are_discouraged! if version.nil?
+
+    !!(version.to_s =~ ANCHORED_VERSION_PATTERN)
   end
 
   ##
@@ -181,10 +184,12 @@ class Gem::Version
   #   ver2 = Version.create(ver1)       # -> (ver1)
   #   ver3 = Version.create(nil)        # -> nil
 
-  def self.create input
-    if self === input then # check yourself before you wreck yourself
+  def self.create(input)
+    if self === input # check yourself before you wreck yourself
       input
-    elsif input.nil? then
+    elsif input.nil?
+      nil_versions_are_discouraged!
+
       nil
     else
       new input
@@ -192,20 +197,34 @@ class Gem::Version
   end
 
   @@all = {}
+  @@bump = {}
+  @@release = {}
 
-  def self.new version # :nodoc:
+  def self.new(version) # :nodoc:
     return super unless Gem::Version == self
 
     @@all[version] ||= super
   end
 
+  def self.nil_versions_are_discouraged!
+    unless Gem::Deprecate.skip
+      warn "nil versions are discouraged and will be deprecated in Rubygems 4"
+    end
+  end
+
+  private_class_method :nil_versions_are_discouraged!
+
   ##
   # Constructs a Version from the +version+ string.  A version string is a
   # series of digits or ASCII letters separated by dots.
 
-  def initialize version
-    raise ArgumentError, "Malformed version number string #{version}" unless
-      self.class.correct?(version)
+  def initialize(version)
+    unless self.class.correct?(version)
+      raise ArgumentError, "Malformed version number string #{version}"
+    end
+
+    # If version is an empty string convert it to 0
+    version = 0 if version.is_a?(String) && version =~ /\A\s*\Z/
 
     @version = version.to_s.strip.gsub("-",".pre.")
     @segments = nil
@@ -218,29 +237,29 @@ class Gem::Version
   # Pre-release (alpha) parts, e.g, 5.3.1.b.2 => 5.4, are ignored.
 
   def bump
-    @bump ||= begin
-                segments = self.segments
-                segments.pop while segments.any? { |s| String === s }
-                segments.pop if segments.size > 1
-
-                segments[-1] = segments[-1].succ
-                self.class.new segments.join(".")
-              end
+    @@bump[self] ||= begin
+                       segments = self.segments
+                       segments.pop while segments.any? {|s| String === s }
+                       segments.pop if segments.size > 1
+
+                       segments[-1] = segments[-1].succ
+                       self.class.new segments.join(".")
+                     end
   end
 
   ##
   # A Version is only eql? to another version if it's specified to the
   # same precision. Version "1.0" is not the same as version "1".
 
-  def eql? other
-    self.class === other and @version == other._version
+  def eql?(other)
+    self.class === other && @version == other._version
   end
 
   def hash # :nodoc:
-    @version.hash
+    canonical_segments.hash
   end
 
-  def init_with coder # :nodoc:
+  def init_with(coder) # :nodoc:
     yaml_initialize coder.tag, coder.map
   end
 
@@ -253,19 +272,19 @@ class Gem::Version
   # string for backwards (RubyGems 1.3.5 and earlier) compatibility.
 
   def marshal_dump
-    [version]
+    [@version]
   end
 
   ##
   # Load custom marshal format. It's a string for backwards (RubyGems
   # 1.3.5 and earlier) compatibility.
 
-  def marshal_load array
+  def marshal_load(array)
     initialize array[0]
   end
 
   def yaml_initialize(tag, map) # :nodoc:
-    @version = map['version']
+    @version = map["version"]
     @segments = nil
     @hash = nil
   end
@@ -274,8 +293,8 @@ class Gem::Version
     ["@version"]
   end
 
-  def encode_with coder # :nodoc:
-    coder.add 'version', @version
+  def encode_with(coder) # :nodoc:
+    coder.add "version", @version
   end
 
   ##
@@ -288,7 +307,7 @@ class Gem::Version
     @prerelease
   end
 
-  def pretty_print q # :nodoc:
+  def pretty_print(q) # :nodoc:
     q.text "Gem::Version.new(#{version.inspect})"
   end
 
@@ -297,13 +316,13 @@ class Gem::Version
   # Non-prerelease versions return themselves.
 
   def release
-    @release ||= if prerelease?
-                   segments = self.segments
-                   segments.pop while segments.any? { |s| String === s }
-                   self.class.new segments.join('.')
-                 else
-                   self
-                 end
+    @@release[self] ||= if prerelease?
+      segments = self.segments
+      segments.pop while segments.any? {|s| String === s }
+      self.class.new segments.join(".")
+    else
+      self
+    end
   end
 
   def segments # :nodoc:
@@ -316,25 +335,29 @@ class Gem::Version
   def approximate_recommendation
     segments = self.segments
 
-    segments.pop    while segments.any? { |s| String === s }
+    segments.pop    while segments.any? {|s| String === s }
     segments.pop    while segments.size > 2
     segments.push 0 while segments.size < 2
 
-    "~> #{segments.join(".")}"
+    recommendation = "~> #{segments.join(".")}"
+    recommendation += ".a" if prerelease?
+    recommendation
   end
 
   ##
   # Compares this version with +other+ returning -1, 0, or 1 if the
   # other version is larger, the same, or smaller than this
   # one. Attempts to compare to something that's not a
-  # <tt>Gem::Version</tt> return +nil+.
+  # <tt>Gem::Version</tt> or a valid version String return +nil+.
+
+  def <=>(other)
+    return self <=> self.class.new(other) if (String === other) && self.class.correct?(other)
 
-  def <=> other
     return unless Gem::Version === other
-    return 0 if @version == other._version
+    return 0 if @version == other._version || canonical_segments == other.canonical_segments
 
-    lhsegments = _segments
-    rhsegments = other._segments
+    lhsegments = canonical_segments
+    rhsegments = other.canonical_segments
 
     lhsize = lhsegments.size
     rhsize = rhsegments.size
@@ -343,7 +366,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
@@ -353,7 +377,20 @@ class Gem::Version
       return lhs <=> rhs
     end
 
-    return 0
+    0
+  end
+
+  def canonical_segments
+    @canonical_segments ||=
+      _split_segments.map! do |segments|
+        segments.reverse_each.drop_while {|s| s == 0 }.reverse
+      end.reduce(&:concat)
+  end
+
+  def freeze
+    prerelease?
+    canonical_segments
+    super
   end
 
   protected
@@ -368,7 +405,14 @@ class Gem::Version
     # 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
+      /^\d+$/.match?(s) ? s.to_i : s
     end.freeze
   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)
+    [numeric_segments, string_segments]
+  end
 end