rubygems-update 0.9.4 → 0.9.5

data/lib/rubygems/commands/fetch_command.rb

@@ -0,0 +1,62 @@
+require 'rubygems/command'
+require 'rubygems/local_remote_options'
+require 'rubygems/version_option'
+require 'rubygems/source_info_cache'
+
+class Gem::Commands::FetchCommand < Gem::Command
+
+  include Gem::LocalRemoteOptions
+  include Gem::VersionOption
+
+  def initialize
+    super 'fetch', 'Download a gem and place it in the current directory'
+
+    add_bulk_threshold_option
+    add_proxy_option
+    add_source_option
+
+    add_version_option
+    add_platform_option
+  end
+
+  def arguments # :nodoc:
+    'GEMNAME       name of gem to download'
+  end
+
+  def defaults_str # :nodoc:
+    "--version '#{Gem::Requirement.default}'"
+  end
+
+  def usage # :nodoc:
+    "#{program_name} GEMNAME [GEMNAME ...]"
+  end
+
+  def execute
+    version = options[:version] || Gem::Requirement.default
+
+    gem_names = get_all_gem_names
+
+    gem_names.each do |gem_name|
+      dep = Gem::Dependency.new gem_name, version
+      specs_and_sources = Gem::SourceInfoCache.search_with_source dep, true
+
+      specs_and_sources.sort_by { |spec,| spec.version }
+
+      spec, source_uri = specs_and_sources.last
+
+      gem_file = "#{spec.full_name}.gem"
+
+      gem_path = File.join source_uri, 'gems', gem_file
+
+      gem = Gem::RemoteFetcher.fetcher.fetch_path gem_path
+
+      File.open gem_file, 'wb' do |fp|
+        fp.write gem
+      end
+
+      say "Downloaded #{gem_file}"
+    end
+  end
+
+end
+

data/lib/rubygems/commands/generate_index_command.rb

@@ -0,0 +1,57 @@
+require 'rubygems/command'
+require 'rubygems/indexer'
+
+class Gem::Commands::GenerateIndexCommand < Gem::Command
+
+  def initialize
+    super 'generate_index',
+          'Generates the index files for a gem server directory',
+          :directory => '.'
+
+    add_option '-d', '--directory=DIRNAME',
+               'repository base dir containing gems subdir' do |dir, options|
+      options[:directory] = File.expand_path dir
+    end
+  end
+
+  def defaults_str # :nodoc:
+    "--directory ."
+  end
+
+  def description # :nodoc:
+    <<-EOF
+The generate_index command creates a set of indexes for serving gems
+statically.  The command expects a 'gems' directory under the path given to
+the --directory option.  When done, it will generate a set of files like this:
+
+  gems/                                        # .gem files you want to index
+  quick/index
+  quick/index.rz                               # quick index manifest
+  quick/<gemname>.gemspec.rz                   # legacy YAML quick index file
+  quick/Marshal.<version>/<gemname>.gemspec.rz # Marshal quick index file
+  Marshal.<version>
+  Marshal.<version>.Z # Marshal full index
+  yaml
+  yaml.Z # legacy YAML full index
+
+The .Z and .rz extension files are compressed with the inflate algorithm.  The
+Marshal version number comes from ruby's Marshal::MAJOR_VERSION and
+Marshal::MINOR_VERSION constants.  It is used to ensure compatibility.  The
+yaml indexes exist for legacy RubyGems clients and fallback in case of Marshal
+version changes.
+    EOF
+  end
+
+  def execute
+    if not File.exist?(options[:directory]) or
+       not File.directory?(options[:directory]) then
+      alert_error "unknown directory name #{directory}."
+      terminate_interaction 1
+    else
+      indexer = Gem::Indexer.new options[:directory]
+      indexer.generate_index
+    end
+  end
+
+end
+

data/lib/rubygems/commands/help_command.rb

@@ -1,82 +1,172 @@
-module Gem
-  module Commands
-    class HelpCommand < Command
-      include CommandAids
+require 'rubygems/command'
 
-      def initialize
-        super('help', "Provide help on the 'gem' command")
-      end
+class Gem::Commands::HelpCommand < Gem::Command
+
+  # :stopdoc:
+  EXAMPLES = <<-EOF
+Some examples of 'gem' usage.
+
+* Install 'rake', either from local directory or remote server:
+
+    gem install rake
+
+* Install 'rake', only from remote server:
+
+    gem install rake --remote
+
+* Install 'rake' from remote server, and run unit tests,
+  and generate RDocs:
+
+    gem install --remote rake --test --rdoc --ri
+
+* Install 'rake', but only version 0.3.1, even if dependencies
+  are not met, and into a specific directory:
+
+    gem install rake --version 0.3.1 --force --install-dir $HOME/.gems
+
+* List local gems whose name begins with 'D':
+
+    gem list D
+
+* List local and remote gems whose name contains 'log':
+
+    gem search log --both
+
+* List only remote gems whose name contains 'log':
+
+    gem search log --remote
+
+* Uninstall 'rake':
+
+    gem uninstall rake
+
+* Create a gem:
+
+    See http://rubygems.rubyforge.org/wiki/wiki.pl?CreateAGemInTenMinutes
+
+* See information about RubyGems:
+
+    gem environment
+
+* Update all gems on your system:
+
+    gem update
+  EOF
+
+  PLATFORMS = <<-'EOF'
+RubyGems platforms are composed of three parts, a CPU, an OS, and a
+version.  These values are taken from values in rbconfig.rb.  You can view
+your current platform by running `gem environment`.
+
+RubyGems matches platforms as follows:
 
-      def usage
-        "#{program_name} ARGUMENT"
+  * The CPU must match exactly, unless one of the platforms has
+    "universal" as the CPU.
+  * The OS must match exactly.
+  * The versions must match exactly unless one of the versions is nil.
+
+For commands that install, uninstall and list gems, you can override what
+RubyGems thinks your platform is with the --platform option.  The platform
+you pass must match "#{cpu}-#{os}" or "#{cpu}-#{os}-#{version}".  On mswin
+platforms, the version is the compiler version, not the OS version.  (Ruby
+compiled with VC6 uses "60" as the compiler version, VC8 uses "80".)
+
+Example platforms:
+
+  x86-freebsd        # Any FreeBSD version on an x86 CPU
+  universal-darwin-8 # Darwin 8 only gems that run on any CPU
+  x86-mswin32-80     # Windows gems compiled with VC8
+
+When building platform gems, set the platform in the gem specification to
+Gem::Platform::CURRENT.  This will correctly mark the gem with your ruby's
+platform.
+  EOF
+  # :startdoc:
+
+  def initialize
+    super 'help', "Provide help on the 'gem' command"
+  end
+
+  def arguments # :nodoc:
+    args = <<-EOF
+      commands      List all 'gem' commands
+      examples      Show examples of 'gem' usage
+      <command>     Show specific help for <command>
+    EOF
+    return args.gsub(/^\s+/, '')
+  end
+
+  def usage # :nodoc:
+    "#{program_name} ARGUMENT"
+  end
+
+  def execute
+    command_manager = Gem::CommandManager.instance
+    arg = options[:args][0]
+
+    if begins? "commands", arg then
+      out = []
+      out << "GEM commands are:"
+      out << nil
+
+      margin_width = 4
+
+      desc_width = command_manager.command_names.map { |n| n.size }.max + 4
+
+      summary_width = 80 - margin_width - desc_width
+      wrap_indent = ' ' * (margin_width + desc_width)
+      format = "#{' ' * margin_width}%-#{desc_width}s%s"
+
+      command_manager.command_names.each do |cmd_name|
+        summary = command_manager[cmd_name].summary
+        summary = wrap(summary, summary_width).split "\n"
+        out << sprintf(format, cmd_name, summary.shift)
+        until summary.empty? do
+          out << "#{wrap_indent}#{summary.shift}"
+        end
       end
 
-      def arguments
-        args = <<-EOF
-          commands      List all 'gem' commands
-          examples      Show examples of 'gem' usage
-          <command>     Show specific help for <command>
-        EOF
-        return args.gsub(/^\s+/, '')
+      out << nil
+      out << "For help on a particular command, use 'gem help COMMAND'."
+      out << nil
+      out << "Commands may be abbreviated, so long as they are unambiguous."
+      out << "e.g. 'gem i rake' is short for 'gem install rake'."
+
+      say out.join("\n")
+
+    elsif begins? "options", arg then
+      say Gem::Command::HELP
+
+    elsif begins? "examples", arg then
+      say EXAMPLES
+
+    elsif begins? "platforms", arg then
+      say PLATFORMS
+
+    elsif options[:help] then
+      command = command_manager[options[:help]]
+      if command
+        # help with provided command
+        command.invoke("--help")
+      else
+        alert_error "Unknown command #{options[:help]}.  Try 'gem help commands'"
       end
 
-      def execute
-        arg = options[:args][0]
-        if begins?("commands", arg)
-          out = []
-          out << "GEM commands are:"
-          out << nil
-
-          margin_width = 4
-          desc_width = command_manager.command_names.collect {|n| n.size}.max + 4
-          summary_width = 80 - margin_width - desc_width
-          wrap_indent = ' ' * (margin_width + desc_width)
-          format = "#{' ' * margin_width}%-#{desc_width}s%s"
-
-          command_manager.command_names.each do |cmd_name|
-            summary = command_manager[cmd_name].summary
-            summary = wrap(summary, summary_width).split "\n"
-            out << sprintf(format, cmd_name, summary.shift)
-            until summary.empty? do
-              out << "#{wrap_indent}#{summary.shift}"
-            end
-          end
-
-          out << nil
-          out << "For help on a particular command, use 'gem help COMMAND'."
-          out << nil
-          out << "Commands may be abbreviated, so long as they are unambiguous."
-          out << "e.g. 'gem i rake' is short for 'gem install rake'."
-
-          say out.join("\n")
-
-        elsif begins?("options", arg)
-          say Gem::HELP
-        elsif begins?("examples", arg)
-          say Gem::EXAMPLES
-        elsif options[:help]
-          command = command_manager[options[:help]]
-          if command
-            # help with provided command
-            command.invoke("--help")
-          else
-            alert_error "Unknown command #{options[:help]}.  Try 'gem help commands'"
-          end
-        elsif arg
-          possibilities = command_manager.find_command_possibilities(arg.downcase)
-          if possibilities.size == 1
-            command = command_manager[possibilities.first]
-            command.invoke("--help")
-          elsif possibilities.size > 1
-            alert_warning "Ambiguous command #{arg} (#{possibilities.join(', ')})"
-          else
-            alert_warning "Unknown command #{arg}. Try gem help commands"
-          end
-        else
-          say Gem::HELP
-        end
+    elsif arg then
+      possibilities = command_manager.find_command_possibilities(arg.downcase)
+      if possibilities.size == 1
+        command = command_manager[possibilities.first]
+        command.invoke("--help")
+      elsif possibilities.size > 1
+        alert_warning "Ambiguous command #{arg} (#{possibilities.join(', ')})"
+      else
+        alert_warning "Unknown command #{arg}. Try gem help commands"
       end
+
+    else
+      say Gem::Command::HELP
     end
-    
   end
-end
+
+end
+

data/lib/rubygems/commands/install_command.rb

@@ -1,139 +1,125 @@
-module Gem
-  module Commands
-    class InstallCommand < Command
-      include CommandAids
-      include VersionOption
-      include LocalRemoteOptions
-      include InstallUpdateOptions
-
-      def initialize
-        super(
-          'install',
-          'Install a gem into the local repository',
-          {
-            :domain => :both, 
-            :generate_rdoc => true,
-            :generate_ri   => true,
-            :force => false, 
-            :test => false, 
-            :wrappers => true,
-            :version => "> 0",
-            :install_dir => Gem.dir,
-            :security_policy => nil,
-          })
-        add_version_option('install')
-        add_local_remote_options
-        add_install_update_options
-      end
-    
-      def usage
-        "#{program_name} GEMNAME [options]
-     or: #{program_name} GEMNAME [options] -- --build-flags"
-      end
+require 'rubygems/command'
+require 'rubygems/doc_manager'
+require 'rubygems/install_update_options'
+require 'rubygems/dependency_installer'
+require 'rubygems/local_remote_options'
+require 'rubygems/validator'
+require 'rubygems/version_option'
 
-      def arguments
-        "GEMNAME   name of gem to install"
-      end
+class Gem::Commands::InstallCommand < Gem::Command
 
-      def defaults_str
-        "--both --version '> 0' --rdoc --ri --no-force --no-test\n" +
-        "--install-dir #{Gem.dir}"
-      end
+  include Gem::VersionOption
+  include Gem::LocalRemoteOptions
+  include Gem::InstallUpdateOptions
+
+  def initialize
+    defaults = Gem::DependencyInstaller::DEFAULT_OPTIONS.merge({
+      :generate_rdoc => true,
+      :generate_ri   => true,
+      :install_dir => Gem.dir,
+      :test => false,
+      :version => Gem::Requirement.default,
+    })
+
+    super 'install', 'Install a gem into the local repository', defaults
+
+    add_install_update_options
+    add_local_remote_options
+    add_platform_option
+    add_version_option
+  end
+
+  def arguments # :nodoc:
+    "GEMNAME       name of gem to install"
+  end
+
+  def defaults_str # :nodoc:
+    "--both --version '#{Gem::Requirement.default}' --rdoc --ri --no-force\n" \
+    "--no-test --install-dir #{Gem.dir}"
+  end
+
+  def usage # :nodoc:
+    "#{program_name} GEMNAME [GEMNAME ...] [options] -- --build-flags"
+  end
+
+  def execute
+    if options[:include_dependencies] then
+      alert "`gem install -y` is now default and will be removed"
+      alert "use --ignore-dependencies to install only the gems you list"
+    end
+
+    installed_gems = []
+
+    ENV['GEM_PATH'] = options[:install_dir] # HACK what does this do?
+
+    install_options = {
+      :env_shebang => options[:env_shebang],
+      :domain => options[:domain],
+      :force => options[:force],
+      :ignore_dependencies => options[:ignore_dependencies],
+      :install_dir => options[:install_dir],
+      :security_policy => options[:security_policy],
+      :wrappers => options[:wrappers],
+    }
 
-      def execute
-        ENV['GEM_PATH'] = options[:install_dir]
-        if(options[:args].empty?)
-          fail Gem::CommandLineError,
-            "Please specify a gem name on the command line (e.g. gem build GEMNAME)"
+    get_all_gem_names.each do |gem_name|
+      begin
+        inst = Gem::DependencyInstaller.new gem_name, options[:version],
+                                            install_options
+        inst.install
+
+        inst.installed_gems.each do |spec|
+          say "Successfully installed #{spec.full_name}"
         end
-        options[:args].each do |gem_name|
-          if local?
-            begin
-              entries = []
-                if(File.exist?(gem_name) && !File.directory?(gem_name))
-                  entries << gem_name
-                else
-                  filepattern = gem_name + "*.gem"
-                  entries = Dir[filepattern] 
-                end
-                unless entries.size > 0
-                  if options[:domain] == :local
-                    alert_error "Local gem file not found: #{filepattern}"
-                  end
-                else
-                  result = Gem::Installer.new(entries.last, options).install(options[:force],     options[:install_dir])
-                  installed_gems = [result].flatten
-                  say "Successfully installed #{installed_gems[0].name}, " +
-                  "version #{installed_gems[0].version}" if installed_gems
-              end
-            rescue LocalInstallationError => e
-              say " -> Local installation can't proceed: #{e.message}"
-            rescue Gem::LoadError => e
-              say " -> Local installation can't proceed due to LoadError: #{e.message}"
-            rescue Gem::InstallError => e
-              raise "Error instaling #{gem_name}:\n\t#{e.message}"
-            rescue => e
-              # TODO: Fix this handle to allow the error to propagate to
-              # the top level handler.  Examine the other errors as
-              # well.  This implementation here looks suspicious to me --
-              # JimWeirich (4/Jan/05) 
-              alert_error "Error installing gem #{gem_name}[.gem]: #{e.message}"
-              return
-            end
-          end
-        
-          if remote? && installed_gems.nil?
-            installer = Gem::RemoteInstaller.new(options)
-            installed_gems = installer.install(
-              gem_name,
-              options[:version],
-              options[:force],
-              options[:install_dir])
-            if installed_gems
-              installed_gems.compact!
-              installed_gems.each do |spec|
-                say "Successfully installed #{spec.full_name}"
-              end
-            end
-          end
-        
-          unless installed_gems
-            alert_error "Could not install a local " +
-              "or remote copy of the gem: #{gem_name}"
-            terminate_interaction(1)
-          end
-        
-          # NOTE: *All* of the RI documents must be generated first.
-          # For some reason, RI docs cannot be generated after any RDoc
-          # documents are generated.
-
-          if options[:generate_ri]
-            installed_gems.each do |gem|
-              Gem::DocManager.new(gem, options[:rdoc_args]).generate_ri
-            end
-          end
 
-          if options[:generate_rdoc]
-            installed_gems.each do |gem|
-              Gem::DocManager.new(gem, options[:rdoc_args]).generate_rdoc
-            end
-          end
+        installed_gems.push(*inst.installed_gems)
+      rescue Gem::InstallError => e
+        alert_error "Error installing #{gem_name}:\n\t#{e.message}"
+      rescue Gem::GemNotFoundException => e
+        alert_error e.message
+#      rescue => e
+#        # TODO: Fix this handle to allow the error to propagate to
+#        # the top level handler.  Examine the other errors as
+#        # well.  This implementation here looks suspicious to me --
+#        # JimWeirich (4/Jan/05)
+#        alert_error "Error installing gem #{gem_name}: #{e.message}"
+#        return
+      end
+    end
+
+    unless installed_gems.empty? then
+      gems = installed_gems.length == 1 ? 'gem' : 'gems'
+      say "#{installed_gems.length} #{gems} installed"
+    end
 
-          if options[:test]
-            installed_gems.each do |spec|
-              gem_spec = Gem::SourceIndex.from_installed_gems.search(spec.name, spec.version.version).first
-              result = Gem::Validator.new.unit_test(gem_spec)
-              unless result.passed?
-                unless ask_yes_no("...keep Gem?", true) then
-                  Gem::Uninstaller.new(spec.name, spec.version.version).uninstall
-                end
-              end
-            end
+    # NOTE: *All* of the RI documents must be generated first.
+    # For some reason, RI docs cannot be generated after any RDoc
+    # documents are generated.
+
+    if options[:generate_ri] then
+      installed_gems.each do |gem|
+        Gem::DocManager.new(gem, options[:rdoc_args]).generate_ri
+      end
+    end
+
+    if options[:generate_rdoc] then
+      installed_gems.each do |gem|
+        Gem::DocManager.new(gem, options[:rdoc_args]).generate_rdoc
+      end
+    end
+
+    if options[:test] then
+      installed_gems.each do |spec|
+        gem_spec = Gem::SourceIndex.from_installed_gems.search(spec.name, spec.version.version).first
+        result = Gem::Validator.new.unit_test(gem_spec)
+        if result and not result.passed?
+          unless ask_yes_no("...keep Gem?", true) then
+            Gem::Uninstaller.new(spec.name, :version => spec.version.version).uninstall
           end
         end
       end
-    
     end
-    
   end
-end
+
+end
+