rubygems-update 3.0.6 → 3.2.14

data/lib/rubygems/query_utils.rb

@@ -0,0 +1,353 @@
+# frozen_string_literal: true
+
+require 'rubygems/local_remote_options'
+require 'rubygems/spec_fetcher'
+require 'rubygems/version_option'
+require 'rubygems/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 --name-matches // --no-details --versions --no-installed"
+  end
+
+  def execute
+    gem_names = Array(options[:name])
+
+    if !args.empty?
+      gem_names = 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].source.empty?
+  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? and Gem.configuration.verbose) or 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|
+      s.name =~ name and req =~ s.version
+    end
+
+    dep = Gem::Deprecate.skip_during { Gem::Dependency.new name, req }
+    specs.select! do |s|
+      dep.match?(s.name, s.version, show_prereleases?)
+    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.respond_to?(:source) && name.source.empty?
+                    fetcher.detect(specs_type) { true }
+                  else
+                    fetcher.detect(specs_type) do |name_tuple|
+                      name === name_tuple.name
+                    end
+                  end
+
+    output_query_results(spec_tuples)
+  end
+
+  def specs_type
+    if options[:all]
+      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 and 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? or 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? or spec.homepage.empty?
+
+    entry << "\n" << format_text("Homepage: #{spec.homepage}", 68, 4)
+  end
+
+  def spec_license(entry, spec)
+    return if spec.license.nil? or 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,18 +1,6 @@
 # frozen_string_literal: true
 require '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'
   module Gem

data/lib/rubygems/remote_fetcher.rb

@@ -4,6 +4,7 @@ require 'rubygems/request'
 require 'rubygems/request/connection_pools'
 require 'rubygems/s3_uri_signer'
 require 'rubygems/uri_formatter'
+require 'rubygems/uri_parsing'
 require 'rubygems/user_interaction'
 require 'resolv'
 
@@ -12,35 +13,36 @@ require 'resolv'
 # a remote source.
 
 class Gem::RemoteFetcher
-
   include Gem::UserInteraction
+  include Gem::UriParsing
 
   ##
   # A FetchError exception wraps up the various possible IO and HTTP failures
   # that could happen while downloading from the internet.
 
   class FetchError < Gem::Exception
+    include Gem::UriParsing
 
     ##
     # The URI which was being accessed when the exception happened.
 
-    attr_accessor :uri
+    attr_accessor :uri, :original_uri
 
     def initialize(message, uri)
       super message
-      begin
-        uri = URI(uri)
-        uri.password = 'REDACTED' if uri.password
-        @uri = uri.to_s
-      rescue URI::InvalidURIError, ArgumentError
-        @uri = uri
-      end
+
+      uri = parse_uri(uri)
+
+      @original_uri = uri.dup
+
+      uri.password = 'REDACTED' if uri.respond_to?(:password) && uri.password
+
+      @uri = uri.to_s
     end
 
     def to_s # :nodoc:
       "#{super} (#{uri})"
     end
-
   end
 
   ##
@@ -49,6 +51,7 @@ class Gem::RemoteFetcher
 
   class UnknownHostError < FetchError
   end
+  deprecate_constant(:UnknownHostError)
 
   @fetcher = nil
 
@@ -76,9 +79,9 @@ class Gem::RemoteFetcher
   #            fetching the gem.
 
   def initialize(proxy=nil, dns=nil, headers={})
+    require 'rubygems/core_ext/tcpsocket_init' if Gem.configuration.ipv4_fallback_enabled
     require 'net/http'
     require 'stringio'
-    require 'time'
     require 'uri'
 
     Socket.do_not_reverse_lookup = true
@@ -103,9 +106,9 @@ class Gem::RemoteFetcher
 
     return if found.empty?
 
-    spec, source = found.max_by { |(s,_)| s.version }
+    spec, source = found.max_by {|(s,_)| s.version }
 
-    download spec, source.uri.to_s
+    download spec, source.uri
   end
 
   ##
@@ -114,11 +117,12 @@ class Gem::RemoteFetcher
   # always replaced.
 
   def download(spec, source_uri, install_dir = Gem.dir)
+    install_cache_dir = File.join install_dir, "cache"
     cache_dir =
-      if Dir.pwd == install_dir  # see fetch_command
+      if Dir.pwd == install_dir # see fetch_command
         install_dir
-      elsif File.writable? install_dir
-        File.join install_dir, "cache"
+      elsif File.writable?(install_cache_dir) || (File.writable?(install_dir) && (not File.exist?(install_cache_dir)))
+        install_cache_dir
       else
         File.join Gem.user_dir, "cache"
       end
@@ -126,20 +130,10 @@ class Gem::RemoteFetcher
     gem_file_name = File.basename spec.cache_file
     local_gem_path = File.join cache_dir, gem_file_name
 
+    require "fileutils"
     FileUtils.mkdir_p cache_dir rescue nil unless File.exist? cache_dir
 
-    # Always escape URI's to deal with potential spaces and such
-    # It should also be considered that source_uri may already be
-    # a valid URI with escaped characters. e.g. "{DESede}" is encoded
-    # as "%7BDESede%7D". If this is escaped again the percentage
-    # symbols will be escaped.
-    unless source_uri.is_a?(URI::Generic)
-      begin
-        source_uri = URI.parse(source_uri)
-      rescue
-        source_uri = URI.parse(URI::DEFAULT_PARSER.escape(source_uri.to_s))
-      end
-    end
+    source_uri = parse_uri(source_uri)
 
     scheme = source_uri.scheme
 
@@ -157,7 +151,7 @@ class Gem::RemoteFetcher
           remote_gem_path = source_uri + "gems/#{gem_file_name}"
 
           self.cache_update_path remote_gem_path, local_gem_path
-        rescue Gem::RemoteFetcher::FetchError
+        rescue FetchError
           raise if spec.original_platform == spec.platform
 
           alternate_name = "#{spec.original_name}.gem"
@@ -220,12 +214,12 @@ class Gem::RemoteFetcher
   def fetch_http(uri, last_modified = nil, head = false, depth = 0)
     fetch_type = head ? Net::HTTP::Head : Net::HTTP::Get
     response   = request uri, fetch_type, last_modified do |req|
-      headers.each { |k,v| req.add_field(k,v) }
+      headers.each {|k,v| req.add_field(k,v) }
     end
 
     case response
     when Net::HTTPOK, Net::HTTPNotModified then
-      response.uri = uri if response.respond_to? :uri
+      response.uri = uri
       head ? response : response.body
     when Net::HTTPMovedPermanently, Net::HTTPFound, Net::HTTPSeeOther,
          Net::HTTPTemporaryRedirect then
@@ -234,7 +228,7 @@ class Gem::RemoteFetcher
       unless location = response['Location']
         raise FetchError.new("redirecting but no redirect location was given", uri)
       end
-      location = URI.parse response['Location']
+      location = parse_uri location
 
       if https?(uri) && !https?(location)
         raise FetchError.new("redirecting to non-https resource: #{location}", uri)
@@ -252,9 +246,7 @@ class Gem::RemoteFetcher
   # Downloads +uri+ and returns it as a String.
 
   def fetch_path(uri, mtime = nil, head = false)
-    uri = URI.parse uri unless URI::Generic === uri
-
-    raise ArgumentError, "bad uri: #{uri}" unless uri
+    uri = parse_uri uri
 
     unless uri.scheme
       raise ArgumentError, "uri scheme is invalid: #{uri.scheme.inspect}"
@@ -262,26 +254,18 @@ class Gem::RemoteFetcher
 
     data = send "fetch_#{uri.scheme}", uri, mtime, head
 
-    if data and !head and uri.to_s =~ /\.gz$/
+    if data and !head and uri.to_s.end_with?(".gz")
       begin
         data = Gem::Util.gunzip data
       rescue Zlib::GzipFile::Error
-        raise FetchError.new("server did not return a valid file", uri.to_s)
+        raise FetchError.new("server did not return a valid file", uri)
       end
     end
 
     data
-  rescue FetchError
-    raise
-  rescue Timeout::Error
-    raise UnknownHostError.new('timed out', uri.to_s)
-  rescue IOError, SocketError, SystemCallError,
-         *(OpenSSL::SSL::SSLError if defined?(OpenSSL)) => e
-    if e.message =~ /getaddrinfo/
-      raise UnknownHostError.new('no such name', uri.to_s)
-    else
-      raise FetchError.new("#{e.class}: #{e}", uri.to_s)
-    end
+  rescue Timeout::Error, IOError, SocketError, SystemCallError,
+         *(OpenSSL::SSL::SSLError if Gem::HAVE_OPENSSL) => e
+    raise FetchError.new("#{e.class}: #{e}", uri)
   end
 
   def fetch_s3(uri, mtime = nil, head = false)
@@ -318,15 +302,6 @@ class Gem::RemoteFetcher
     data
   end
 
-  ##
-  # Returns the size of +uri+ in bytes.
-
-  def fetch_size(uri) # TODO: phase this out
-    response = fetch_path(uri, nil, true)
-
-    response['content-length'].to_i
-  end
-
   ##
   # Performs a Net::HTTP request of type +request_class+ on +uri+ returning
   # a Net::HTTP response object.  request maintains a table of persistent
@@ -348,7 +323,7 @@ class Gem::RemoteFetcher
   end
 
   def close_all
-    @pools.each_value {|pool| pool.close_all}
+    @pools.each_value {|pool| pool.close_all }
   end
 
   private
@@ -362,5 +337,4 @@ class Gem::RemoteFetcher
       @pools[proxy] ||= Gem::Request::ConnectionPools.new proxy, @cert_files
     end
   end
-
 end