rubygems-update 3.1.6 → 3.3.22

data/lib/rubygems/platform.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-require "rubygems/deprecate"
+require_relative "deprecate"
 
 ##
 # Available list of platforms for targeting Gem installations.
@@ -7,34 +7,48 @@ require "rubygems/deprecate"
 # See `gem help platform` for information on platform matching.
 
 class Gem::Platform
-
   @local = nil
 
-  attr_accessor :cpu
-
-  attr_accessor :os
-
-  attr_accessor :version
+  attr_accessor :cpu, :os, :version
 
   def self.local
-    arch = RbConfig::CONFIG['arch']
+    arch = RbConfig::CONFIG["arch"]
     arch = "#{arch}_60" if arch =~ /mswin(?:32|64)$/
     @local ||= new(arch)
   end
 
   def self.match(platform)
-    Gem.platforms.any? do |local_platform|
-      platform.nil? or
-        local_platform == platform or
-        (local_platform != Gem::Platform::RUBY and local_platform =~ platform)
+    match_platforms?(platform, Gem.platforms)
+  end
+
+  def self.match_platforms?(platform, platforms)
+    platforms.any? do |local_platform|
+      platform.nil? ||
+        local_platform == platform ||
+        (local_platform != Gem::Platform::RUBY && platform =~ local_platform)
     end
   end
+  private_class_method :match_platforms?
+
+  def self.match_spec?(spec)
+    match_gem?(spec.platform, spec.name)
+  end
+
+  def self.match_gem?(platform, gem_name)
+    # Note: this method might be redefined by Ruby implementations to
+    # customize behavior per RUBY_ENGINE, gem_name or other criteria.
+    match_platforms?(platform, Gem.platforms)
+  end
+
+  def self.sort_priority(platform)
+    platform == Gem::Platform::RUBY ? -1 : 1
+  end
 
   def self.installable?(spec)
     if spec.respond_to? :installable_platform?
       spec.installable_platform?
     else
-      match spec.platform
+      match_spec? spec
     end
   end
 
@@ -42,7 +56,7 @@ class Gem::Platform
     case arch
     when Gem::Platform::CURRENT then
       Gem::Platform.local
-    when Gem::Platform::RUBY, nil, '' then
+    when Gem::Platform::RUBY, nil, "" then
       Gem::Platform::RUBY
     else
       super
@@ -54,9 +68,9 @@ class Gem::Platform
     when Array then
       @cpu, @os, @version = arch
     when String then
-      arch = arch.split '-'
+      arch = arch.split "-"
 
-      if arch.length > 2 and arch.last !~ /\d/  # reassemble x86-linux-gnu
+      if arch.length > 2 && arch.last !~ /\d+(\.\d+)?$/ # reassemble x86-linux-{libc}
         extra = arch.pop
         arch.last << "-#{extra}"
       end
@@ -64,11 +78,11 @@ class Gem::Platform
       cpu = arch.shift
 
       @cpu = case cpu
-             when /i\d86/ then 'x86'
-             else cpu
-             end
+      when /i\d86/ then "x86"
+      else cpu
+      end
 
-      if arch.length == 2 and arch.last =~ /^\d+(\.\d+)?$/  # for command-line
+      if arch.length == 2 && arch.last =~ /^\d+(\.\d+)?$/ # for command-line
         @os, @version = arch
         return
       end
@@ -77,31 +91,32 @@ class Gem::Platform
       @cpu, os = nil, cpu if os.nil? # legacy jruby
 
       @os, @version = case os
-                      when /aix(\d+)?/ then             [ 'aix',       $1  ]
-                      when /cygwin/ then                [ 'cygwin',    nil ]
-                      when /darwin(\d+)?/ then          [ 'darwin',    $1  ]
-                      when /^macruby$/ then             [ 'macruby',   nil ]
-                      when /freebsd(\d+)?/ then         [ 'freebsd',   $1  ]
-                      when /hpux(\d+)?/ then            [ 'hpux',      $1  ]
-                      when /^java$/, /^jruby$/ then     [ 'java',      nil ]
-                      when /^java([\d.]*)/ then         [ 'java',      $1  ]
-                      when /^dalvik(\d+)?$/ then        [ 'dalvik',    $1  ]
-                      when /^dotnet$/ then              [ 'dotnet',    nil ]
-                      when /^dotnet([\d.]*)/ then       [ 'dotnet',    $1  ]
-                      when /linux-?((?!gnu)\w+)?/ then  [ 'linux',     $1  ]
-                      when /mingw32/ then               [ 'mingw32',   nil ]
-                      when /(mswin\d+)(\_(\d+))?/ then
-                        os, version = $1, $3
-                        @cpu = 'x86' if @cpu.nil? and os =~ /32$/
-                        [os, version]
-                      when /netbsdelf/ then             [ 'netbsdelf', nil ]
-                      when /openbsd(\d+\.\d+)?/ then    [ 'openbsd',   $1  ]
-                      when /bitrig(\d+\.\d+)?/ then     [ 'bitrig',    $1  ]
-                      when /solaris(\d+\.\d+)?/ then    [ 'solaris',   $1  ]
-                      # test
-                      when /^(\w+_platform)(\d+)?/ then [ $1,          $2  ]
-                      else                              [ 'unknown',   nil ]
-                      end
+      when /aix(\d+)?/ then             [ "aix",       $1  ]
+      when /cygwin/ then                [ "cygwin",    nil ]
+      when /darwin(\d+)?/ then          [ "darwin",    $1  ]
+      when /^macruby$/ then             [ "macruby",   nil ]
+      when /freebsd(\d+)?/ then         [ "freebsd",   $1  ]
+      when /hpux(\d+)?/ then            [ "hpux",      $1  ]
+      when /^java$/, /^jruby$/ then     [ "java",      nil ]
+      when /^java([\d.]*)/ then         [ "java",      $1  ]
+      when /^dalvik(\d+)?$/ then        [ "dalvik",    $1  ]
+      when /^dotnet$/ then              [ "dotnet",    nil ]
+      when /^dotnet([\d.]*)/ then       [ "dotnet",    $1  ]
+      when /linux-?(\w+)?/ then         [ "linux",     $1  ]
+      when /mingw32/ then               [ "mingw32",   nil ]
+      when /mingw-?(\w+)?/ then         [ "mingw",     $1  ]
+      when /(mswin\d+)(\_(\d+))?/ then
+        os, version = $1, $3
+        @cpu = "x86" if @cpu.nil? && os =~ /32$/
+        [os, version]
+      when /netbsdelf/ then             [ "netbsdelf", nil ]
+      when /openbsd(\d+\.\d+)?/ then    [ "openbsd",   $1  ]
+      when /bitrig(\d+\.\d+)?/ then     [ "bitrig",    $1  ]
+      when /solaris(\d+\.\d+)?/ then    [ "solaris",   $1  ]
+      # test
+      when /^(\w+_platform)(\d+)?/ then [ $1,          $2  ]
+      else                              [ "unknown",   nil ]
+      end
     when Gem::Platform then
       @cpu = arch.cpu
       @os = arch.os
@@ -111,16 +126,12 @@ class Gem::Platform
     end
   end
 
-  def inspect
-    "%s @cpu=%p, @os=%p, @version=%p>" % [super[0..-2], *to_a]
-  end
-
   def to_a
     [@cpu, @os, @version]
   end
 
   def to_s
-    to_a.compact.join '-'
+    to_a.compact.join "-"
   end
 
   ##
@@ -128,7 +139,7 @@ class Gem::Platform
   # the same CPU, OS and version.
 
   def ==(other)
-    self.class === other and to_a == other.to_a
+    self.class === other && to_a == other.to_a
   end
 
   alias :eql? :==
@@ -140,23 +151,38 @@ class Gem::Platform
   ##
   # Does +other+ match this platform?  Two platforms match if they have the
   # same CPU, or either has a CPU of 'universal', they have the same OS, and
-  # they have the same version, or either has no version.
+  # they have the same version, or either one has no version
   #
   # Additionally, the platform will match if the local CPU is 'arm' and the
   # other CPU starts with "arm" (for generic ARM family support).
+  #
+  # Of note, this method is not commutative. Indeed the OS 'linux' has a
+  # special case: the version is the libc name, yet while "no version" stands
+  # as a wildcard for a binary gem platform (as for other OSes), for the
+  # runtime platform "no version" stands for 'gnu'. To be able to disinguish
+  # these, the method receiver is the gem platform, while the argument is
+  # the runtime platform.
 
   def ===(other)
     return nil unless Gem::Platform === other
 
-    # cpu
-    ([nil,'universal'].include?(@cpu) or [nil, 'universal'].include?(other.cpu) or @cpu == other.cpu or
-    (@cpu == 'arm' and other.cpu =~ /\Aarm/)) and
-
-    # os
-    @os == other.os and
+    # universal-mingw32 matches x64-mingw-ucrt
+    return true if (@cpu == "universal" || other.cpu == "universal") &&
+                   @os.start_with?("mingw") && other.os.start_with?("mingw")
 
-    # version
-    (@version.nil? or other.version.nil? or @version == other.version)
+    # cpu
+    ([nil,"universal"].include?(@cpu) || [nil, "universal"].include?(other.cpu) || @cpu == other.cpu ||
+    (@cpu == "arm" && other.cpu.start_with?("arm"))) &&
+
+      # os
+      @os == other.os &&
+
+      # version
+      (
+        (@os != "linux" && (@version.nil? || other.version.nil?)) ||
+        (@os == "linux" && (other.version == "gnu#{@version}" || other.version == "musl#{@version}" || @version == "gnu#{other.version}")) ||
+        @version == other.version
+      )
   end
 
   ##
@@ -169,19 +195,19 @@ class Gem::Platform
     when String then
       # This data is from http://gems.rubyforge.org/gems/yaml on 19 Aug 2007
       other = case other
-              when /^i686-darwin(\d)/     then ['x86',       'darwin',  $1    ]
-              when /^i\d86-linux/         then ['x86',       'linux',   nil   ]
-              when 'java', 'jruby'        then [nil,         'java',    nil   ]
-              when /^dalvik(\d+)?$/       then [nil,         'dalvik',  $1    ]
-              when /dotnet(\-(\d+\.\d+))?/ then ['universal','dotnet',  $2    ]
-              when /mswin32(\_(\d+))?/    then ['x86',       'mswin32', $2    ]
-              when /mswin64(\_(\d+))?/    then ['x64',       'mswin64', $2    ]
-              when 'powerpc-darwin'       then ['powerpc',   'darwin',  nil   ]
-              when /powerpc-darwin(\d)/   then ['powerpc',   'darwin',  $1    ]
-              when /sparc-solaris2.8/     then ['sparc',     'solaris', '2.8' ]
-              when /universal-darwin(\d)/ then ['universal', 'darwin',  $1    ]
-              else                             other
-              end
+      when /^i686-darwin(\d)/     then ["x86",       "darwin",  $1    ]
+      when /^i\d86-linux/         then ["x86",       "linux",   nil   ]
+      when "java", "jruby"        then [nil,         "java",    nil   ]
+      when /^dalvik(\d+)?$/       then [nil,         "dalvik",  $1    ]
+      when /dotnet(\-(\d+\.\d+))?/ then ["universal","dotnet",  $2    ]
+      when /mswin32(\_(\d+))?/    then ["x86",       "mswin32", $2    ]
+      when /mswin64(\_(\d+))?/    then ["x64",       "mswin64", $2    ]
+      when "powerpc-darwin"       then ["powerpc",   "darwin",  nil   ]
+      when /powerpc-darwin(\d)/   then ["powerpc",   "darwin",  $1    ]
+      when /sparc-solaris2.8/     then ["sparc",     "solaris", "2.8" ]
+      when /universal-darwin(\d)/ then ["universal", "darwin",  $1    ]
+      else                             other
+      end
 
       other = Gem::Platform.new other
     else
@@ -195,12 +221,11 @@ class Gem::Platform
   # A pure-Ruby gem that may use Gem::Specification#extensions to build
   # binary files.
 
-  RUBY = 'ruby'.freeze
+  RUBY = "ruby".freeze
 
   ##
   # A platform-specific gem that is built for the packaging Ruby's platform.
   # This will be replaced with Gem::Platform::local.
 
-  CURRENT = 'current'.freeze
-
+  CURRENT = "current".freeze
 end

data/lib/rubygems/psych_tree.rb

@@ -2,13 +2,12 @@
 module Gem
   if defined? ::Psych::Visitors
     class NoAliasYAMLTree < Psych::Visitors::YAMLTree
-
       def self.create
         new({})
       end unless respond_to? :create
 
       def visit_String(str)
-        return super unless str == '=' # or whatever you want
+        return super unless str == "=" # or whatever you want
 
         quote = Psych::Nodes::Scalar::SINGLE_QUOTED
         @emitter.scalar str, nil, nil, false, true, quote
@@ -28,7 +27,6 @@ module Gem
       end
 
       private :format_time
-
     end
   end
 end

data/lib/rubygems/query_utils.rb

@@ -0,0 +1,351 @@
+# frozen_string_literal: true
+
+require_relative "local_remote_options"
+require_relative "spec_fetcher"
+require_relative "version_option"
+require_relative "text"
+
+module Gem::QueryUtils
+
+  include Gem::Text
+  include Gem::LocalRemoteOptions
+  include Gem::VersionOption
+
+  def add_query_options
+    add_option("-i", "--[no-]installed",
+               "Check for installed gem") do |value, options|
+      options[:installed] = value
+    end
+
+    add_option("-I", "Equivalent to --no-installed") do |value, options|
+      options[:installed] = false
+    end
+
+    add_version_option command, "for use with --installed"
+
+    add_option("-d", "--[no-]details",
+               "Display detailed information of gem(s)") do |value, options|
+      options[:details] = value
+    end
+
+    add_option("--[no-]versions",
+               "Display only gem names") do |value, options|
+      options[:versions] = value
+      options[:details] = false unless value
+    end
+
+    add_option("-a", "--all",
+               "Display all gem versions") do |value, options|
+      options[:all] = value
+    end
+
+    add_option("-e", "--exact",
+               "Name of gem(s) to query on matches the",
+               "provided STRING") do |value, options|
+      options[:exact] = value
+    end
+
+    add_option("--[no-]prerelease",
+               "Display prerelease versions") do |value, options|
+      options[:prerelease] = value
+    end
+
+    add_local_remote_options
+  end
+
+  def defaults_str # :nodoc:
+    "--local --no-details --versions --no-installed"
+  end
+
+  def execute
+    gem_names = if args.empty?
+      [options[:name]]
+    else
+      options[:exact] ? args.map {|arg| /\A#{Regexp.escape(arg)}\Z/ } : args.map {|arg| /#{arg}/i }
+    end
+
+    terminate_interaction(check_installed_gems(gem_names)) if check_installed_gems?
+
+    gem_names.each {|n| show_gems(n) }
+  end
+
+  private
+
+  def check_installed_gems(gem_names)
+    exit_code = 0
+
+    if args.empty? && !gem_name?
+      alert_error "You must specify a gem name"
+      exit_code = 4
+    elsif gem_names.count > 1
+      alert_error "You must specify only ONE gem!"
+      exit_code = 4
+    else
+      installed = installed?(gem_names.first, options[:version])
+      installed = !installed unless options[:installed]
+
+      say(installed)
+      exit_code = 1 if !installed
+    end
+
+    exit_code
+  end
+
+  def check_installed_gems?
+    !options[:installed].nil?
+  end
+
+  def gem_name?
+    !options[:name].nil?
+  end
+
+  def prerelease
+    options[:prerelease]
+  end
+
+  def show_prereleases?
+    prerelease.nil? || prerelease
+  end
+
+  def args
+    options[:args].to_a
+  end
+
+  def display_header(type)
+    if (ui.outs.tty? && Gem.configuration.verbose) || both?
+      say
+      say "*** #{type} GEMS ***"
+      say
+    end
+  end
+
+  #Guts of original execute
+  def show_gems(name)
+    show_local_gems(name)  if local?
+    show_remote_gems(name) if remote?
+  end
+
+  def show_local_gems(name, req = Gem::Requirement.default)
+    display_header("LOCAL")
+
+    specs = Gem::Specification.find_all do |s|
+      name_matches = name ? s.name =~ name : true
+      version_matches = show_prereleases? || !s.version.prerelease?
+
+      name_matches && version_matches
+    end
+
+    spec_tuples = specs.map do |spec|
+      [spec.name_tuple, spec]
+    end
+
+    output_query_results(spec_tuples)
+  end
+
+  def show_remote_gems(name)
+    display_header("REMOTE")
+
+    fetcher = Gem::SpecFetcher.fetcher
+
+    spec_tuples = if name.nil?
+      fetcher.detect(specs_type) { true }
+    else
+      fetcher.detect(specs_type) do |name_tuple|
+        name === name_tuple.name && options[:version].satisfied_by?(name_tuple.version)
+      end
+    end
+
+    output_query_results(spec_tuples)
+  end
+
+  def specs_type
+    if options[:all] || options[:version].specific?
+      if options[:prerelease]
+        :complete
+      else
+        :released
+      end
+    elsif options[:prerelease]
+      :prerelease
+    else
+      :latest
+    end
+  end
+
+  ##
+  # Check if gem +name+ version +version+ is installed.
+
+  def installed?(name, req = Gem::Requirement.default)
+    Gem::Specification.any? {|s| s.name =~ name && req =~ s.version }
+  end
+
+  def output_query_results(spec_tuples)
+    output = []
+    versions = Hash.new {|h,name| h[name] = [] }
+
+    spec_tuples.each do |spec_tuple, source|
+      versions[spec_tuple.name] << [spec_tuple, source]
+    end
+
+    versions = versions.sort_by do |(n,_),_|
+      n.downcase
+    end
+
+    output_versions output, versions
+
+    say output.join(options[:details] ? "\n\n" : "\n")
+  end
+
+  def output_versions(output, versions)
+    versions.each do |gem_name, matching_tuples|
+      matching_tuples = matching_tuples.sort_by {|n,_| n.version }.reverse
+
+      platforms = Hash.new {|h,version| h[version] = [] }
+
+      matching_tuples.each do |n, _|
+        platforms[n.version] << n.platform if n.platform
+      end
+
+      seen = {}
+
+      matching_tuples.delete_if do |n,_|
+        if seen[n.version]
+          true
+        else
+          seen[n.version] = true
+          false
+        end
+      end
+
+      output << clean_text(make_entry(matching_tuples, platforms))
+    end
+  end
+
+  def entry_details(entry, detail_tuple, specs, platforms)
+    return unless options[:details]
+
+    name_tuple, spec = detail_tuple
+
+    spec = spec.fetch_spec(name_tuple)if spec.respond_to?(:fetch_spec)
+
+    entry << "\n"
+
+    spec_platforms   entry, platforms
+    spec_authors     entry, spec
+    spec_homepage    entry, spec
+    spec_license     entry, spec
+    spec_loaded_from entry, spec, specs
+    spec_summary     entry, spec
+  end
+
+  def entry_versions(entry, name_tuples, platforms, specs)
+    return unless options[:versions]
+
+    list =
+      if platforms.empty? || options[:details]
+        name_tuples.map {|n| n.version }.uniq
+      else
+        platforms.sort.reverse.map do |version, pls|
+          out = version.to_s
+
+          if options[:domain] == :local
+            default = specs.any? do |s|
+              !s.is_a?(Gem::Source) && s.version == version && s.default_gem?
+            end
+            out = "default: #{out}" if default
+          end
+
+          if pls != [Gem::Platform::RUBY]
+            platform_list = [pls.delete(Gem::Platform::RUBY), *pls.sort].compact
+            out = platform_list.unshift(out).join(" ")
+          end
+
+          out
+        end
+      end
+
+    entry << " (#{list.join ', '})"
+  end
+
+  def make_entry(entry_tuples, platforms)
+    detail_tuple = entry_tuples.first
+
+    name_tuples, specs = entry_tuples.flatten.partition do |item|
+      Gem::NameTuple === item
+    end
+
+    entry = [name_tuples.first.name]
+
+    entry_versions(entry, name_tuples, platforms, specs)
+    entry_details(entry, detail_tuple, specs, platforms)
+
+    entry.join
+  end
+
+  def spec_authors(entry, spec)
+    authors = "Author#{spec.authors.length > 1 ? 's' : ''}: ".dup
+    authors << spec.authors.join(", ")
+    entry << format_text(authors, 68, 4)
+  end
+
+  def spec_homepage(entry, spec)
+    return if spec.homepage.nil? || spec.homepage.empty?
+
+    entry << "\n" << format_text("Homepage: #{spec.homepage}", 68, 4)
+  end
+
+  def spec_license(entry, spec)
+    return if spec.license.nil? || spec.license.empty?
+
+    licenses = "License#{spec.licenses.length > 1 ? 's' : ''}: ".dup
+    licenses << spec.licenses.join(", ")
+    entry << "\n" << format_text(licenses, 68, 4)
+  end
+
+  def spec_loaded_from(entry, spec, specs)
+    return unless spec.loaded_from
+
+    if specs.length == 1
+      default = spec.default_gem? ? " (default)" : nil
+      entry << "\n" << "    Installed at#{default}: #{spec.base_dir}"
+    else
+      label = "Installed at"
+      specs.each do |s|
+        version = s.version.to_s
+        version << ", default" if s.default_gem?
+        entry << "\n" << "    #{label} (#{version}): #{s.base_dir}"
+        label = " " * label.length
+      end
+    end
+  end
+
+  def spec_platforms(entry, platforms)
+    non_ruby = platforms.any? do |_, pls|
+      pls.any? {|pl| pl != Gem::Platform::RUBY }
+    end
+
+    return unless non_ruby
+
+    if platforms.length == 1
+      title = platforms.values.length == 1 ? "Platform" : "Platforms"
+      entry << "    #{title}: #{platforms.values.sort.join(', ')}\n"
+    else
+      entry << "    Platforms:\n"
+
+      sorted_platforms = platforms.sort_by {|version,| version }
+
+      sorted_platforms.each do |version, pls|
+        label = "        #{version}: "
+        data = format_text pls.sort.join(", "), 68, label.length
+        data[0, label.length] = label
+        entry << data << "\n"
+      end
+    end
+  end
+
+  def spec_summary(entry, spec)
+    summary = truncate_text(spec.summary, "the summary for #{spec.full_name}")
+    entry << "\n\n" << format_text(summary, 68, 4)
+  end
+
+end

data/lib/rubygems/rdoc.rb

@@ -1,20 +1,8 @@
 # frozen_string_literal: true
-require 'rubygems'
+require_relative "../rubygems"
 
 begin
-  gem 'rdoc'
-rescue Gem::LoadError
-  # swallow
-else
-  # This will force any deps that 'rdoc' might have
-  # (such as json) that are ambiguous to be activated, which
-  # is important because we end up using Specification.reset
-  # and we don't want the warning it pops out.
-  Gem.finish_resolve
-end
-
-begin
-  require 'rdoc/rubygems_hook'
+  require "rdoc/rubygems_hook"
   module Gem
     RDoc = ::RDoc::RubygemsHook
   end