rubygems-update 3.0.3 → 3.4.7

data/lib/rubygems/commands/query_command.rb

@@ -1,71 +1,35 @@
 # frozen_string_literal: true
-require 'rubygems/command'
-require 'rubygems/local_remote_options'
-require 'rubygems/spec_fetcher'
-require 'rubygems/version_option'
-require 'rubygems/text'
+require_relative "../command"
+require_relative "../query_utils"
+require_relative "../deprecate"
 
 class Gem::Commands::QueryCommand < Gem::Command
+  extend Gem::Deprecate
+  rubygems_deprecate_command
 
-  include Gem::Text
-  include Gem::LocalRemoteOptions
-  include Gem::VersionOption
+  include Gem::QueryUtils
 
-  def initialize(name = 'query',
-                 summary = 'Query gem information in local or remote repositories')
-    super name, summary,
-         :name => //, :domain => :local, :details => false, :versions => true,
-         :installed => nil, :version => Gem::Requirement.default
-
-    add_option('-i', '--[no-]installed',
-               'Check for installed gem') do |value, options|
-      options[:installed] = value
-    end
+  alias warning_without_suggested_alternatives deprecation_warning
+  def deprecation_warning
+    warning_without_suggested_alternatives
 
-    add_option('-I', 'Equivalent to --no-installed') do |value, options|
-      options[:installed] = false
-    end
+    message = "It is recommended that you use `gem search` or `gem list` instead.\n"
+    alert_warning message unless Gem::Deprecate.skip
+  end
 
-    add_version_option command, "for use with --installed"
+  def initialize(name = "query",
+                 summary = "Query gem information in local or remote repositories")
+    super name, summary,
+         :domain => :local, :details => false, :versions => true,
+         :installed => nil, :version => Gem::Requirement.default
 
-    add_option('-n', '--name-matches REGEXP',
-               'Name of gem(s) to query on matches the',
-               'provided REGEXP') do |value, options|
+    add_option("-n", "--name-matches REGEXP",
+               "Name of gem(s) to query on matches the",
+               "provided REGEXP") do |value, options|
       options[:name] = /#{value}/i
     end
 
-    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"
+    add_query_options
   end
 
   def description # :nodoc:
@@ -76,284 +40,4 @@ You should really use the list and search commands instead.  This command
 is too hard to use.
     EOF
   end
-
-  def execute
-    exit_code = 0
-    if options[:args].to_a.empty? and options[:name].source.empty?
-      name = options[:name]
-      no_name = true
-    elsif !options[:name].source.empty?
-      name = Array(options[:name])
-    else
-      args = options[:args].to_a
-      name = options[:exact] ? args.map{|arg| /\A#{Regexp.escape(arg)}\Z/ } : args.map{|arg| /#{arg}/i }
-    end
-
-    prerelease = options[:prerelease]
-
-    unless options[:installed].nil?
-      if no_name
-        alert_error "You must specify a gem name"
-        exit_code |= 4
-      elsif name.count > 1
-        alert_error "You must specify only ONE gem!"
-        exit_code |= 4
-      else
-        installed = installed? name.first, options[:version]
-        installed = !installed unless options[:installed]
-
-        if installed
-          say "true"
-        else
-          say "false"
-          exit_code |= 1
-        end
-      end
-
-      terminate_interaction exit_code
-    end
-
-    names = Array(name)
-    names.each { |n| show_gems n, prerelease }
-  end
-
-  private
-
-  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, prerelease)
-    req = Gem::Requirement.default
-    # TODO: deprecate for real
-    dep = Gem::Deprecate.skip_during { Gem::Dependency.new name, req }
-    dep.prerelease = prerelease
-
-    if local?
-      if prerelease and not both?
-        alert_warning "prereleases are always shown locally"
-      end
-
-      display_header 'LOCAL'
-
-      specs = Gem::Specification.find_all { |s|
-        s.name =~ name and req =~ s.version
-      }
-
-      spec_tuples = specs.map do |spec|
-        [spec.name_tuple, spec]
-      end
-
-      output_query_results spec_tuples
-    end
-
-    if remote?
-      display_header 'REMOTE'
-
-      fetcher = Gem::SpecFetcher.fetcher
-
-      type = if options[:all]
-               if options[:prerelease]
-                 :complete
-               else
-                 :released
-               end
-             elsif options[:prerelease]
-               :prerelease
-             else
-               :latest
-             end
-
-      if name.respond_to?(:source) && name.source.empty?
-        spec_tuples = fetcher.detect(type) { true }
-      else
-        spec_tuples = fetcher.detect(type) do |name_tuple|
-          name === name_tuple.name
-        end
-      end
-
-      output_query_results spec_tuples
-    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"
-      platforms.sort_by do |version,|
-        version
-      end.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/commands/rdoc_command.rb

@@ -1,35 +1,35 @@
 # frozen_string_literal: true
-require 'rubygems/command'
-require 'rubygems/version_option'
-require 'rubygems/rdoc'
-require 'fileutils'
+require_relative "../command"
+require_relative "../version_option"
+require_relative "../rdoc"
+require "fileutils"
 
 class Gem::Commands::RdocCommand < Gem::Command
   include Gem::VersionOption
 
   def initialize
-    super 'rdoc', 'Generates RDoc for pre-installed gems',
+    super "rdoc", "Generates RDoc for pre-installed gems",
           :version => Gem::Requirement.default,
           :include_rdoc => false, :include_ri => true, :overwrite => false
 
-    add_option('--all',
-               'Generate RDoc/RI documentation for all',
-               'installed gems') do |value, options|
+    add_option("--all",
+               "Generate RDoc/RI documentation for all",
+               "installed gems") do |value, options|
       options[:all] = value
     end
 
-    add_option('--[no-]rdoc',
-               'Generate RDoc HTML') do |value, options|
+    add_option("--[no-]rdoc",
+               "Generate RDoc HTML") do |value, options|
       options[:include_rdoc] = value
     end
 
-    add_option('--[no-]ri',
-               'Generate RI data') do |value, options|
+    add_option("--[no-]ri",
+               "Generate RI data") do |value, options|
       options[:include_ri] = value
     end
 
-    add_option('--[no-]overwrite',
-               'Overwrite installed documents') do |value, options|
+    add_option("--[no-]overwrite",
+               "Overwrite installed documents") do |value, options|
       options[:overwrite] = value
     end
 
@@ -61,15 +61,15 @@ Use --overwrite to force rebuilding of documentation.
 
   def execute
     specs = if options[:all]
-              Gem::Specification.to_a
-            else
-              get_all_gem_names.map do |name|
-                Gem::Specification.find_by_name name, options[:version]
-              end.flatten.uniq
-            end
+      Gem::Specification.to_a
+    else
+      get_all_gem_names.map do |name|
+        Gem::Specification.find_by_name name, options[:version]
+      end.flatten.uniq
+    end
 
     if specs.empty?
-      alert_error 'No matching gems found'
+      alert_error "No matching gems found"
       terminate_interaction 1
     end
 
@@ -79,18 +79,18 @@ Use --overwrite to force rebuilding of documentation.
       doc.force = options[:overwrite]
 
       if options[:overwrite]
-        FileUtils.rm_rf File.join(spec.doc_dir, 'ri')
-        FileUtils.rm_rf File.join(spec.doc_dir, 'rdoc')
+        FileUtils.rm_rf File.join(spec.doc_dir, "ri")
+        FileUtils.rm_rf File.join(spec.doc_dir, "rdoc")
       end
 
       begin
         doc.generate
       rescue Errno::ENOENT => e
-        e.message =~ / - /
-        alert_error "Unable to document #{spec.full_name}, #{$'} is missing, skipping"
+        match = / - /.match(e.message)
+        alert_error "Unable to document #{spec.full_name}, " \
+                    " #{match.post_match} is missing, skipping"
         terminate_interaction 1 if specs.length == 1
       end
     end
   end
-
 end

data/lib/rubygems/commands/search_command.rb

@@ -1,15 +1,16 @@
 # frozen_string_literal: true
-require 'rubygems/command'
-require 'rubygems/commands/query_command'
+require_relative "../command"
+require_relative "../query_utils"
 
-class Gem::Commands::SearchCommand < Gem::Commands::QueryCommand
+class Gem::Commands::SearchCommand < Gem::Command
+  include Gem::QueryUtils
 
   def initialize
-    super 'search', 'Display remote gems whose name matches REGEXP'
+    super "search", "Display remote gems whose name matches REGEXP",
+         :domain => :remote, :details => false, :versions => true,
+         :installed => nil, :version => Gem::Requirement.default
 
-    remove_option '--name-matches'
-
-    defaults[:domain] = :remote
+    add_query_options
   end
 
   def arguments # :nodoc:
@@ -36,5 +37,4 @@ To list local gems use the list command.
   def usage # :nodoc:
     "#{program_name} [REGEXP]"
   end
-
 end

data/lib/rubygems/commands/server_command.rb

@@ -1,86 +1,25 @@
 # frozen_string_literal: true
-require 'rubygems/command'
-require 'rubygems/server'
-
-class Gem::Commands::ServerCommand < Gem::Command
-
-  def initialize
-    super 'server', 'Documentation and gem repository HTTP server',
-          :port => 8808, :gemdir => [], :daemon => false
-
-    OptionParser.accept :Port do |port|
-      if port =~ /\A\d+\z/
-        port = Integer port
-        raise OptionParser::InvalidArgument, "#{port}: not a port number" if
-          port > 65535
-
-        port
-      else
-        begin
-          Socket.getservbyname port
-        rescue SocketError
-          raise OptionParser::InvalidArgument, "#{port}: no such named service"
-        end
+require_relative "../command"
+
+unless defined? Gem::Commands::ServerCommand
+  class Gem::Commands::ServerCommand < Gem::Command
+    def initialize
+      super("server", "Starts up a web server that hosts the RDoc (requires rubygems-server)")
+      begin
+        Gem::Specification.find_by_name("rubygems-server").activate
+      rescue Gem::LoadError
+        # no-op
       end
     end
 
-    add_option '-p', '--port=PORT', :Port,
-               'port to listen on' do |port, options|
-      options[:port] = port
-    end
-
-    add_option '-d', '--dir=GEMDIR',
-               'directories from which to serve gems',
-               'multiple directories may be provided' do |gemdir, options|
-      options[:gemdir] << File.expand_path(gemdir)
+    def description # :nodoc:
+      <<-EOF
+The server command has been moved to the rubygems-server gem.
+      EOF
     end
 
-    add_option '--[no-]daemon', 'run as a daemon' do |daemon, options|
-      options[:daemon] = daemon
+    def execute
+      alert_error "Install the rubygems-server gem for the server command"
     end
-
-    add_option '-b', '--bind=HOST,HOST',
-               'addresses to bind', Array do |address, options|
-      options[:addresses] ||= []
-      options[:addresses].push(*address)
-    end
-
-    add_option '-l', '--launch[=COMMAND]',
-               'launches a browser window',
-               "COMMAND defaults to 'start' on Windows",
-               "and 'open' on all other platforms" do |launch, options|
-      launch ||= Gem.win_platform? ? 'start' : 'open'
-      options[:launch] = launch
-    end
-  end
-
-  def defaults_str # :nodoc:
-    "--port 8808 --dir #{Gem.dir} --no-daemon"
   end
-
-  def description # :nodoc:
-    <<-EOF
-The server command starts up a web server that hosts the RDoc for your
-installed gems and can operate as a server for installation of gems on other
-machines.
-
-The cache files for installed gems must exist to use the server as a source
-for gem installation.
-
-To install gems from a running server, use `gem install GEMNAME --source
-http://gem_server_host:8808`
-
-You can set up a shortcut to gem server documentation using the URL:
-
-  http://localhost:8808/rdoc?q=%s - Firefox
-  http://localhost:8808/rdoc?q=* - LaunchBar
-
-    EOF
-  end
-
-  def execute
-    options[:gemdir] = Gem.path if options[:gemdir].empty?
-    Gem::Server.run options
-  end
-
 end