rubygems-update 0.8.3

data/lib/rubygems/cmd_manager.rb

@@ -0,0 +1,127 @@
+require 'rubygems'
+require 'rubygems/command'
+require 'rubygems/user_interaction'
+require 'rubygems/gem_commands'
+
+module Gem
+
+  # Signals that local installation will not proceed, not that it has
+  # been tried and failed.  TODO: better name.
+  class LocalInstallationError < Gem::Exception; end
+  
+  class FilePermissionError < Gem::Exception
+    def initialize(path)
+      super("You don't have write permissions into the #{path} directory.")
+    end
+  end
+
+  # Signals that a remote operation cannot be conducted, probably due to not being
+  # connected (or just not finding host).
+  #
+  # TODO: create a method that tests connection to the preferred gems server.  All code
+  # dealing with remote operations will want this.  Failure in that method should raise
+  # this error.
+  class RemoteError < Gem::Exception; end
+
+  class CommandManager
+    include UserInteraction
+
+    def self.instance
+      @cmd_manager ||= CommandManager.new
+    end
+
+    def initialize
+      @commands = {}
+      register_command HelpCommand.new
+      register_command InstallCommand.new
+      register_command UninstallCommand.new
+      register_command CheckCommand.new
+      register_command BuildCommand.new
+      register_command QueryCommand.new
+      register_command ListCommand.new
+      register_command SearchCommand.new
+      register_command UpdateCommand.new
+      register_command RDocCommand.new
+      register_command EnvironmentCommand.new
+      register_command SpecificationCommand.new
+      register_command UnpackCommand.new
+    end
+    
+    def register_command(command)
+      @commands[command.command.intern] = command
+    end
+    
+    def [](command_name)
+      @commands[command_name.intern]
+    end
+    
+    def command_names
+      @commands.keys.collect {|key| key.to_s}.sort
+    end
+    
+    def run(cfg)
+      process_args(cfg.args)
+    rescue StandardError => ex
+      alert_error "While executing gem ... (#{ex.class})\n    #{ex.to_s}"
+      puts ex.backtrace if cfg.backtrace
+      terminate_interaction(1)
+    end
+
+    def process_args(args)
+      args = args.to_str.split(/\s/) if args.respond_to?(:to_str)
+      if args.size == 0
+        say Gem::HELP
+        terminate_interaction(1)
+      end 
+      case args[0]
+      when '-h', '--help'
+        say Gem::HELP
+        terminate_interaction(0)
+      when '-v', '--version'
+        say Gem::RubyGemsPackageVersion
+        terminate_interaction(0)
+      when /^-/
+        alert_error "Invalid option: #{args[0]}.  See 'gem --help'."
+        terminate_interaction(1)
+      else
+        cmd_name = args.shift.downcase
+        cmd = find_command(cmd_name)
+        #load_config_file_options(args)
+        cmd.invoke(*args)
+      end
+    end
+
+    def find_command(cmd_name)
+      possibilities = find_command_possibilities(cmd_name)
+      if possibilities.size > 1
+        raise "Ambiguous command #{cmd_name} matches [#{possibilities.join(', ')}]"
+      end
+      if possibilities.size < 1
+        raise "Unknown command #{cmd_name}"
+      end
+      self[possibilities.first]
+    end
+
+    def find_command_possibilities(cmd_name)
+      len = cmd_name.length
+      self.command_names.select { |n| cmd_name == n[0,len] }
+    end
+
+    #  - a config file may be specified on the command line
+    #  - if it's specified multiple times, the first one wins 
+    #  - there is a default config file location HOME/.gemrc
+    def load_config_file_options(args)
+      config_file = File.join(ENV['HOME'], ".gemrc")
+      if args.index("--config-file")
+        config_file = args[args.index("--config-file")+1]
+      end
+      if File.exist?(config_file)
+        @config_file_options = YAML.load(File.read(config_file))
+      else
+        alert_error "Config file #{config_file} not found" if options[:config_file]
+        terminate_interaction!if options[:config_file]
+      end
+    end
+
+  end
+end 

data/lib/rubygems/command.rb

@@ -0,0 +1,191 @@
+require 'rubygems/user_interaction'
+
+module Gem
+  class Command
+    include UserInteraction
+    
+    Option = Struct.new(:short, :long, :description, :handler)
+    
+    attr_reader :command, :options
+    attr_accessor :summary, :defaults, :program_name
+    
+    def initialize(command, summary=nil, defaults={})
+      @command = command
+      @summary = summary
+      @program_name = "gem #{command}"
+      @defaults = defaults
+      @options = defaults.dup
+      @option_list = []
+      @parser = nil
+    end
+    
+    def show_help
+      parser.program_name = usage
+      say parser
+    end
+
+    def usage
+      "#{program_name}"
+    end
+
+    # Override this method to provide details of the arguments a command takes.  It should
+    # return a left-justified string, one argument per line.
+    def arguments
+      ""
+    end
+
+    # This is just like the 'arguments' method, except it describes the default options used.
+    def defaults_str
+      ""
+    end
+
+    def invoke(*args)
+      handle_options(args)
+      if options[:help]
+        show_help
+      elsif @when_invoked
+        @when_invoked.call(options)
+      else
+        execute
+      end
+    end
+    
+    def when_invoked(&block)
+      @when_invoked = block
+    end
+    
+    def add_option(*args, &handler)
+      @option_list << [args, handler]
+    end
+
+    def remove_option(name)
+      @option_list.reject! { |args, handler| args.any? { |x| x =~ /^#{name}/ } }
+    end
+    
+    def merge_options(new_options)
+      @options = @defaults.clone
+      new_options.each do |k,v| @options[k] = v end
+    end
+
+    def handles?(args)
+      begin
+        parser.parse!(args.dup)
+        return true
+      rescue
+        return false
+      end
+    end
+
+    private
+
+    def handle_options(args)
+      args = add_extra_args(args)
+      @options = @defaults.clone
+      parser.parse!(args)
+      @options[:args] = args
+    end
+    
+    def add_extra_args(args)
+      result = []
+      extra = Command.extra_args.dup
+      while ! extra.empty?
+        ex = []
+        ex << extra.shift
+        ex << extra.shift if extra.first.to_s =~ /^[^-]/
+        result << ex if handles?(ex)
+      end
+      result.flatten!
+      result.concat(args)
+      result
+    end
+    
+    # Create on demand parser.
+    def parser
+      create_option_parser if @parser.nil?
+      @parser
+    end
+
+    def create_option_parser
+      require 'optparse'
+      @parser = OptionParser.new
+      option_names = {}
+      @parser.separator("")
+      unless @option_list.empty?
+        @parser.separator("  Options:")
+        configure_options(@option_list, option_names)
+        @parser.separator("")
+      end
+      @parser.separator("  Common Options:")
+      configure_options(Command.common_options, option_names)
+      @parser.separator("")
+      unless arguments.empty?
+        @parser.separator("  Arguments:")
+        arguments.split(/\n/).each do |arg_desc|
+          @parser.separator("    #{arg_desc}")
+        end
+        @parser.separator("")
+      end
+      @parser.separator("  Summary:")
+      @parser.separator("    #@summary")
+      unless defaults_str.empty?
+        @parser.separator("")
+        @parser.separator("  Defaults:")
+        defaults_str.split(/\n/).each do |line|
+          @parser.separator("    #{line}")
+        end
+      end
+    end
+
+    def configure_options(option_list, option_names)
+      option_list.each do |args, handler|
+        dashes = args.select { |arg| arg =~ /^-/ }
+        next if dashes.any? { |arg| option_names[arg] }
+        @parser.on(*args) do |value|
+          handler.call(value, @options)
+        end
+        dashes.each do |arg| option_names[arg] = true end
+      end
+    end
+
+    class << self
+      def common_options
+        @common_options ||= []
+      end
+    
+      def add_common_option(*args, &handler)
+        Gem::Command.common_options << [args, handler]
+      end
+
+      def extra_args
+        @extra_args ||= []
+      end
+
+      def extra_args=(value)
+        case value
+        when Array
+          @extra_args = value
+        when String
+          @extra_args = value.split
+        end
+      end
+    end
+
+    add_common_option('--source URL', 'Use URL as the remote source for gems') do |value, options|
+      require_gem("sources")
+      Gem.sources.clear
+      Gem.sources << value
+    end
+    add_common_option('-p', '--[no-]http-proxy [URL]', 'Use HTTP proxy for remote operations') do |value, options|
+      options[:http_proxy] = (value == false) ? :no_proxy : value
+    end
+    add_common_option('-h', '--help', 'Get help on this command') do |value, options|
+      options[:help] = true
+    end
+    # Backtrace and config-file are added so they show up in the help
+    # commands.  Both options are actually handled before the other
+    # options get parsed.
+    add_common_option('--config-file FILE', "Use this config file instead of default") do end
+    add_common_option('--backtrace', 'Show stack backtrace on errors') do end
+    add_common_option('--debug', 'Turn on Ruby debugging') do end
+  end # class
+end # module

data/lib/rubygems/config_file.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+
+require 'yaml'
+
+module Gem
+  class ConfigFile
+    attr_reader :backtrace, :args
+
+    def initialize(arg_list)
+      handle_arguments(arg_list)
+      if File.exist?(config_file_name)
+	@hash = open(config_file_name) { |f| YAML.load(f) }
+      else
+	@hash = {}
+      end
+    end
+
+    def config_file_name
+      @config_file_name || default_config_file_name
+    end
+
+    def [](key)
+      @hash[key.to_s]
+    end
+
+    private
+
+    def handle_arguments(arg_list)
+      need_cfg_name = false
+      @args = []
+      arg_list.each do |arg|
+	if need_cfg_name
+	  @config_file_name = arg
+	  need_cfg_name = false
+	else
+	  case arg
+	  when /^--backtrace$/
+	    @backtrace = true
+          when /^--debug$/
+            $DEBUG = true
+	  when /^--config-file$/
+	    need_cfg_name = true
+	  when /^--config-file=(.+)$/
+	    @config_file_name = $1
+	  else
+	    @args << arg
+	  end
+	end
+      end
+    end
+
+    def default_config_file_name
+      File.join(ENV['HOME'], '.gemrc')
+    end
+  end
+
+end

data/lib/rubygems/doc_manager.rb

@@ -0,0 +1,94 @@
+module Gem
+
+  class DocumentError < Gem::Exception; end
+  
+  class DocManager
+  
+    include UserInteraction
+  
+    #
+    # spec::      The Gem::Specification object representing the gem.
+    # rdoc_args:: Optional arguments for RDoc (template etc.) as a String.
+    #
+    def initialize(spec, rdoc_args="")
+      @spec = spec
+      @doc_dir = File.join(spec.installation_path, "doc", spec.full_name)
+      Gem::FilePermissionError.new(spec.installation_path) unless File.writable?(spec.installation_path)
+      @rdoc_args = rdoc_args.nil? ? [] : rdoc_args.split
+    end
+    
+    def rdoc_installed?
+      return File.exist?(File.join(@doc_dir, "rdoc"))
+    end
+    
+    def install_doc(rdoc = true)
+      self.generate_rdoc if rdoc
+      require 'fileutils'
+      FileUtils.mkdir_p @doc_dir unless File.exist?(@doc_dir)
+    end
+
+    ##
+    # Return Rdoc args as specified in gem spec.  If args exist in gemspec,
+    # append any user-defined args.  This behavior is open for a vote. 
+    def rdoc_args_from_spec(non_spec_args)
+      @spec.rdoc_options << non_spec_args 
+    end
+    
+    def generate_rdoc
+      require 'fileutils'
+      Gem::FilePermissionError.new(@doc_dir) if File.exist?(@doc_dir) && !File.writable?(@doc_dir)
+      FileUtils.mkdir_p @doc_dir unless File.exist?(@doc_dir)
+      begin
+        require 'rdoc/rdoc'
+      rescue LoadError => e
+        raise DocumentError, "ERROR: RDoc documentation generator not installed!"
+      end
+      say "Installing RDoc documentation for #{@spec.full_name}..."
+      say "WARNING: Generating RDoc on .gem that may not have RDoc." unless @spec.has_rdoc?
+      rdoc_dir = File.join(@doc_dir, "rdoc")
+      begin
+        source_dirs = @spec.require_paths.clone.concat(@spec.extra_rdoc_files)
+        current_dir = Dir.pwd
+        Dir.chdir(@spec.full_gem_path)
+        begin
+          @rdoc_args = rdoc_args_from_spec(@rdoc_args)
+          @rdoc_args.concat(DocManager.configured_args)
+          r = RDoc::RDoc.new
+          begin
+            r.document(['--quiet', '--op', rdoc_dir] + @rdoc_args.flatten + source_dirs)
+          rescue Errno::EACCES => e
+            raise Gem::FilePermissionError.new(File.dirname(e.message.split("-")[1].strip))
+          end
+	 #TODO: Why is this throwing an error?
+          #ri = RDoc::RDoc.new
+          #ri.document(['-R'] + source_dirs)
+        ensure
+          Dir.chdir(current_dir)
+        end
+      rescue RDoc::RDocError => e
+        raise DocumentError, e.message
+      end
+    end
+    
+    def uninstall_doc
+      doc_dir = File.join(@spec.installation_path, "doc", @spec.full_name)
+      FileUtils.rm_rf doc_dir
+    end
+
+    class << self
+      def configured_args
+        @configured_args ||= []
+      end
+
+      def configured_args=(args)
+        case args
+        when Array
+          @configured_args = args
+        when String
+          @configured_args = args.split
+        end
+      end
+    end
+    
+  end
+end