slimgems 1.3.8

data/lib/rubygems/command_manager.rb

@@ -0,0 +1,182 @@
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+require 'timeout'
+require 'rubygems/command'
+require 'rubygems/user_interaction'
+
+##
+# The command manager registers and installs all the individual sub-commands
+# supported by the gem command.
+#
+# Extra commands can be provided by writing a rubygems_plugin.rb
+# file in an installed gem.  You should register your command against the
+# Gem::CommandManager instance, like this:
+#
+#   # file rubygems_plugin.rb
+#   require 'rubygems/command_manager'
+#
+#   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
+
+  include Gem::UserInteraction
+
+  ##
+  # Return the authoritative instance of the command manager.
+
+  def self.instance
+    @command_manager ||= new
+  end
+
+  ##
+  # Register all the subcommands supported by the gem command.
+
+  def initialize
+    @commands = {}
+    register_command :build
+    register_command :cert
+    register_command :check
+    register_command :cleanup
+    register_command :contents
+    register_command :dependency
+    register_command :environment
+    register_command :fetch
+    register_command :generate_index
+    register_command :help
+    register_command :install
+    register_command :list
+    register_command :lock
+    register_command :mirror
+    register_command :outdated
+    register_command :owner
+    register_command :pristine
+    register_command :push
+    register_command :query
+    register_command :rdoc
+    register_command :search
+    register_command :server
+    register_command :sources
+    register_command :specification
+    register_command :stale
+    register_command :uninstall
+    register_command :unpack
+    register_command :update
+    register_command :which
+  end
+
+  ##
+  # Register the Symbol +command+ as a gem command.
+
+  def register_command(command)
+    @commands[command] = false
+  end
+
+  ##
+  # Return the registered command from the command name.
+
+  def [](command_name)
+    command_name = command_name.intern
+    return nil if @commands[command_name].nil?
+    @commands[command_name] ||= load_and_instantiate(command_name)
+  end
+
+  ##
+  # 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+.
+
+  def run(args)
+    process_args(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
+    terminate_interaction(1)
+  rescue Interrupt
+    alert_error "Interrupted"
+    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::Command::HELP
+      terminate_interaction(1)
+    end
+    case args[0]
+    when '-h', '--help'
+      say Gem::Command::HELP
+      terminate_interaction(0)
+    when '-v', '--version'
+      say "#{Gem::NAME} " + Gem::VERSION
+      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)
+      cmd.invoke(*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}"
+    end
+
+    self[possibilities.first]
+  end
+
+  def find_command_possibilities(cmd_name)
+    len = cmd_name.length
+
+    command_names.select { |n| cmd_name == n[0, len] }
+  end
+
+  private
+
+  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
+
+    begin
+      commands.const_get const_name
+    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
+        raise RuntimeError
+      end
+      retry
+    end.new
+  end
+
+end
+

data/lib/rubygems/commands/build_command.rb

@@ -0,0 +1,53 @@
+require 'rubygems/command'
+require 'rubygems/builder'
+
+class Gem::Commands::BuildCommand < Gem::Command
+
+  def initialize
+    super('build', 'Build a gem from a gemspec')
+  end
+
+  def arguments # :nodoc:
+    "GEMSPEC_FILE  gemspec file name to build a gem for"
+  end
+
+  def usage # :nodoc:
+    "#{program_name} GEMSPEC_FILE"
+  end
+
+  def execute
+    gemspec = get_one_gem_name
+    if File.exist?(gemspec)
+      specs = load_gemspecs(gemspec)
+      specs.each do |spec|
+        Gem::Builder.new(spec).build
+      end
+    else
+      alert_error "Gemspec file not found: #{gemspec}"
+    end
+  end
+
+  def load_gemspecs(filename)
+    if yaml?(filename)
+      result = []
+      open(filename) do |f|
+        begin
+          while not f.eof? and spec = Gem::Specification.from_yaml(f)
+            result << spec
+          end
+        rescue Gem::EndOfYAMLException
+          # OK
+        end
+      end
+    else
+      result = [Gem::Specification.load(filename)]
+    end
+    result
+  end
+
+  def yaml?(filename)
+    line = open(filename) { |f| line = f.gets }
+    result = line =~ %r{!ruby/object:Gem::Specification}
+    result
+  end
+end

data/lib/rubygems/commands/cert_command.rb

@@ -0,0 +1,86 @@
+require 'rubygems/command'
+require 'rubygems/security'
+
+class Gem::Commands::CertCommand < Gem::Command
+
+  def initialize
+    super 'cert', "Manage #{Gem::NAME} certificates and signing settings"
+
+    add_option('-a', '--add CERT',
+               'Add a trusted certificate.') do |value, options|
+      cert = OpenSSL::X509::Certificate.new(File.read(value))
+      Gem::Security.add_trusted_cert(cert)
+      say "Added '#{cert.subject.to_s}'"
+    end
+
+    add_option('-l', '--list',
+               'List trusted certificates.') do |value, options|
+      glob_str = File::join(Gem::Security::OPT[:trust_dir], '*.pem')
+      Dir::glob(glob_str) do |path|
+        begin
+          cert = OpenSSL::X509::Certificate.new(File.read(path))
+          # this could probably be formatted more gracefully
+          say cert.subject.to_s
+        rescue OpenSSL::X509::CertificateError
+          next
+        end
+      end
+    end
+
+    add_option('-r', '--remove STRING',
+               'Remove trusted certificates containing',
+               'STRING.') do |value, options|
+      trust_dir = Gem::Security::OPT[:trust_dir]
+      glob_str = File::join(trust_dir, '*.pem')
+
+      Dir::glob(glob_str) do |path|
+        begin
+          cert = OpenSSL::X509::Certificate.new(File.read(path))
+          if cert.subject.to_s.downcase.index(value)
+            say "Removed '#{cert.subject.to_s}'"
+            File.unlink(path)
+          end
+        rescue OpenSSL::X509::CertificateError
+          next
+        end
+      end
+    end
+
+    add_option('-b', '--build EMAIL_ADDR',
+               'Build private key and self-signed',
+               'certificate for EMAIL_ADDR.') do |value, options|
+      vals = Gem::Security.build_self_signed_cert(value)
+      File.chmod 0600, vals[:key_path]
+      say "Public Cert: #{vals[:cert_path]}"
+      say "Private Key: #{vals[:key_path]}"
+      say "Don't forget to move the key file to somewhere private..."
+    end
+
+    add_option('-C', '--certificate CERT',
+               'Certificate for --sign command.') do |value, options|
+      cert = OpenSSL::X509::Certificate.new(File.read(value))
+      Gem::Security::OPT[:issuer_cert] = cert
+    end
+
+    add_option('-K', '--private-key KEY',
+               'Private key for --sign command.') do |value, options|
+      key = OpenSSL::PKey::RSA.new(File.read(value))
+      Gem::Security::OPT[:issuer_key] = key
+    end
+
+    add_option('-s', '--sign NEWCERT',
+               'Sign a certificate with my key and',
+               'certificate.') do |value, options|
+      cert = OpenSSL::X509::Certificate.new(File.read(value))
+      my_cert = Gem::Security::OPT[:issuer_cert]
+      my_key = Gem::Security::OPT[:issuer_key]
+      cert = Gem::Security.sign_cert(cert, my_key, my_cert)
+      File.open(value, 'wb') { |file| file.write(cert.to_pem) }
+    end
+  end
+
+  def execute
+  end
+
+end
+

data/lib/rubygems/commands/check_command.rb

@@ -0,0 +1,80 @@
+require 'rubygems/command'
+require 'rubygems/version_option'
+require 'rubygems/validator'
+
+class Gem::Commands::CheckCommand < Gem::Command
+
+  include Gem::VersionOption
+
+  def initialize
+    super 'check', 'Check installed gems',
+          :verify => false, :alien => false
+
+    add_option(      '--verify FILE',
+               'Verify gem file against its internal',
+               'checksum') do |value, options|
+      options[:verify] = value
+    end
+
+    add_option('-a', '--alien', "Report 'unmanaged' or rogue files in the",
+               "gem repository") do |value, options|
+      options[:alien] = true
+    end
+
+    add_option('-v', '--verbose', "Spew more words") do |value, options|
+      options[:verbose] = true
+    end
+
+    add_option('-t', '--test', "Run unit tests for gem") do |value, options|
+      options[:test] = true
+    end
+
+    add_version_option 'run tests for'
+  end
+
+  def execute
+    if options[:test]
+      version = options[:version] || Gem::Requirement.default
+      dep = Gem::Dependency.new get_one_gem_name, version
+      gem_spec = Gem::SourceIndex.from_installed_gems.search(dep).first
+      Gem::Validator.new.unit_test(gem_spec)
+    end
+
+    if options[:alien]
+      say "Performing the 'alien' operation"
+      say
+      gems = get_all_gem_names rescue []
+      Gem::Validator.new.alien(gems).sort.each do |key, val|
+        unless val.empty? then
+          say "#{key} has #{val.size} problems"
+          val.each do |error_entry|
+            say "  #{error_entry.path}:"
+            say "    #{error_entry.problem}"
+          end
+        else
+          say "#{key} is error-free" if options[:verbose]
+        end
+        say
+      end
+    end
+
+    if options[:verify]
+      gem_name = options[:verify]
+      unless gem_name
+        alert_error "Must specify a .gem file with --verify NAME"
+        return
+      end
+      unless File.exist?(gem_name)
+        alert_error "Unknown file: #{gem_name}."
+        return
+      end
+      say "Verifying gem: '#{gem_name}'"
+      begin
+        Gem::Validator.new.verify_gem_file(gem_name)
+      rescue Exception
+        alert_error "#{gem_name} is invalid."
+      end
+    end
+  end
+
+end

data/lib/rubygems/commands/cleanup_command.rb

@@ -0,0 +1,106 @@
+require 'rubygems/command'
+require 'rubygems/source_index'
+require 'rubygems/dependency_list'
+require 'rubygems/uninstaller'
+
+class Gem::Commands::CleanupCommand < Gem::Command
+
+  def initialize
+    super 'cleanup',
+          'Clean up old versions of installed gems in the local repository',
+          :force => false, :test => false, :install_dir => Gem.dir
+
+    add_option('-d', '--dryrun', "") do |value, options|
+      options[:dryrun] = true
+    end
+  end
+
+  def arguments # :nodoc:
+    "GEMNAME       name of gem to cleanup"
+  end
+
+  def defaults_str # :nodoc:
+    "--no-dryrun"
+  end
+
+  def description # :nodoc:
+    <<-EOF
+The cleanup command removes old gems from GEM_HOME.  If an older version is
+installed elsewhere in GEM_PATH the cleanup command won't touch it.
+    EOF
+  end
+
+  def usage # :nodoc:
+    "#{program_name} [GEMNAME ...]"
+  end
+
+  def execute
+    say "Cleaning up installed gems..."
+    primary_gems = {}
+
+    Gem.source_index.each do |name, spec|
+      if primary_gems[spec.name].nil? or
+         primary_gems[spec.name].version < spec.version then
+        primary_gems[spec.name] = spec
+      end
+    end
+
+    gems_to_cleanup = []
+
+    unless options[:args].empty? then
+      options[:args].each do |gem_name|
+        dep = Gem::Dependency.new gem_name, Gem::Requirement.default
+        specs = Gem.source_index.search dep
+        specs.each do |spec|
+          gems_to_cleanup << spec
+        end
+      end
+    else
+      Gem.source_index.each do |name, spec|
+        gems_to_cleanup << spec
+      end
+    end
+
+    gems_to_cleanup = gems_to_cleanup.select { |spec|
+      primary_gems[spec.name].version != spec.version
+    }
+
+    deplist = Gem::DependencyList.new
+    gems_to_cleanup.uniq.each do |spec| deplist.add spec end
+
+    deps = deplist.strongly_connected_components.flatten.reverse
+
+    deps.each do |spec|
+      if options[:dryrun] then
+        say "Dry Run Mode: Would uninstall #{spec.full_name}"
+      else
+        say "Attempting to uninstall #{spec.full_name}"
+
+        options[:args] = [spec.name]
+
+        uninstall_options = {
+          :executables => false,
+          :version => "= #{spec.version}",
+        }
+
+        if Gem.user_dir == spec.installation_path then
+          uninstall_options[:install_dir] = spec.installation_path
+        end
+
+        uninstaller = Gem::Uninstaller.new spec.name, uninstall_options
+
+        begin
+          uninstaller.uninstall
+        rescue Gem::DependencyRemovalException, Gem::InstallError,
+               Gem::GemNotInHomeException => e
+          say "Unable to uninstall #{spec.full_name}:"
+          say "\t#{e.class}: #{e.message}"
+        end
+      end
+    end
+
+    say "Clean Up Complete"
+  end
+
+end
+