rubygems-update 0.8.10 → 0.8.11

data/lib/rubygems/format.rb

@@ -26,7 +26,7 @@ module Gem
     #
     # file_path:: [String] Path to the gem file
     #
-    def self.from_file_by_path(file_path)
+    def self.from_file_by_path(file_path, security_policy = nil)
       unless File.exist?(file_path)
         raise Gem::Exception, "Cannot load gem at [#{file_path}]"
       end
@@ -38,7 +38,7 @@ module Gem
         return OldFormat.from_file_by_path(file_path)
       else
         f = File.open(file_path, 'rb')
-        return from_io(f, file_path)
+        return from_io(f, file_path, security_policy)
       end
     end
 
@@ -48,9 +48,9 @@ module Gem
     #
     # io:: [IO] Stream from which to read the gem
     #
-    def self.from_io(io, gem_path="(io)")
+    def self.from_io(io, gem_path="(io)", security_policy = nil)
       format = self.new(gem_path)
-      Package.open_from_io(io) do |pkg|
+      Package.open_from_io(io, 'r', security_policy) do |pkg|
         format.spec = pkg.metadata
         format.file_entries = []
         pkg.each do |entry|

data/lib/rubygems/gem_commands.rb

@@ -51,6 +51,9 @@ module Gem
     end
   end
 
+  ##
+  # OptionParser options specific to the gem install command.
+
   module InstallUpdateOptions
     def add_install_update_options
       add_option('-i', '--install-dir DIR', '') do |value, options|
@@ -65,18 +68,28 @@ module Gem
       add_option('-t', '--[no-]test', 'Run unit tests prior to installation') do |value, options|
         options[:test] = value
       end
+      add_option('-w', '--[no-]wrappers', 'Use bin wrappers for executables',
+                 'Not available on dosish platforms') do |value, options|
+        options[:wrappers] = value
+      end
+      add_option('-P', '--trust-policy POLICY', 'Specify gem trust policy.') do |value, options|
+        options[:security_policy] = value
+      end
       add_option('--ignore-dependencies',
 	'Do not install any required dependent gems') do |value, options|
 	options[:ignore_dependencies] = value
       end
-      add_option('--include-dependencies',
+      add_option('-y', '--include-dependencies',
 	'Unconditionally install the required dependent gems') do |value, options|
 	options[:include_dependencies] = value
       end
     end
     
+    ##
+    # Default options for the gem install command.
+
     def install_update_defaults_str
-      '--rdoc --no-force --no-test'
+      '--rdoc --no-force --no-test --wrappers'
     end
   end
 
@@ -88,7 +101,9 @@ module Gem
     end
   end
 
-  ####################################################################
+  ##
+  # Gem install command.
+
   class InstallCommand < Command
     include CommandAids
     include VersionOption
@@ -104,15 +119,16 @@ module Gem
           :generate_rdoc => true, 
           :force => false, 
           :test => false, 
+          :wrappers => true,
           :version => "> 0",
-          :install_dir => Gem.dir
+          :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"
     end
@@ -260,6 +276,77 @@ module Gem
     end
   end      
 
+  class CertCommand < Command
+    include CommandAids
+    
+    def initialize
+      super(
+        'cert',
+        'Adjust RubyGems certificate 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)
+        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
+
+      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|
+          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('-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..."
+      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
+
   ####################################################################
   class DependencyCommand < Command
     include VersionOption
@@ -403,7 +490,7 @@ module Gem
       if options[:verify]
         gem_name = options[:verify]
         unless gem_name
-          alert_error "Must specifiy a .gem file with --verify NAME"
+          alert_error "Must specify a .gem file with --verify NAME"
           return
         end
         unless File.exist?(gem_name)
@@ -487,7 +574,7 @@ module Gem
         summary,
         {:name=>/.*/, :domain=>:local, :details=>false}
         )
-      add_option('-n', '--name-matches REGEXP', 'Name of gem(s) to query on maches the provided REGEXP') do |value, options|
+      add_option('-n', '--name-matches REGEXP', 'Name of gem(s) to query on matches the provided REGEXP') do |value, options|
         options[:name] = /#{value}/i
       end
       add_option('-d', '--[no-]details', 'Display detailed information of gem(s)') do |value, options|
@@ -635,7 +722,7 @@ module Gem
     def initialize
       super(
         'update',
-        'Upgrade currently installed gems in the local repository',
+        'Upgrade the named gem (or all installed gems) in the local repository',
         {
           :generate_rdoc => true, 
           :force => false, 
@@ -709,7 +796,7 @@ module Gem
       update_dir = File.join(Gem.dir, "gems", "rubygems-update-#{version_string}")
       Dir.chdir(update_dir) do
 	puts "Installing RubyGems #{version_string}"
-	system "ruby setup.rb"
+	system "#{Gem.ruby} setup.rb"
       end
     end
 
@@ -1089,6 +1176,71 @@ module Gem
     end
   end
 
+  class ContentsCommand < Command
+    include CommandAids
+    def initialize
+      super('contents','Disply the contents of the installed gems', {:list => true, :specdirs => [] })
+      add_option("-l","--list",'List the files inside a Gem') do |v,o|
+	o[:list] = true
+      end
+      
+      add_option("-V","--version","Specify version for gem to view") do |v,o|
+	o[:version] = v
+      end
+      
+      add_option('-s','--spec-dir a,b,c', Array, "Search for gems under specific paths") do |v,o|
+	o[:specdirs] = v
+      end
+      
+      add_option('-v','--verbose','Be verbose when showing status') do |v,o|
+	o[:verbose] = v
+      end
+    end
+    
+    def execute(io=STDOUT)
+      if options[:list]
+	version = options[:version] || "> 0.0.0"
+	gem = get_one_gem_name
+	
+	s = options[:specdirs].map do |i|
+	  [i, File.join(i,"specifications")]
+	end.flatten
+	
+	if s.empty?
+	  path_kind = "default gem paths"
+	  system = true
+	else
+	  path_kind = "specified path"
+	  system = false
+	end
+	
+	si = Gem::SourceIndex.from_installed_gems(*s)
+	
+	gem_spec = si.search(gem, version).first
+	unless gem_spec
+	  io.puts "Unable to find gem '#{gem}' in #{path_kind}"
+	  if options[:verbose]
+	    io.puts "\nDirectories searched:"
+	    if system
+	      Gem.path.each do |p|
+		io.puts p
+	      end
+	    else
+	      s.each do |p|
+		io.puts p
+	      end
+	    end
+	  end
+	  return
+	end
+	# show the list of files.
+	gem_spec.files.each do |f|
+	  io.puts File.join(gem_spec.full_gem_path, f)
+	end
+      end
+    end
+  end
+  
 end # module
 
 ## Documentation Constants

data/lib/rubygems/gem_openssl.rb

@@ -0,0 +1,34 @@
+
+# Some system might not have OpenSSL installed, therefore the core
+# library file openssl might not be available.  We localize testing
+# for the presence of OpenSSL in this file.
+
+module Gem
+  class << self
+    # Is SSL (used by the signing commands) available on this
+    # platform?
+    def ssl_available?
+      require 'rubygems/gem_openssl'
+      @ssl_available
+    end
+    
+    # Set the value of the ssl_avilable flag.
+    attr_writer :ssl_available
+    
+    # Ensure that SSL is available.  Throw an exception if it is not.
+    def ensure_ssl_available
+      unless ssl_available?
+	fail Gem::Exception, "SSL is not installed on this system"
+      end
+    end
+  end
+end
+
+begin
+  require 'openssl'
+  Gem.ssl_available = true
+rescue LoadError
+  Gem.ssl_available = false
+rescue
+  Gem.ssl_available = false
+end

data/lib/rubygems/gem_runner.rb

@@ -6,7 +6,11 @@ module Gem
 
     def run(args)
       do_configuration(args)
-      Gem::CommandManager.instance.run(@cfg)
+      cmd = Gem::CommandManager.instance
+      cmd.command_names.each do |c|
+          Command.add_specific_extra_args c, Array(@cfg[c])
+      end
+      cmd.run(@cfg)
     end
 
     private

data/lib/rubygems/installer.rb

@@ -1,3 +1,5 @@
+$TESTING = false unless defined? $TESTING
+
 require 'pathname'
 require 'rbconfig'
 require 'rubygems/format'
@@ -12,7 +14,7 @@ module Gem
   # files contained in the .gem into the Gem.path.
   #
   class Installer
-  
+
     include UserInteraction
   
     ##
@@ -44,7 +46,15 @@ module Gem
     #
     def install(force=false, install_dir=Gem.dir, ignore_this_parameter=false)
       require 'fileutils'
-      format = Gem::Format.from_file_by_path(@gem)
+
+      # if we're forcing the install, then disable security, _unless_ 
+      # the security policy says that we only install singed gems
+      # (this includes Gem::Security::HighSecurity)
+      security_policy = @options[:security_policy]
+      security_policy = nil if force && security_policy && 
+                            security_policy.only_signed != true
+
+      format = Gem::Format.from_file_by_path(@gem, security_policy)
       unless force
         spec = format.spec
         # Check the Ruby version.
@@ -53,49 +63,66 @@ module Gem
             raise "#{spec.name} requires Ruby version #{rrv}"
           end
         end
-        # Check the dependent gems.
-	# NOTE: THe dependent gem check is disabled.  WE SHOULD NOT
-	# REQUIRE GEMS DURING INSTALLTION.  If we need to check
-	# dependencies, we need a different way. 
-# 	unless @options[:ignore_dependencies]
-# 	  spec.dependencies.each do |dep_gem|
-# 	    # TODO: Does this take account of *versions*?
-# 	    require_gem_with_options(dep_gem, [], :auto_require=>false)
-# 	  end
-# 	end
+ 	unless @options[:ignore_dependencies]
+ 	  spec.dependencies.each do |dep_gem|
+	    ensure_dependency!(spec, dep_gem)
+ 	  end
+ 	end
       end
       
       raise Gem::FilePermissionError.new(install_dir) unless File.writable?(install_dir)
 
       # Build spec dir.
-      directory = File.join(install_dir, "gems", format.spec.full_name)
-      FileUtils.mkdir_p directory
+      @directory = File.join(install_dir, "gems", format.spec.full_name)
+      FileUtils.mkdir_p @directory
 
-      extract_files(directory, format)
-      generate_bin_scripts(format.spec, install_dir)
-      build_extensions(directory, format.spec)
+      extract_files(@directory, format)
+      generate_bin(format.spec, install_dir)
+      build_extensions(@directory, format.spec)
       
       # Build spec/cache/doc dir.
       build_support_directories(install_dir)
       
       # Write the spec and cache files.
       write_spec(format.spec, File.join(install_dir, "specifications"))
-      unless(File.exist?(File.join(File.join(install_dir, "cache"), @gem.split(/\//).pop))) 
-        FileUtils.cp(@gem, File.join(install_dir, "cache"))
+      unless File.exist? File.join(install_dir, "cache", @gem.split(/\//).pop)
+        FileUtils.cp @gem, File.join(install_dir, "cache")
       end
 
       format.spec.loaded_from = File.join(install_dir, 'specifications', format.spec.full_name+".gemspec")
       return format.spec
     end
 
-    # 
+    ##
+    # Ensure that the dependency is satisfied by the current
+    # installation of gem.  If it is not, then fail (i.e. throw and
+    # exception).
+    #
+    # spec       :: Gem::Specification
+    # dependency :: Gem::Dependency
+    def ensure_dependency!(spec, dependency)
+      raise "#{spec.name} requires #{dependency.name} #{dependency.version_requirements} " unless
+	installation_satisfies_dependency?(dependency)
+    end
+
+    ##
+    # True if the current installed gems satisfy the given dependency.
+    #
+    # dependency :: Gem::Dependency
+    def installation_satisfies_dependency?(dependency)
+      current_index = SourceIndex.from_installed_gems
+      current_index.find_name(dependency.name, dependency.version_requirements).size > 0
+    end
+
+    ##
     # Unpacks the gem into the given directory.
     #
     def unpack(directory)
-      format = Gem::Format.from_file_by_path(@gem)
+      format = Gem::Format.from_file_by_path(@gem, @options[:security_policy])
       extract_files(directory, format)
     end
 
+    ##
     # Given a root gem directory, build supporting directories for gem
     # if they do not already exist
     def build_support_directories(install_dir)
@@ -131,7 +158,44 @@ module Gem
       if Config::CONFIG["arch"] =~ /dos|win32/i
         script_name = filename + ".cmd"
         File.open(File.join(bindir, File.basename(script_name)), "w") do |file|
-          file.puts "@ruby \"#{File.join(bindir,filename)}\" %*"
+          file.puts "@#{Gem.ruby} \"#{File.join(bindir,filename)}\" %*"
+        end
+      end
+    end
+
+    ##
+    # Determines the directory for binaries
+    #
+    def bindir(install_dir=Gem.dir)
+      if(install_dir == Gem.default_dir)
+        # mac framework support
+        if defined? RUBY_FRAMEWORK_VERSION
+          File.join(File.dirname(Config::CONFIG["sitedir"]), File.basename(Config::CONFIG["bindir"]))
+        else # generic install
+          Config::CONFIG['bindir']
+        end
+      else
+        File.join(install_dir, "bin")
+      end
+    end
+
+    def generate_bin(spec, install_dir=Gem.dir)
+      return unless spec.executables && ! spec.executables.empty?
+      
+      # If the user has asked for the gem to be installed in
+      # a directory that is the system gem directory, then
+      # use the system bin directory, else create (or use) a
+      # new bin dir under the install_dir.
+      bindir = bindir(install_dir)
+
+      Dir.mkdir bindir unless File.exist? bindir
+      raise Gem::FilePermissionError.new(bindir) unless File.writable?(bindir)
+
+      spec.executables.each do |filename|
+        if @options[:wrappers] then
+          generate_bin_script spec, filename, bindir, install_dir
+        else
+          generate_bin_symlink spec, filename, bindir, install_dir
         end
       end
     end
@@ -139,22 +203,37 @@ module Gem
     ##
     # Creates the scripts to run the applications in the gem.
     #
-    def generate_bin_scripts(spec, install_dir=Gem.dir)
-      if spec.executables && ! spec.executables.empty?
-        bindir = if(install_dir == Gem.default_dir)
-	  Config::CONFIG['bindir'] 
-	else
-	  File.join(install_dir, "bin")
-	end
-        Dir.mkdir(bindir) unless File.exist?(bindir)
-        raise Gem::FilePermissionError.new(bindir) unless File.writable?(bindir)
-        spec.executables.each do |filename|
-          File.open(File.join(bindir, File.basename(filename)), "w", 0755) do |file|
-            file.print(app_script_text(spec, install_dir, filename))
-          end
-          generate_windows_script(bindir, filename)
+    def generate_bin_script(spec, filename, bindir, install_dir)
+      File.open(File.join(bindir, File.basename(filename)), "w", 0755) do |file|
+        file.print app_script_text(spec, install_dir, filename)
+      end
+      generate_windows_script bindir, filename
+    end
+
+    ##
+    # Creates the symlinks to run the applications in the gem.  Moves
+    # the symlink if the gem being installed has a newer version.
+    #
+    def generate_bin_symlink(spec, filename, bindir, install_dir)
+      if Config::CONFIG["arch"] =~ /dos|win32/i then
+        warn "Unable to use symlinks on win32, installing wrapper" unless $TESTING # HACK
+        generate_bin_script spec, filename, bindir, install_dir
+        return
+      end
+
+      src = File.join @directory, 'bin', filename
+      dst = File.join bindir, File.basename(filename)
+
+      if File.exist? dst then
+        if File.symlink? dst then
+          link = File.readlink(dst).split File::SEPARATOR
+          cur_version = Gem::Version.create(link[-3].sub(/^.*-/, ''))
+          return if spec.version < cur_version
         end
+        File.unlink dst
       end
+
+      File.symlink src, dst
     end
 
     def shebang(spec, install_dir, bin_file_name)
@@ -207,8 +286,8 @@ TEXT
       dest_path = File.join(directory, spec.require_paths[0])
       spec.extensions.each do |extension|
         Dir.chdir File.join(directory, File.dirname(extension))
-        results = ["ruby #{File.basename(extension)} #{ARGV.join(" ")}"]
-        results << `ruby #{File.basename(extension)} #{ARGV.join(" ")}`
+        results = ["#{Gem.ruby} #{File.basename(extension)} #{ARGV.join(" ")}"]
+        results << `#{Gem.ruby} #{File.basename(extension)} #{ARGV.join(" ")}`
         if File.exist?('Makefile')
           mf = File.read('Makefile')
           mf = mf.gsub(/^RUBYARCHDIR\s*=\s*\$.*/, "RUBYARCHDIR = #{dest_path}")