rubygems-update 1.8.30 → 2.0.0.preview2

data/lib/rubygems/commands/build_command.rb

@@ -1,5 +1,5 @@
 require 'rubygems/command'
-require 'rubygems/builder'
+require 'rubygems/package'
 
 class Gem::Commands::BuildCommand < Gem::Command
 
@@ -22,11 +22,11 @@ class Gem::Commands::BuildCommand < Gem::Command
   def execute
     gemspec = get_one_gem_name
 
-    if File.exist? gemspec
-      spec = load_gemspec gemspec
+    if File.exist? gemspec then
+      spec = Gem::Specification.load gemspec
 
       if spec then
-        Gem::Builder.new(spec).build options[:force]
+        Gem::Package.build spec, options[:force]
       else
         alert_error "Error loading gemspec. Aborting."
         terminate_interaction 1
@@ -37,23 +37,5 @@ class Gem::Commands::BuildCommand < Gem::Command
     end
   end
 
-  def load_gemspec filename
-    if yaml?(filename)
-      open(filename) do |f|
-        begin
-          Gem::Specification.from_yaml(f)
-        rescue Gem::EndOfYAMLException
-          nil
-        end
-      end
-    else
-      Gem::Specification.load(filename) # can return nil
-    end
-  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

@@ -4,82 +4,224 @@ require 'rubygems/security'
 class Gem::Commands::CertCommand < Gem::Command
 
   def initialize
-    super 'cert', 'Manage RubyGems 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
+    super 'cert', 'Manage RubyGems certificates and signing settings',
+          :add => [], :remove => [], :list => [], :build => [], :sign => []
+
+    OptionParser.accept OpenSSL::X509::Certificate do |certificate|
+      begin
+        OpenSSL::X509::Certificate.new File.read certificate
+      rescue Errno::ENOENT
+        raise OptionParser::InvalidArgument, "#{certificate}: does not exist"
+      rescue OpenSSL::X509::CertificateError
+        raise OptionParser::InvalidArgument,
+          "#{certificate}: invalid X509 certificate"
       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
+    OptionParser.accept OpenSSL::PKey::RSA do |key_file|
+      begin
+        key = OpenSSL::PKey::RSA.new File.read key_file
+      rescue Errno::ENOENT
+        raise OptionParser::InvalidArgument, "#{key_file}: does not exist"
+      rescue OpenSSL::PKey::RSAError
+        raise OptionParser::InvalidArgument, "#{key_file}: invalid RSA key"
       end
+
+      raise OptionParser::InvalidArgument,
+            "#{key_file}: private key not found" unless key.private?
+
+      key
+    end
+
+    add_option('-a', '--add CERT', OpenSSL::X509::Certificate,
+               'Add a trusted certificate.') do |cert, options|
+      options[:add] << cert
+    end
+
+    add_option('-l', '--list [FILTER]',
+               'List trusted certificates where the',
+               'subject contains FILTER') do |filter, options|
+      filter ||= ''
+
+      options[:list] << filter
+    end
+
+    add_option('-r', '--remove FILTER',
+               'Remove trusted certificates where the',
+               'subject contains FILTER') do |filter, options|
+      options[:remove] << filter
     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)
-      FileUtils.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..."
+               'certificate for EMAIL_ADDR') do |email_address, options|
+      options[:build] << email_address
     end
 
-    add_option('-C', '--certificate CERT',
-               'Certificate for --sign command.') do |value, options|
-      cert = OpenSSL::X509::Certificate.new(File.read(value))
+    add_option('-C', '--certificate CERT', OpenSSL::X509::Certificate,
+               'Signing certificate for --sign') do |cert, options|
       options[: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))
-      options[:issuer_key] = key
+    add_option('-K', '--private-key KEY', OpenSSL::PKey::RSA,
+               'Key for --sign or --build') do |key, options|
+      options[: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 = options[:issuer_cert]
-      my_key = options[:issuer_key]
-      cert = Gem::Security.sign_cert(cert, my_key, my_cert)
-      File.open(value, 'wb') { |file| file.write(cert.to_pem) }
+    add_option('-s', '--sign CERT',
+               'Signs CERT with the key from -K',
+               'and the certificate from -C') do |cert_file, options|
+      raise OptionParser::InvalidArgument, "#{cert_file}: does not exist" unless
+        File.file? cert_file
+
+      options[:sign] << cert_file
     end
   end
 
   def execute
+    options[:add].each do |certificate|
+      Gem::Security.trust_dir.trust_cert certificate
+
+      say "Added '#{certificate.subject}'"
+    end
+
+    options[:remove].each do |filter|
+      certificates_matching filter do |certificate, path|
+        FileUtils.rm path
+        say "Removed '#{certificate.subject}'"
+      end
+    end
+
+    options[:list].each do |filter|
+      certificates_matching filter do |certificate, _|
+        # this could probably be formatted more gracefully
+        say certificate.subject.to_s
+      end
+    end
+
+    options[:build].each do |name|
+      build name
+    end
+
+    unless options[:sign].empty? then
+      load_default_cert unless options[:issuer_cert]
+      load_default_key  unless options[:key]
+    end
+
+    options[:sign].each do |cert_file|
+      sign cert_file
+    end
+  end
+
+  def build name
+    key = options[:key] || Gem::Security.create_key
+
+    cert = Gem::Security.create_cert_email name, key
+
+    key_path  = Gem::Security.write key, "gem-private_key.pem"
+    cert_path = Gem::Security.write cert, "gem-public_cert.pem"
+
+    say "Certificate: #{cert_path}"
+    say "Private Key: #{key_path}"
+    say "Don't forget to move the key file to somewhere private!"
+  end
+
+  def certificates_matching filter
+    return enum_for __method__, filter unless block_given?
+
+    Gem::Security.trusted_certificates.select do |certificate, _|
+      subject = certificate.subject.to_s
+      subject.downcase.index filter
+    end.sort_by do |certificate, _|
+      certificate.subject.to_a.map { |name, data,| [name, data] }
+    end.each do |certificate, path|
+      yield certificate, path
+    end
+  end
+
+  def description # :nodoc:
+    <<-EOF
+The cert command manages signing keys and certificates for creating signed
+gems.  Your signing certificate and private key are typically stored in
+~/.gem/gem-public_cert.pem and ~/.gem/gem-private_key.pem respectively.
+
+To build a certificate for signing gems:
+
+  gem cert --build you@example
+
+If you already have an RSA key, or are creating a new certificate for an
+existing key:
+
+  gem cert --build you@example --private-key /path/to/key.pem
+
+If you wish to trust a certificate you can add it to the trust list with:
+
+  gem cert --add /path/to/cert.pem
+
+You can list trusted certificates with:
+
+  gem cert --list
+
+or:
+
+  gem cert --list cert_subject_substring
+
+If you wish to remove a previously trusted certificate:
+
+  gem cert --remove cert_subject_substring
+
+To sign another gem author's certificate:
+
+  gem cert --sign /path/to/other_cert.pem
+
+For further reading on signing gems see `ri Gem::Security`.
+    EOF
+  end
+
+  def load_default_cert
+    cert_file = File.join Gem.user_home, 'gem-public_cert.pem'
+    cert = File.read cert_file
+    options[:issuer_cert] = OpenSSL::X509::Certificate.new cert
+  rescue Errno::ENOENT
+    alert_error \
+      "--certificate not specified and ~/.gem/gem-public_cert.pem does not exist"
+
+    terminate_interaction 1
+  rescue OpenSSL::X509::CertificateError
+    alert_error \
+      "--certificate not specified and ~/.gem/gem-public_cert.pem is not valid"
+
+    terminate_interaction 1
+  end
+
+  def load_default_key
+    key_file = File.join Gem.user_home, 'gem-private_key.pem'
+    key = File.read key_file
+    options[:key] = OpenSSL::PKey::RSA.new key
+  rescue Errno::ENOENT
+    alert_error \
+      "--private-key not specified and ~/.gem/gem-private_key.pem does not exist"
+
+    terminate_interaction 1
+  rescue OpenSSL::PKey::RSAError
+    alert_error \
+      "--private-key not specified and ~/.gem/gem-private_key.pem is not valid"
+
+    terminate_interaction 1
+  end
+
+  def sign cert_file
+    cert = File.read cert_file
+    cert = OpenSSL::X509::Certificate.new cert
+
+    permissions = File.stat(cert_file).mode & 0777
+
+    issuer_cert = options[:issuer_cert]
+    issuer_key = options[:key]
+
+    cert = Gem::Security.sign cert, issuer_key, issuer_cert
+
+    Gem::Security.write cert, cert_file, permissions
   end
 
 end

data/lib/rubygems/commands/check_command.rb

@@ -8,13 +8,7 @@ class Gem::Commands::CheckCommand < Gem::Command
 
   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
+          :alien => true
 
     add_option('-a', '--alien', "Report 'unmanaged' or rogue files in the",
                "gem repository") do |value, options|
@@ -25,40 +19,21 @@ class Gem::Commands::CheckCommand < Gem::Command
   end
 
   def execute
-    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 Gem.configuration.verbose
+    say "Checking gems..."
+    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
-        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."
+      else
+        say "#{key} is error-free" if Gem.configuration.verbose
       end
+      say
     end
   end
 

data/lib/rubygems/commands/cleanup_command.rb

@@ -26,6 +26,9 @@ class Gem::Commands::CleanupCommand < Gem::Command
     <<-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.
+
+Older gems that are required to satisify the dependencies of gems
+are not removed.
     EOF
   end
 
@@ -56,14 +59,19 @@ installed elsewhere in GEM_PATH the cleanup command won't touch it.
       primary_gems[spec.name].version != spec.version
     }
 
+    full = Gem::DependencyList.from_specs
+
     deplist = Gem::DependencyList.new
     gems_to_cleanup.uniq.each do |spec| deplist.add spec end
 
     deps = deplist.strongly_connected_components.flatten.reverse
 
+    original_home = Gem.dir
     original_path = Gem.path
 
     deps.each do |spec|
+      next unless full.ok_to_remove?(spec.full_name)
+
       if options[:dryrun] then
         say "Dry Run Mode: Would uninstall #{spec.full_name}"
       else
@@ -90,7 +98,7 @@ installed elsewhere in GEM_PATH the cleanup command won't touch it.
       end
 
       # Restore path Gem::Uninstaller may have change
-      Gem.use_paths(*original_path)
+      Gem.use_paths(original_home, *original_path)
     end
 
     say "Clean Up Complete"

data/lib/rubygems/commands/contents_command.rb

@@ -1,3 +1,4 @@
+require 'English'
 require 'rubygems/command'
 require 'rubygems/version_option'
 
@@ -74,25 +75,42 @@ class Gem::Commands::ContentsCommand < Gem::Command
 
         if Gem.configuration.verbose then
           say "\nDirectories searched:"
-          spec_dirs.each { |dir| say dir }
+          spec_dirs.sort.each { |dir| say dir }
         end
 
         terminate_interaction 1 if gem_names.length == 1
       end
 
-      gem_path = spec.full_gem_path
-      extra    = "/{#{spec.require_paths.join ','}}" if options[:lib_only]
-      glob     = "#{gem_path}#{extra}/**/*"
-      files    = Dir[glob]
-
-      gem_path = File.join gem_path, '' # add trailing / if missing
-
-      files.sort.each do |file|
-        next if File.directory? file
+      if spec.default_gem?
+        files = spec.files.sort.map do |file|
+          case file
+          when /\A#{spec.bindir}\//
+            [Gem::ConfigMap[:bindir], $POSTMATCH]
+          when /\.so\z/
+            [Gem::ConfigMap[:archdir], file]
+          else
+            [Gem::ConfigMap[:rubylibdir], file]
+          end
+        end
+      else
+        gem_path  = spec.full_gem_path
+        extra     = "/{#{spec.require_paths.join ','}}" if options[:lib_only]
+        glob      = "#{gem_path}#{extra}/**/*"
+        prefix_re = /#{Regexp.escape(gem_path)}\//
+        files     = Dir[glob].map do |file|
+          [gem_path, file.sub(prefix_re, "")]
+        end
+      end
 
-        file = file.sub gem_path, '' unless options[:prefix]
+      files.sort.each do |prefix, basename|
+        absolute_path = File.join(prefix, basename)
+        next if File.directory? absolute_path
 
-        say file
+        if options[:prefix]
+          say absolute_path
+        else
+          say basename
+        end
       end
     end
   end