rubygems-update 1.8.30 → 2.0.0.preview2

data/lib/rubygems/available_set.rb

@@ -0,0 +1,95 @@
+module Gem
+  class AvailableSet
+    Tuple = Struct.new(:spec, :source)
+
+    def initialize
+      @set = []
+      @sorted = nil
+    end
+
+    attr_reader :set
+
+    def add(spec, source)
+      @set << Tuple.new(spec, source)
+      @sorted = nil
+      self
+    end
+
+    def <<(o)
+      case o
+      when AvailableSet
+        s = o.set
+      when Array
+        s = o.map do |sp,so|
+          if !sp.kind_of?(Specification) or !so.kind_of?(Source)
+            raise TypeError, "Array must be in [[spec, source], ...] form"
+          end
+
+          Tuple.new(sp,so)
+        end
+      else
+        raise TypeError, "Must be an AvailableSet"
+      end
+
+      @set += s
+      @sorted = nil
+
+      self
+    end
+
+    def empty?
+      @set.empty?
+    end
+
+    def all_specs
+      @set.map { |t| t.spec }
+    end
+
+    def match_platform!
+      @set.reject! { |t| !Gem::Platform.match(t.spec.platform) }
+      @sorted = nil
+      self
+    end
+
+    def sorted
+      @sorted ||= @set.sort do |a,b|
+        i = b.spec <=> a.spec
+        i != 0 ? i : (a.source <=> b.source)
+      end
+    end
+
+    def size
+      @set.size
+    end
+
+    def source_for(spec)
+      f = @set.find { |t| t.spec == spec }
+      f.source
+    end
+
+    def pick_best!
+      return self if empty?
+
+      @set = [sorted.first]
+      @sorted = nil
+      self
+    end
+
+    def remove_installed!(dep)
+      @set.reject! do |t|
+        # already locally installed
+        Gem::Specification.any? do |installed_spec|
+          dep.name == installed_spec.name and
+            dep.requirement.satisfied_by? installed_spec.version
+        end
+      end
+
+      @sorted = nil
+      self
+    end
+
+    def inject_into_list(dep_list)
+      @set.each { |t| dep_list.add t.spec }
+    end
+  end
+end

data/lib/rubygems/command.rb

@@ -5,11 +5,12 @@
 #++
 
 require 'optparse'
+require 'rubygems/requirement'
 require 'rubygems/user_interaction'
 
 ##
 # Base class for all Gem commands.  When creating a new gem command, define
-# #new, #execute, #arguments, #defaults_str, #description and #usage
+# #initialize, #execute, #arguments, #defaults_str, #description and #usage
 # (as appropriate).  See the above mentioned methods for details.
 #
 # A very good example to look at is Gem::Commands::ContentsCommand
@@ -150,8 +151,9 @@ class Gem::Command
 
   def show_lookup_failure(gem_name, version, errors, domain)
     if errors and !errors.empty?
-      alert_error "Could not find a valid gem '#{gem_name}' (#{version}), here is why:"
-      errors.each { |x| say "          #{x.wordy}" }
+      msg = "Could not find a valid gem '#{gem_name}' (#{version}), here is why:\n"
+      errors.each { |x| msg << "          #{x.wordy}\n" }
+      alert_error msg
     else
       alert_error "Could not find a valid gem '#{gem_name}' (#{version}) in any repository"
     end
@@ -179,6 +181,21 @@ class Gem::Command
     args.select { |arg| arg !~ /^-/ }
   end
 
+  ##
+  # Get all [gem, version] from the command line.
+  #
+  # An argument in the form gem:ver is pull apart into the gen name and version,
+  # respectively.
+  def get_all_gem_names_and_versions
+    get_all_gem_names.map do |name|
+      if /\A(.*):(#{Gem::Requirement::PATTERN_RAW})\z/ =~ name
+        [$1, $2]
+      else
+        [name]
+      end
+    end
+  end
+
   ##
   # Get a single gem name from the command line.  Fail if there is no gem name
   # or if there is more than one gem name given.
@@ -268,8 +285,18 @@ class Gem::Command
   # Invoke the command with the given list of arguments.
 
   def invoke(*args)
+    invoke_with_build_args args, nil
+  end
+
+  ##
+  # Invoke the command with the given list of normal arguments
+  # and additional build arguments.
+
+  def invoke_with_build_args(args, build_args)
     handle_options args
 
+    options[:build_args] = build_args
+
     if options[:help] then
       show_help
     elsif @when_invoked then
@@ -344,7 +371,7 @@ class Gem::Command
 
   def handle_options(args)
     args = add_extra_args(args)
-    @options = @defaults.clone
+    @options = Marshal.load Marshal.dump @defaults # deep copy
     parser.parse!(args)
     @options[:args] = args
   end
@@ -372,18 +399,23 @@ class Gem::Command
 
   private
 
-  ##
-  # Create on demand parser.
+  def add_parser_description # :nodoc:
+    return unless description
 
-  def parser
-    create_option_parser if @parser.nil?
-    @parser
-  end
+    formatted = description.split("\n\n").map do |chunk|
+      wrap chunk, 80 - 4
+    end.join "\n"
 
-  def create_option_parser
-    @parser = OptionParser.new
+    @parser.separator nil
+    @parser.separator "  Description:"
+    formatted.split("\n").each do |line|
+      @parser.separator "    #{line.rstrip}"
+    end
+  end
 
+  def add_parser_options # :nodoc:
     @parser.separator nil
+
     regular_options = @option_groups.delete :options
 
     configure_options "", regular_options
@@ -392,45 +424,56 @@ class Gem::Command
       @parser.separator nil
       configure_options group_name, option_list
     end
+  end
 
-    @parser.separator nil
-    configure_options "Common", Gem::Command.common_options
+  ##
+  # Adds a section with +title+ and +content+ to the parser help view.  Used
+  # for adding command arguments and default arguments.
 
-    unless arguments.empty?
-      @parser.separator nil
-      @parser.separator "  Arguments:"
-      arguments.split(/\n/).each do |arg_desc|
-        @parser.separator "    #{arg_desc}"
-      end
-    end
+  def add_parser_run_info title, content
+    return if content.empty?
 
-    if @summary then
-      @parser.separator nil
-      @parser.separator "  Summary:"
-      wrap(@summary, 80 - 4).split("\n").each do |line|
-        @parser.separator "    #{line.strip}"
-      end
+    @parser.separator nil
+    @parser.separator "  #{title}:"
+    content.split(/\n/).each do |line|
+      @parser.separator "    #{line}"
     end
+  end
 
-    if description then
-      formatted = description.split("\n\n").map do |chunk|
-        wrap chunk, 80 - 4
-      end.join "\n"
+  def add_parser_summary # :nodoc:
+    return unless @summary
 
-      @parser.separator nil
-      @parser.separator "  Description:"
-      formatted.split("\n").each do |line|
-        @parser.separator "    #{line.rstrip}"
-      end
+    @parser.separator nil
+    @parser.separator "  Summary:"
+    wrap(@summary, 80 - 4).split("\n").each do |line|
+      @parser.separator "    #{line.strip}"
     end
+  end
 
-    unless defaults_str.empty?
-      @parser.separator nil
-      @parser.separator "  Defaults:"
-      defaults_str.split(/\n/).each do |line|
-        @parser.separator "    #{line}"
-      end
-    end
+  ##
+  # Create on demand parser.
+
+  def parser
+    create_option_parser if @parser.nil?
+    @parser
+  end
+
+  ##
+  # Creates an option parser and fills it in with the help info for the
+  # command.
+
+  def create_option_parser
+    @parser = OptionParser.new
+
+    add_parser_options
+
+    @parser.separator nil
+    configure_options "Common", Gem::Command.common_options
+
+    add_parser_run_info "Arguments", arguments
+    add_parser_summary
+    add_parser_description
+    add_parser_run_info "Defaults", defaults_str
   end
 
   def configure_options(header, option_list)
@@ -521,7 +564,7 @@ basic help message containing pointers to more information.
                                  http://localhost:8808/
                                  with info about installed gems
   Further information:
-    http://rubygems.rubyforge.org
+    http://guides.rubygems.org
   HELP
 
   # :startdoc:
@@ -529,7 +572,7 @@ basic help message containing pointers to more information.
 end
 
 ##
-# This is where Commands will be placed in the namespace
+# \Commands will be placed in this namespace
 
 module Gem::Commands
 end

data/lib/rubygems/command_manager.rb

@@ -18,12 +18,15 @@ require 'rubygems/user_interaction'
 #   # file rubygems_plugin.rb
 #   require 'rubygems/command_manager'
 #
+#   Gem::CommandManager.instance.register_command :edit
+#
+# You should put the implementation of your command in rubygems/commands.
+#
+#   # file rubygems/commands/edit_command.rb
 #   class Gem::Commands::EditCommand < Gem::Command
 #     # ...
 #   end
 #
-#   Gem::CommandManager.instance.register_command :edit
-#
 # See Gem::Command for instructions on writing gem commands.
 
 class Gem::CommandManager
@@ -37,6 +40,14 @@ class Gem::CommandManager
     @command_manager ||= new
   end
 
+  ##
+  # Returns self. Allows a CommandManager instance to stand
+  # in for the class itself.
+
+  def instance
+    self
+  end
+
   ##
   # Reset the authoritative instance of the command manager.
 
@@ -63,6 +74,7 @@ class Gem::CommandManager
     register_command :install
     register_command :list
     register_command :lock
+    register_command :mirror
     register_command :outdated
     register_command :owner
     register_command :pristine
@@ -78,13 +90,14 @@ class Gem::CommandManager
     register_command :unpack
     register_command :update
     register_command :which
+    register_command :yank
   end
 
   ##
   # Register the Symbol +command+ as a gem command.
 
-  def register_command(command)
-    @commands[command] = false
+  def register_command(command, obj=false)
+    @commands[command] = obj
   end
 
   ##
@@ -95,7 +108,7 @@ class Gem::CommandManager
   end
 
   ##
-  # Return the registered command from the command name.
+  # Returns a Command instance for +command_name+
 
   def [](command_name)
     command_name = command_name.intern
@@ -104,56 +117,69 @@ class Gem::CommandManager
   end
 
   ##
-  # Return a sorted list of all command names (as strings).
+  # Return a sorted list of all command names as strings.
 
   def command_names
     @commands.keys.collect {|key| key.to_s}.sort
   end
 
   ##
-  # Run the config specified by +args+.
+  # Run the command specified by +args+.
 
-  def run(args)
-    process_args(args)
+  def run(args, build_args=nil)
+    process_args(args, build_args)
   rescue StandardError, Timeout::Error => ex
     alert_error "While executing gem ... (#{ex.class})\n    #{ex.to_s}"
-    ui.errs.puts "\t#{ex.backtrace.join "\n\t"}" if
-      Gem.configuration.backtrace
+    ui.backtrace ex
+
+    if Gem.configuration.really_verbose and \
+         ex.kind_of?(Gem::Exception) and ex.source_exception
+      e = ex.source_exception
+
+      ui.errs.puts "Because of: (#{e.class})\n    #{e.to_s}"
+      ui.backtrace e
+    end
+
     terminate_interaction(1)
   rescue Interrupt
     alert_error "Interrupted"
     terminate_interaction(1)
   end
 
-  def process_args(args)
+  def process_args(args, build_args=nil)
     args = args.to_str.split(/\s+/) if args.respond_to?(:to_str)
-    if args.size == 0
+
+    if args.empty? then
       say Gem::Command::HELP
-      terminate_interaction(1)
+      terminate_interaction 1
     end
-    case args[0]
-    when '-h', '--help'
+
+    case args.first
+    when '-h', '--help' then
       say Gem::Command::HELP
-      terminate_interaction(0)
-    when '-v', '--version'
+      terminate_interaction 0
+    when '-v', '--version' then
       say Gem::VERSION
-      terminate_interaction(0)
-    when /^-/
-      alert_error "Invalid option: #{args[0]}.  See 'gem --help'."
-      terminate_interaction(1)
+      terminate_interaction 0
+    when /^-/ then
+      alert_error "Invalid option: #{args.first}.  See 'gem --help'."
+      terminate_interaction 1
     else
       cmd_name = args.shift.downcase
-      cmd = find_command(cmd_name)
-      cmd.invoke(*args)
+      cmd = find_command cmd_name
+      cmd.invoke_with_build_args args, build_args
     end
   end
 
   def find_command(cmd_name)
     possibilities = find_command_possibilities cmd_name
+
     if possibilities.size > 1 then
-      raise "Ambiguous command #{cmd_name} matches [#{possibilities.join(', ')}]"
-    elsif possibilities.size < 1 then
-      raise "Unknown command #{cmd_name}"
+      raise Gem::CommandLineError,
+            "Ambiguous command #{cmd_name} " \
+            "matches [#{possibilities.join(', ')}]"
+    elsif possibilities.empty? then
+      raise Gem::CommandLineError, "Unknown command #{cmd_name}"
     end
 
     self[possibilities.first]
@@ -162,7 +188,11 @@ class Gem::CommandManager
   def find_command_possibilities(cmd_name)
     len = cmd_name.length
 
-    command_names.select { |n| cmd_name == n[0, len] }
+    found = command_names.select { |name| cmd_name == name[0, len] }
+
+    exact = found.find { |name| name == cmd_name }
+
+    exact ? [exact] : found
   end
 
   private
@@ -170,23 +200,20 @@ class Gem::CommandManager
   def load_and_instantiate(command_name)
     command_name = command_name.to_s
     const_name = command_name.capitalize.gsub(/_(.)/) { $1.upcase } << "Command"
-    commands = Gem::Commands
-    retried = false
+    load_error = nil
 
     begin
-      commands.const_get(const_name).new
-    rescue NameError
-      raise if retried
-
-      retried = true
       begin
         require "rubygems/commands/#{command_name}_command"
-      rescue Exception => e
-        alert_error "Loading command: #{command_name} (#{e.class})\n    #{e}"
-        ui.errs.puts "\t#{e.backtrace.join "\n\t"}" if
-          Gem.configuration.backtrace
+      rescue LoadError => e
+        load_error = e
       end
-      retry
+      Gem::Commands.const_get(const_name).new
+    rescue Exception => e
+      e = load_error if load_error
+
+      alert_error "Loading command: #{command_name} (#{e.class})\n\t#{e}"
+      ui.backtrace e
     end
   end