rubygems-update 0.8.6 → 0.8.8

data/lib/rubygems/doc_manager.rb

@@ -35,6 +35,7 @@ module Gem
     end
     
     def generate_rdoc
+      return if @spec.has_rdoc == false
       require 'fileutils'
       Gem::FilePermissionError.new(@doc_dir) if File.exist?(@doc_dir) && !File.writable?(@doc_dir)
       FileUtils.mkdir_p @doc_dir unless File.exist?(@doc_dir)

data/lib/rubygems/gem_commands.rb

@@ -65,8 +65,16 @@ module Gem
       add_option('-t', '--[no-]test', 'Run unit tests prior to installation') do |value, options|
         options[:test] = 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',
+	'Unconditionally install the required dependent gems') do |value, options|
+	options[:include_dependencies] = value
+      end
     end
-
+    
     def install_update_defaults_str
       '--rdoc --no-force --no-test'
     end
@@ -144,9 +152,12 @@ module Gem
                 alert_error "Local gem file not found: #{filepattern}"
               end
             else
-              result = Gem::Installer.new(entries.last).install(options[:force], options[:install_dir])
+              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
+              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}"
@@ -165,8 +176,17 @@ module Gem
         if remote? && installed_gems.nil?
           say "Attempting remote installation of '#{gem_name}'"
           installer = Gem::RemoteInstaller.new(options)
-          installed_gems = installer.install(gem_name, options[:version], options[:force], options[:install_dir])
-          say "Successfully installed #{installed_gems[0].name}, version #{installed_gems[0].version}" if installed_gems
+          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
@@ -203,11 +223,26 @@ module Gem
 
     def initialize
       super('uninstall', 'Uninstall a gem from the local repository', {:version=>"> 0"})
+      add_option('-a', '--[no-]all',
+	'Uninstall all matching versions'
+	) do |value, options|
+        options[:all] = value
+      end
+      add_option('-i', '--[no-]ignore-dependencies',
+	'Ignore dependency requirements while uninstalling'
+	) do |value, options|
+        options[:ignore] = value
+      end
+      add_option('-x', '--[no-]executables',
+	'Uninstall applicable executables without confirmation'
+	) do |value, options|
+        options[:executables] = value
+      end
       add_version_option('uninstall')
     end
 
     def defaults_str
-      "--version '> 0'"
+      "--version '> 0' --no-force"
     end
     
     def usage
@@ -221,10 +256,108 @@ module Gem
     def execute
       gem_name = get_one_gem_name
       say "Attempting to uninstall gem '#{gem_name}'"
-      Gem::Uninstaller.new(gem_name, options[:version]).uninstall
+      Gem::Uninstaller.new(gem_name, options).uninstall
     end
   end      
 
+  ####################################################################
+  class DependencyCommand < Command
+    include VersionOption
+    include CommandAids
+
+    def initialize
+      super('dependency',
+	'Show the dependencies of an installed gem',
+	{:version=>"> 0"})
+      add_version_option('uninstall')
+      add_option('-r', '--[no-]reverse-dependencies',
+	'Include reverse dependencies in the output'
+	) do |value, options|
+        options[:reverse_dependencies] = value
+      end
+      add_option('-p', '--pipe', "Pipe Format (name --version ver)") do |value, options|
+	options[:pipe_format] = value
+      end
+    end
+
+    def defaults_str
+      "--version '> 0' --no-reverse"
+    end
+    
+    def usage
+      "#{program_name} GEMNAME"
+    end
+
+    def arguments
+      "GEMNAME   name of gems to show"
+    end
+
+    def execute
+      specs = {}
+      srcindex = SourceIndex.from_installed_gems
+      options[:args] << '.' if options[:args].empty?
+      options[:args].each do |name|
+	speclist = srcindex.search(name, options[:version])
+	if speclist.empty?
+	  say "No match found for #{name} (#{options[:version]})"
+	else
+	  speclist.each do |spec|
+	    specs[spec.full_name] = spec
+	  end
+	end
+      end
+      reverse = Hash.new { |h, k| h[k] = [] }
+      if options[:reverse_dependencies]
+	specs.values.each do |spec|
+	  reverse[spec.full_name] = find_reverse_dependencies(spec, srcindex)
+	end
+      end
+      if options[:pipe_format]
+	specs.values.sort.each do |spec|
+	  unless spec.dependencies.empty?
+	    spec.dependencies.each do |dep|
+	      puts %{#{dep.name} --version '#{dep.version_requirements}'}
+	    end
+	  end
+	end	
+      else
+	response = ''
+	specs.values.sort.each do |spec|
+	  response << "Gem #{spec.full_name}\n"
+	  unless spec.dependencies.empty?
+	    response << "  Requires\n"
+	    spec.dependencies.each do |dep|
+	      response << "    #{dep}\n"
+	    end
+	  end
+	  unless reverse[spec.full_name].empty?
+	    response << "  Used by\n"
+	    reverse[spec.full_name].each do |sp, dep|
+	      response << "    #{sp} (#{dep})\n"
+	    end
+	  end
+	  response << "\n"
+	end
+	say response
+      end
+    end
+
+    # Retuns list of [specification, dep] that are satisfied by spec.
+    def find_reverse_dependencies(spec, srcindex)
+      result = []
+      srcindex.each do |name, sp|
+	sp.dependencies.each do |dep|
+	  if spec.name == dep.name &&
+	      dep.version_requirements.satisfied_by?(spec.version)
+	    result << [sp.full_name, dep]
+	  end
+	end
+      end
+      result
+    end
+
+  end      
+
   ####################################################################
   class CheckCommand < Command
     include CommandAids
@@ -506,7 +639,7 @@ module Gem
         {
           :generate_rdoc => true, 
           :force => false, 
-          :test => false, 
+          :test => false,
           :install_dir => Gem.dir
         })
       add_install_update_options
@@ -564,7 +697,11 @@ module Gem
 	say "Updating version of RubyGems"
 	do_rubygems_update
       end
-      say "All gems up to date"
+      if(options[:system]) then
+        say "RubyGems system software updated"
+      else
+        say "Gems: [#{gems_to_update.uniq.sort.collect{|g| g.to_s}.join(', ')}] updated"
+      end
     end
 
     def do_rubygems_update
@@ -589,9 +726,77 @@ module Gem
       end
       result
     end
+  end
 
-    def command_manager
-      Gem::CommandManager.instance
+  ####################################################################
+  class CleanupCommand < Command
+    def initialize
+      super(
+        'cleanup',
+        'Cleanup 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 defaults_str
+      "--no-dryrun"
+    end
+
+    def arguments
+      "GEMNAME(s)   name of gem(s) to cleanup"
+    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?
+        options[:args].each do |gem_name|
+          specs = Gem.cache.search(/^#{gem_name}$/i)
+	  specs.each do |spec|
+	    gems_to_cleanup << spec
+	  end
+        end
+      else
+	srcindex.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
+      }
+      uninstall_command = command_manager['uninstall']
+      deplist = DependencyList.new
+      gems_to_cleanup.uniq.each do |spec| deplist.add(spec) end
+      deplist.dependency_order.each do |spec|
+	if options[:dryrun]
+	  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
+	    say "Unable to uninstall #{spec.full_name} ... continuing with remaining gems"
+	  end
+	end
+      end
+      say "Clean Up Complete"
     end
   end
 
@@ -882,10 +1087,6 @@ module Gem
         say Gem::HELP
       end
     end
-    
-    def command_manager
-      Gem::CommandManager.instance
-    end
   end
 
 end # module

data/lib/rubygems/installer.rb

@@ -1,6 +1,7 @@
 require 'pathname'
 require 'rbconfig'
 require 'rubygems/format'
+require 'rubygems/dependency_list'
 
 module Gem
 
@@ -19,8 +20,9 @@ module Gem
     #
     # gem:: [String] The file name of the gem
     #
-    def initialize(gem)
+    def initialize(gem, options={})
       @gem = gem
+      @options = options
     end
     
     ##
@@ -37,11 +39,10 @@ module Gem
     # force:: [default = false] if false will fail if a required Gem is not installed,
     #         or if the Ruby version is too low for the gem
     # install_dir:: [default = Gem.dir] directory that Gem is to be installed in
-    # install_stub:: [default = false] causes the installation of a library stub in the +site_ruby+ directory
     #
     # return:: [Gem::Specification] The specification for the newly installed Gem.
     #
-    def install(force=false, install_dir=Gem.dir, install_stub=false)
+    def install(force=false, install_dir=Gem.dir, ignore_this_parameter=false)
       require 'fileutils'
       format = Gem::Format.from_file_by_path(@gem)
       unless force
@@ -53,10 +54,12 @@ module Gem
           end
         end
         # Check the dependent gems.
-        spec.dependencies.each do |dep_gem|
-          # XXX: Does this take account of *versions*?
-          require_gem(dep_gem, false) #no autorequire
-        end
+	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
       end
       
       raise Gem::FilePermissionError.new(install_dir) unless File.writable?(install_dir)
@@ -67,7 +70,6 @@ module Gem
 
       extract_files(directory, format)
       generate_bin_scripts(format.spec, install_dir)
-      #generate_library_stubs(format.spec) if install_stub
       build_extensions(directory, format.spec)
       
       # Build spec/cache/doc dir.
@@ -106,7 +108,8 @@ module Gem
     end
     
     ##
-    # Writes the .gemspec specification (in Ruby) to the supplied spec_path.
+    # Writes the .gemspec specification (in Ruby) to the supplied
+    # spec_path.
     #
     # spec:: [Gem::Specification] The Gem specification to output
     # spec_path:: [String] The location (path) to write the gemspec to
@@ -151,15 +154,19 @@ module Gem
       end
     end
 
-    def shebang(spec, install_dir, file_name)
-      first_line = ""
-      File.open(File.join(install_dir, "gems", spec.full_name, spec.bindir,file_name), "rb") do |file|
+    def shebang(spec, install_dir, bin_file_name)
+      path = File.join(install_dir, "gems", spec.full_name, spec.bindir, bin_file_name)
+      File.open(path, "rb") do |file|
         first_line = file.readlines("\n").first 
-      end
-      if first_line =~ /^#!/ then
-        first_line.sub(/\A\#!\s*\S*ruby\S*/, "#!" + File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])) #Thanks RPA
-      else
-        "\#!#{File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])}"
+        path_to_ruby = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
+        if first_line =~ /^#!/
+          # Preserve extra words on shebang line, like "-w".  Thanks RPA.
+          shebang = first_line.sub(/\A\#!\s*\S*ruby\S*/, "#!" + path_to_ruby)
+        else
+          # Create a plain shebang line.
+          shebang = "#!" + path_to_ruby
+        end
+        return shebang.strip  # Avoid nasty ^M issues.
       end
     end
 
@@ -190,19 +197,6 @@ TEXT
       text
     end
 
-    ##
-    # Creates a file in the site_ruby directory that acts as a stub for the gem.  Thus, if
-    # 'package' is installed as a gem, the user can just type <tt>require 'package'</tt> and
-    # the gem (latest version) will be loaded.  This is like a backwards compatibility so that
-    # gems and non-gems can interact.
-    #
-    # Which files are stubified?  Those included in the gem's 'autorequire' and 'library_stubs'
-    # attributes.
-    #
-    def generate_library_stubs(spec)
-      LibraryStubs.new(spec).generate
-    end
-
     def build_extensions(directory, spec)
       return unless spec.extensions.size > 0
       say "Building native extensions.  This could take a while..."
@@ -259,196 +253,6 @@ TEXT
   end  # class Installer
 
 
-  #
-  # This class represents a single library stub, which is characterised by a 
-  #
-  class LibraryStub
-    SITELIBDIR = Pathname.new(Config::CONFIG['sitelibdir'])
-
-    #
-    # The 'autorequire' attribute in a gemspec is a special case: it represents a require
-    # target, not a relative path.  We therefore offer this method of creating a library stub
-    # for the autorequire file.
-    #
-    # If the given spec doesn't have an 'autorequire' value, we return +nil+.
-    #
-    def self.from_autorequire(gemspec, require_paths)
-      require_target = gemspec.autorequire
-      return nil if require_target.nil?
-      gem_relpath = find_gem_relpath(require_paths, require_target, gemspec)
-      LibraryStub.new(gemspec.name, require_paths, gem_relpath, true)
-    end
-
-    #
-    # require_paths::
-    #   ([Pathname]) The require paths in the gemspec.
-    # gem_relpath::
-    #   (String) The path to the library file, relative to the root of the gem.
-    # autorequire::
-    #   (Boolean) Whether this stub represents the gem's autorequire file.
-    #
-    def initialize(gem_name, require_paths, gem_relpath, autorequire=false)
-      @gem_name       = gem_name
-      @lib_relpath    = find_lib_relpath(require_paths, gem_relpath)
-      @require_target = @lib_relpath.to_s.sub(/\.rb\Z/, '')
-      @stub_path      = SITELIBDIR.join(@lib_relpath)
-      @autorequire    = autorequire
-    end
-
-    #
-    # The powerhouse of the class.  No exceptions should result from calling this.
-    #
-    def generate
-      if @stub_path.exist?
-        # The stub path is inhabited by a file.  If it's a gem stub, we'll overwrite it (just
-        # to be sure).  If it's a genuine library, we'll leave it alone and issue a warning.
-        unless library_stub?(@stub_path)
-          alert_warning(
-            ["Library file '#{target_path}'",
-             "already exists; not overwriting.  If you want to force a",
-             "library stub, delete the file and reinstall."].join("\n")
-          )
-          return
-        end
-      end
-
-      unless @stub_path.dirname.exist?
-        @stub_path.dirname.mkpath
-      end
-      @stub_path.open('w', 0644) do |io|
-        io.write(library_stub_content())
-      end
-    end
-
-    # Two LibraryStub objects are equal if they have the same gem name and relative (gem) path.
-    def ==(other)
-      LibraryStub === other and @gem_name == other.gem_name and
-        @gem_relpath == other.gem_relpath
-    end
-
-   private
-
-    #
-    # require_paths::
-    #   ([Pathname]) The require paths in the gemspec.
-    # require_target::
-    #   (String) The subject of an intended 'require' statement.
-    # gemspec::
-    #   (Gem::Specification) 
-    #
-    # The aim of this method is to resolve the require_target into a path relative to the root
-    # of the gem.  We try each require path in turn, and see if the require target exists under
-    # that directory.
-    #
-    # If no match is found, we return +nil+. 
-    #
-    def self.find_gem_relpath(require_paths, require_target, gemspec)
-      require_target << '.rb' unless require_target =~ /\.rb\Z/
-      gem_files = gemspec.files.map { |path| Pathname.new(path).cleanpath }
-      require_paths.each do |require_path|
-        possible_lib_path = require_path.join(require_target)
-        if gem_files.include?(possible_lib_path)
-          return possible_lib_path.to_s
-        end
-      end
-      nil  # If we get this far, there was no match.
-    end
-
-    #
-    # require_paths::
-    #   ([Pathname]) The require paths in the gemspec.
-    # gem_relpath::
-    #   (String) The path to the library file, relative to the root of the gem.
-    #
-    # Returns: the path (Pathname) to the same file, relative to the gem's library path
-    # (typically 'lib').  Thus 'lib/rake/rdoctask.rb' becomes 'rake/rdoctask.rb'.  The gemspec
-    # may contain several library paths, though that would be unusual, so we must deal with
-    # that possibility here.
-    #
-    # If there is no such relative path, we return +nil+. 
-    #
-    def find_lib_relpath(require_paths, gem_relpath)
-      require_paths.each do |require_path|
-        begin
-          return Pathname.new(gem_relpath).relative_path_from(require_path)
-        rescue ArgumentError
-          next
-        end
-        nil  # If we get this far, there was no match.
-      end
-    end
-
-    # Returns a string suitable for placing in a stub file.
-    def library_stub_content
-      content = %{
-        #
-        # This file was generated by RubyGems.
-        #
-        # The library '#{@gem_name}' is installed as part of a gem, and
-        # this file is here so you can 'require' it easily (i.e.
-        # without having to know it's a gem).
-        #
-        # gem: #{@gem_name}
-        # stub: #{@lib_relpath} 
-        #
- 
-        require 'rubygems'
-        $".delete('#{@lib_relpath}')
-        require_gem '#{@gem_name}'
-      }.gsub(/^[ \t]+/, '')
-      unless @autorequire
-        content << %{require '#{@require_target}'\n}
-      end
-      content << %{
-        # (end of stub)
-      }.gsub(/^[ \t]+/, '')
-    end
-
-    # Returns true iff the contents of the given _path_ (a Pathname) appear to be a RubyGems
-    # library stub.
-    def library_stub?(path)
-      lines = path.readlines
-      lines.grep(/^# This file was generated by RubyGems/) and
-        lines.grep(/is installed as part of a gem, and/)
-    end
-
-  end  # class LibraryStub
-  
-  
-  #
-  # This class contains the logic to generate all library stubs, including the autorequire, for
-  # a single gemspec.
-  #
-  #   LibraryStubs.new(gemspec).generate 
-  #
-  class LibraryStubs
-    SITELIBDIR = Pathname.new(Config::CONFIG['sitelibdir'])
-
-    def initialize(spec)
-      @spec = spec
-    end
-
-    def generate
-      require_paths = @spec.require_paths.map { |p| Pathname.new(p) }
-      stubs = @spec.library_stubs.map {
-        |stub| LibraryStub.new(@spec.name, require_paths, stub)
-      }
-      stubs << LibraryStub.from_autorequire(@spec, require_paths)
-      stubs = stubs.compact.uniq
-      unless stubs.empty?
-        if FileTest.writable?(SITELIBDIR)
-          stubs.each do |stub| stub.generate end
-        else
-          alert_warning(
-            ["Can't install library stub for gem '#{spec.name}'",
-             "(Don't have write permissions on '#{sitelibdir}' directory.)"].join("\n")
-           )
-        end
-      end
-    end
-  end  # class LibraryStubs
-
-  
   ##
   # The Uninstaller class uninstalls a Gem
   #
@@ -461,30 +265,39 @@ TEXT
     # 
     # gem:: [String] The Gem name to uninstall
     #
-    def initialize(gem, version="> 0")
+    def initialize(gem, options)
       @gem = gem
-      @version = version
+      @version = options[:version] || "> 0"
+      @force_executables = options[:executables]
+      @force_all = options[:all]
+      @force_ignore = options[:ignore]
     end
     
     ##
-    # Performs the uninstall of the Gem.  This removes the spec, the Gem directory, and the
-    # cached .gem file,
+    # Performs the uninstall of the Gem.  This removes the spec, the
+    # Gem directory, and the cached .gem file,
     #
-    # Application and library stubs are removed according to what is still installed.
+    # Application stubs are (or should be) removed according to what
+    # is still installed.
     #
-    # XXX: Application stubs refer to specific gem versions, which means things may get
-    # inconsistent after an uninstall (i.e. referring to a version that no longer exists).
+    # XXX: Application stubs refer to specific gem versions, which
+    # means things may get inconsistent after an uninstall
+    # (i.e. referring to a version that no longer exists).
     #
     def uninstall
       require 'fileutils'
-      list = Gem::SourceIndex.from_installed_gems.search(@gem, @version)
+      Gem.source_index.refresh!
+      list = Gem.source_index.search(@gem, @version)
       if list.size == 0 
         raise "Unknown RubyGem: #{@gem} (#{@version})"
-      elsif list.size > 1
+      elsif list.size > 1 && @force_all
+	remove_all(list.dup) 
+	remove_executables(list.last)
+      elsif list.size > 1 
         say 
-        gem_list = list.collect {|gem| gem.full_name}
-        gem_list << "All versions"
-        gem_name, index = choose_from_list("Select RubyGem to uninstall:", gem_list)
+        gem_names = list.collect {|gem| gem.full_name} + ["All versions"]
+        gem_name, index =
+	  choose_from_list("Select RubyGem to uninstall:", gem_names)
         if index == list.size
           remove_all(list.dup) 
           remove_executables(list.last)
@@ -495,18 +308,20 @@ TEXT
           say "Error: must enter a number [1-#{list.size+1}]"
         end
       else
+        remove(list[0], list.dup)
         remove_executables(list.last)
-        remove(list[0], list)
       end
     end
     
-    #
-    # Remove executables and batch files (windows only) for the gem as it is being installed
+    ##
+    # Remove executables and batch files (windows only) for the gem as
+    # it is being installed
     #
     # gemspec::[Specification] the gem whose executables need to be removed.
+    #
     def remove_executables(gemspec)
       return if gemspec.nil?
-      if(gemspec.executables.size > 0) then
+      if(gemspec.executables.size > 0)
         raise Gem::FilePermissionError.new(Config::CONFIG['bindir']) unless
 	  File.writable?(Config::CONFIG['bindir'])
         list = Gem.source_index.search(gemspec.name).delete_if { |spec|
@@ -519,7 +334,10 @@ TEXT
           end
         end
         return if executables.size == 0
-        answer = ask_yes_no("Remove executables and scripts for\n'#{gemspec.executables.join(", ")}' in addition to the gem?", true)
+        answer = @force_executables || ask_yes_no(
+	  "Remove executables and scripts for\n" +
+	  "'#{gemspec.executables.join(", ")}' in addition to the gem?",
+	  true)
         unless answer
           say "Executables and scripts will remain installed."
           return
@@ -537,8 +355,8 @@ TEXT
     #
     # list:: the list of all gems to remove
     #
-    # Warning: this method modifies the +list+ parameter.  Once it has uninstalled a gem, it is
-    # removed from that list.
+    # Warning: this method modifies the +list+ parameter.  Once it has
+    # uninstalled a gem, it is removed from that list.
     #
     def remove_all(list)
       list.dup.each { |gem| remove(gem, list) }
@@ -548,85 +366,92 @@ TEXT
     # spec:: the spec of the gem to be uninstalled
     # list:: the list of all such gems
     #
-    # Warning: this method modifies the +list+ parameter.  Once it has uninstalled a gem, it is
-    # removed from that list.
+    # Warning: this method modifies the +list+ parameter.  Once it has
+    # uninstalled a gem, it is removed from that list.
     #
     def remove(spec, list)
-      if(has_dependents?(spec)) then
-        raise DependencyRemovalException.new("Uninstallation aborted due to dependent gem(s)")
+      if( ! ok_to_remove?(spec)) then
+        raise DependencyRemovalException.new(
+	  "Uninstallation aborted due to dependent gem(s)")
       end
-      raise Gem::FilePermissionError.new(spec.installation_path) unless File.writable?(spec.installation_path)
+      raise Gem::FilePermissionError.new(spec.installation_path) unless
+	File.writable?(spec.installation_path)
       FileUtils.rm_rf spec.full_gem_path
-      FileUtils.rm_rf File.join(spec.installation_path, 'specifications', "#{spec.full_name}.gemspec")
-      FileUtils.rm_rf File.join(spec.installation_path, 'cache', "#{spec.full_name}.gem")
+      FileUtils.rm_rf File.join(
+	spec.installation_path,
+	'specifications',
+	"#{spec.full_name}.gemspec")
+      FileUtils.rm_rf File.join(
+	spec.installation_path,
+	'cache',
+	"#{spec.full_name}.gem")
       DocManager.new(spec).uninstall_doc
       #remove_stub_files(spec, list - [spec])
       say "Successfully uninstalled #{spec.name} version #{spec.version}"
       list.delete(spec)
     end
 
-    def has_dependents?(spec)
+    def ok_to_remove?(spec)
+      return true if @force_ignore
+      srcindex= Gem::SourceIndex.from_installed_gems
+      deplist = Gem::DependencyList.from_source_index(srcindex)
+      deplist.ok_to_remove?(spec.full_name) ||
+	ask_if_ok(spec)
+    end
+
+    def ask_if_ok(spec)
+      msg = ['']
+      msg << 'You have requested to uninstall the gem:'
+      msg << "\t#{spec.full_name}"
       spec.dependent_gems.each do |gem,dep,satlist|
-        msg = ['You have requested to uninstall the gem:']
-        satlist.each do |sat|
-          msg << "\t#{sat.name}-#{sat.version}"
-        end
-        msg << "#{gem.name}-#{gem.version} depends on [#{dep.name} (#{dep.version_requirements})]"
-        msg << 'If you remove this gem, the dependency will not be met.'
-        msg << 'Uninstall anyway?'
-        return !ask_yes_no(msg.join("\n"), false)
+        msg <<
+	  ("#{gem.name}-#{gem.version} depends on " +
+	  "[#{dep.name} (#{dep.version_requirements})]")
       end
-      false
+      msg << 'If you remove this gems, one or more dependencies will not be met.'
+      msg << 'Continue with Uninstall?'
+      return ask_yes_no(msg.join("\n"), true)
     end
 
     private
 
     ##
-    # Remove application and library stub files.  These are detected by the line
-    #   # This file was generated by RubyGems. 
+    # Remove application stub files.  These are detected by the line
+    #   # This file was generated by RubyGems.
     #
     # spec:: the spec of the gem that is being uninstalled
-    # other_specs:: any other installed specs for this gem (i.e. different versions)
+    # other_specs:: any other installed specs for this gem
+    #               (i.e. different versions)
     #
-    # Both parameters are necessary to ensure that the correct files are uninstalled.  It is
-    # assumed that +other_specs+ contains only *installed* gems, except the one that's about to
-    # be uninstalled.
+    # Both parameters are necessary to ensure that the correct files
+    # are uninstalled.  It is assumed that +other_specs+ contains only
+    # *installed* gems, except the one that's about to be uninstalled.
     #
     def remove_stub_files(spec, other_specs)
       remove_app_stubs(spec, other_specs)
-      remove_lib_stub(spec, other_specs)
     end
 
     def remove_app_stubs(spec, other_specs)
-      # App stubs are tricky, because each version of an app gem could install different
-      # applications.  We need to make sure that what we delete isn't needed by any remaining
-      # versions of the gem.
+      # App stubs are tricky, because each version of an app gem could
+      # install different applications.  We need to make sure that
+      # what we delete isn't needed by any remaining versions of the
+      # gem.
       #
-      # There's extra trickiness, too, because app stubs 'require_gem' a specific version of
-      # the gem.  If we uninstall the latest gem, we should ensure that there is a sensible app
-      # stub(s) installed after the removal of the current one.
+      # There's extra trickiness, too, because app stubs 'require_gem'
+      # a specific version of the gem.  If we uninstall the latest
+      # gem, we should ensure that there is a sensible app stub(s)
+      # installed after the removal of the current one.
       #
       # Perhaps the best way to approach this is:
-      #  * remove all application stubs for this gemspec
-      #  * regenerate the app stubs for the latest remaining version
-      #    (you always want to have the latest version of an app, don't you?)
+      # * remove all application stubs for this gemspec
+      # * regenerate the app stubs for the latest remaining version
+      #    (you always want to have the latest version of an app,
+      #    don't you?)
       #
-      # The Installer class doesn't really support this approach very well at the moment.
+      # The Installer class doesn't really support this approach very
+      # well at the moment.
     end
 
-    def remove_lib_stub(spec, other_specs)
-      # Library stubs are a bit easier than application stubs.  They do not refer to a specific
-      # version; they just load the latest version of the library available as a gem.  The only
-      # corner case is that different versions of the same gem may have different autorequire
-      # settings, which means they will have different library stubs.
-      #
-      # I suppose our policy should be: when you uninstall a library, make sure all the
-      # remaining versions of that gem are still supported by stubs.  Of course, the user may
-      # have expressed a preference in the past not to have library stubs installed.
-      #
-      # Mixing the segregated world of gem installations with the global namespace of the
-      # site_ruby directory certainly brings some tough issues.
-    end
   end  # class Uninstaller
 
 end  # module Gem