rubygems-update 0.9.4 → 0.9.5

data/lib/rubygems/commands/build_command.rb

@@ -1,57 +1,53 @@
-module Gem
-  module Commands
-    class BuildCommand < Command
-      include CommandAids
+require 'rubygems/command'
+require 'rubygems/builder'
 
-      def initialize
-        super('build', 'Build a gem from a gemspec')
-      end
+class Gem::Commands::BuildCommand < Gem::Command
 
-      def usage
-        "#{program_name} GEMSPEC_FILE"
-      end
+  def initialize
+    super('build', 'Build a gem from a gemspec')
+  end
 
-      def arguments
-        "GEMSPEC_FILE      name of gemspec file used to build the gem"
-      end
+  def arguments # :nodoc:
+    "GEMSPEC_FILE  gemspec file name to build a gem for"
+  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
-          return
-        else
-          alert_error "Gemspec file not found: #{gemspec}"
-        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)
-          require 'yaml'
-          result = []
-          open(filename) do |f|
-            begin
-              while spec = Gem::Specification.from_yaml(f)
-                result << spec
-              end
-            rescue EndOfYAMLException => e
-              # OK
-            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
-        else
-          result = [Gem::Specification.load(filename)]
+        rescue Gem::EndOfYAMLException => e
+          # OK
         end
-        result
-      end
-
-      def yaml?(filename)
-        line = open(filename) { |f| line = f.gets }
-        result = line =~ %r{^--- *!ruby/object:Gem::Specification}
-        result
       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
+end

data/lib/rubygems/commands/cert_command.rb

@@ -1,83 +1,86 @@
-module Gem
-  module Commands
-    
-    class CertCommand < Command
-      include CommandAids
-    
-      def initialize
-        super(
-          'cert',
-          'Adjust RubyGems certificate settings',
-          {
-          })
+require 'rubygems/command'
+require 'rubygems/security'
 
-        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)
-          puts "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|
-            cert = OpenSSL::X509::Certificate.new(File.read(path))
-            # this could proably be formatted more gracefully
-            puts cert.subject.to_s
-          end
-        end
+class Gem::Commands::CertCommand < Gem::Command
 
-        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')
+  def initialize
+    super 'cert', 'Manage RubyGems certificates and signing settings'
 
-          Dir::glob(glob_str) do |path|
-            cert = OpenSSL::X509::Certificate.new(File.read(path))
-            if cert.subject.to_s.downcase.index(value)
-              puts "Removing '#{cert.subject.to_s}'"
-              File.unlink(path)
-            end
-          end
-        end
+    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('-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])
-          puts "Public Cert: #{vals[:cert_path]}",
-               "Private Key: #{vals[:key_path]}",
-               "Don't forget to move the key file to somewhere private..."
+    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 proably be formatted more gracefully
+          say cert.subject.to_s
+        rescue OpenSSL::X509::CertificateError
+          next
         end
+      end
+    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('-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')
 
-        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
+      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('-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
+    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
 
-      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
 
-      def execute
-      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
-end
+
+  def execute
+  end
+
+end
+

data/lib/rubygems/commands/check_command.rb

@@ -1,74 +1,74 @@
-module Gem
-  module Commands
-    class CheckCommand < Command
-      include CommandAids
+require 'rubygems/command'
+require 'rubygems/version_option'
+require 'rubygems/validator'
 
-      def initialize
-        super('check', 'Check installed gems',
-              {:verify => false, :alien => false})
+class Gem::Commands::CheckCommand < Gem::Command
 
-        add_option('-v', '--verify FILE',
-                   'Verify gem file against its internal',
-                   'checksum') do |value, options|
-          options[:verify] = value
-        end
+  include Gem::VersionOption
 
-        add_option('-a', '--alien', "Report 'unmanaged' or rogue files in the",
-                   "gem repository") do |value, options|
-          options[:alien] = true
-        end
+  def initialize
+    super 'check', 'Check installed gems',
+          :verify => false, :alien => false
 
-        add_option('-t', '--test', "Run unit tests for gem") do |value, options|
-          options[:test] = true
-        end
+    add_option(      '--verify FILE',
+               'Verify gem file against its internal',
+               'checksum') do |value, options|
+      options[:verify] = value
+    end
 
-        add_option('-V', '--version',
-                   "Specify version for which to run unit tests") do |value, options|
-          options[:version] = value
-        end
-      end
-    
-      def execute
-        if options[:test]
-          version = options[:version] || "> 0.0.0"
-          gem_spec = Gem::SourceIndex.from_installed_gems.search(get_one_gem_name, version).first
-          Gem::Validator.new.unit_test(gem_spec)
-        end
-        if options[:alien]
-          say "Performing the 'alien' operation"
-          Gem::Validator.new.alien.each do |key, val|
-            if(val.size > 0)
-              say "#{key} has #{val.size} problems"
-              val.each do |error_entry|
-                say "\t#{error_entry.path}:"
-                say "\t#{error_entry.problem}"
-                say
-              end
-            else  
-              say "#{key} is error-free"
-            end
+    add_option('-a', '--alien', "Report 'unmanaged' or rogue files in the",
+               "gem repository") do |value, options|
+      options[:alien] = 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
+      gem_spec = Gem::SourceIndex.from_installed_gems.search(get_one_gem_name, version).first
+      Gem::Validator.new.unit_test(gem_spec)
+    end
+
+    if options[:alien]
+      say "Performing the 'alien' operation"
+      Gem::Validator.new.alien.each do |key, val|
+        if(val.size > 0)
+          say "#{key} has #{val.size} problems"
+          val.each do |error_entry|
+            say "\t#{error_entry.path}:"
+            say "\t#{error_entry.problem}"
             say
           end
+        else  
+          say "#{key} is error-free"
         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 => e
-            alert_error "#{gem_name} is invalid."
-          end
-        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 => e
+        alert_error "#{gem_name} is invalid."
       end
-    
     end
   end
-end
+
+end

data/lib/rubygems/commands/cleanup_command.rb

@@ -1,3 +1,7 @@
+require 'rubygems/command'
+require 'rubygems/source_index'
+require 'rubygems/dependency_list'
+
 module Gem
   module Commands
     class CleanupCommand < Command
@@ -14,26 +18,33 @@ module Gem
           options[:dryrun] = true
         end
       end
-    
-      def defaults_str
+
+      def arguments # :nodoc:
+        "GEMNAME       name of gem to cleanup"
+      end
+
+      def defaults_str # :nodoc:
         "--no-dryrun"
       end
 
-      def arguments
-        "GEMNAME(s)   name of gem(s) to cleanup"
+      def usage # :nodoc:
+        "#{program_name} [GEMNAME ...]"
       end
 
       def execute
         say "Cleaning up installed gems..."
         srcindex = Gem::SourceIndex.from_installed_gems
         primary_gems = {}
+
         srcindex.each do |name, spec|
           if primary_gems[spec.name].nil? or primary_gems[spec.name].version < spec.version
             primary_gems[spec.name] = spec
           end
         end
+
         gems_to_cleanup = []
-        if ! options[:args].empty?
+
+        unless options[:args].empty? then
           options[:args].each do |gem_name|
             specs = Gem.cache.search(/^#{gem_name}$/i)
             specs.each do |spec|
@@ -45,21 +56,27 @@ module Gem
               gems_to_cleanup << spec
           end
         end
+
         gems_to_cleanup = gems_to_cleanup.select { |spec|
           primary_gems[spec.name].version != spec.version
         }
-        uninstall_command = command_manager['uninstall']
+
+        uninstall_command = Gem::CommandManager.instance['uninstall']
         deplist = DependencyList.new
         gems_to_cleanup.uniq.each do |spec| deplist.add(spec) end
+
         deplist.dependency_order.each do |spec|
-          if options[:dryrun]
+          if options[:dryrun] then
             say "Dry Run Mode: Would uninstall #{spec.full_name}"
           else
             say "Attempting uninstall on #{spec.full_name}"
+
             options[:args] = [spec.name]
             options[:version] = "= #{spec.version}"
             options[:executables] = true
+
             uninstall_command.merge_options(options)
+
             begin
               uninstall_command.execute
             rescue Gem::DependencyRemovalException => ex
@@ -67,6 +84,7 @@ module Gem
             end
           end
         end
+
         say "Clean Up Complete"
       end
     end