rubygems-update 1.0.1 → 1.1.0

data/lib/rubygems/commands/sources_command.rb

@@ -39,8 +39,11 @@ class Gem::Commands::SourcesCommand < Gem::Command
     options[:list] = !(options[:add] || options[:remove] || options[:clear_all] || options[:update])
 
     if options[:clear_all] then
-      remove_cache_file("user", Gem::SourceInfoCache.user_cache_file)
-      remove_cache_file("system", Gem::SourceInfoCache.system_cache_file)
+      sic = Gem::SourceInfoCache
+      remove_cache_file 'user',          sic.user_cache_file
+      remove_cache_file 'latest user',   sic.latest_user_cache_file
+      remove_cache_file 'system',        sic.system_cache_file
+      remove_cache_file 'latest system', sic.latest_system_cache_file
     end
 
     if options[:add] then
@@ -48,7 +51,7 @@ class Gem::Commands::SourcesCommand < Gem::Command
 
       sice = Gem::SourceInfoCacheEntry.new nil, nil
       begin
-        sice.refresh source_uri
+        sice.refresh source_uri, true
 
         Gem::SourceInfoCache.cache_data[source_uri] = sice
         Gem::SourceInfoCache.cache.update
@@ -66,7 +69,7 @@ class Gem::Commands::SourcesCommand < Gem::Command
     end
 
     if options[:update] then
-      Gem::SourceInfoCache.cache.refresh
+      Gem::SourceInfoCache.cache true
       Gem::SourceInfoCache.cache.flush
 
       say "source cache successfully updated"
@@ -78,6 +81,11 @@ class Gem::Commands::SourcesCommand < Gem::Command
       unless Gem.sources.include? source_uri then
         say "source #{source_uri} not present in cache"
       else
+        begin # HACK figure out how to get the cache w/o update
+          Gem::SourceInfoCache.cache
+        rescue Gem::RemoteFetcher::FetchError
+        end
+
         Gem::SourceInfoCache.cache_data.delete source_uri
         Gem::SourceInfoCache.cache.update
         Gem::SourceInfoCache.cache.flush
@@ -92,19 +100,20 @@ class Gem::Commands::SourcesCommand < Gem::Command
       say "*** CURRENT SOURCES ***"
       say
 
-      Gem.sources.each do |source_uri|
-        say source_uri
+      Gem.sources.each do |source|
+        say source
       end
     end
   end
 
   private
 
-  def remove_cache_file(desc, fn)
-    FileUtils.rm_rf fn rescue nil
-    if ! File.exist?(fn)
+  def remove_cache_file(desc, path)
+    FileUtils.rm_rf path
+
+    if not File.exist?(path) then
       say "*** Removed #{desc} source cache ***"
-    elsif ! File.writable?(fn)
+    elsif not File.writable?(path) then
       say "*** Unable to remove #{desc} source cache (write protected) ***"
     else
       say "*** Unable to remove #{desc} source cache ***"

data/lib/rubygems/commands/specification_command.rb

@@ -3,6 +3,7 @@ require 'rubygems/command'
 require 'rubygems/local_remote_options'
 require 'rubygems/version_option'
 require 'rubygems/source_info_cache'
+require 'rubygems/format'
 
 class Gem::Commands::SpecificationCommand < Gem::Command
 
@@ -41,13 +42,16 @@ class Gem::Commands::SpecificationCommand < Gem::Command
     gem = get_one_gem_name
 
     if local? then
-      source_index = Gem::SourceIndex.from_installed_gems
-      specs.push(*source_index.search(/\A#{gem}\z/, options[:version]))
+      if File.exist? gem then
+        specs << Gem::Format.from_file_by_path(gem).spec rescue nil
+      end
+
+      if specs.empty? then
+        specs.push(*Gem.source_index.search(/\A#{gem}\z/, options[:version]))
+      end
     end
 
     if remote? then
-      alert_warning "Remote information is not complete\n\n"
-
       Gem::SourceInfoCache.cache_data.each do |_,sice|
         specs.push(*sice.source_index.search(gem, options[:version]))
       end
@@ -58,12 +62,12 @@ class Gem::Commands::SpecificationCommand < Gem::Command
       terminate_interaction 1
     end
 
-    output = lambda { |spec| say spec.to_yaml; say "\n" }
+    output = lambda { |s| say s.to_yaml; say "\n" }
 
     if options[:all] then
       specs.each(&output)
     else
-      spec = specs.sort_by { |spec| spec.version }.last
+      spec = specs.sort_by { |s| s.version }.last
       output[spec]
     end
   end

data/lib/rubygems/commands/uninstall_command.rb

@@ -18,18 +18,28 @@ module Gem
           options[:all] = value
         end
 
-          add_option('-i', '--[no-]ignore-dependencies',
-                     'Ignore dependency requirements while',
-                     'uninstalling') do |value, options|
+        add_option('-I', '--[no-]ignore-dependencies',
+                   'Ignore dependency requirements while',
+                   'uninstalling') do |value, options|
           options[:ignore] = value
         end
 
-          add_option('-x', '--[no-]executables',
+        add_option('-x', '--[no-]executables',
                      'Uninstall applicable executables without',
                      'confirmation') do |value, options|
           options[:executables] = value
         end
 
+        add_option('-i', '--install-dir DIR',
+                   'Directory to uninstall gem from') do |value, options|
+          options[:install_dir] = File.expand_path(value)
+        end
+
+        add_option('-n', '--bindir DIR',
+                   'Directory to remove binaries from') do |value, options|
+          options[:bin_dir] = File.expand_path(value)
+        end
+
         add_version_option
         add_platform_option
       end
@@ -39,7 +49,8 @@ module Gem
       end
 
       def defaults_str # :nodoc:
-        "--version '#{Gem::Requirement.default}' --no-force"
+        "--version '#{Gem::Requirement.default}' --no-force " \
+        "--install-dir #{Gem.dir}"
       end
 
       def usage # :nodoc:
@@ -48,7 +59,13 @@ module Gem
 
       def execute
         get_all_gem_names.each do |gem_name|
-          Gem::Uninstaller.new(gem_name, options).uninstall
+          begin
+            Gem::Uninstaller.new(gem_name, options).uninstall
+          rescue Gem::GemNotInHomeException => e
+            spec = e.spec
+            alert("In order to remove #{spec.name}, please execute:\n" \
+                  "\tgem uninstall #{spec.name} --install-dir=#{spec.installation_path}")
+          end
         end
       end
     end

data/lib/rubygems/commands/unpack_command.rb

@@ -38,6 +38,7 @@ class Gem::Commands::UnpackCommand < Gem::Command
   def execute
     gemname = get_one_gem_name
     path = get_path(gemname, options[:version])
+
     if path then
       basename = File.basename(path).sub(/\.gem$/, '')
       target_dir = File.expand_path File.join(options[:target], basename)
@@ -66,16 +67,27 @@ class Gem::Commands::UnpackCommand < Gem::Command
   # source directories?
   def get_path(gemname, version_req)
     return gemname if gemname =~ /\.gem$/i
-    specs = Gem::SourceIndex.from_installed_gems.search(/\A#{gemname}\z/, version_req)
+
+    specs = Gem::source_index.search(/\A#{gemname}\z/, version_req)
+
     selected = specs.sort_by { |s| s.version }.last
+
     return nil if selected.nil?
+
     # We expect to find (basename).gem in the 'cache' directory.
     # Furthermore, the name match must be exact (ignoring case).
     if gemname =~ /^#{selected.name}$/i
       filename = selected.full_name + '.gem'
-      return File.join(Gem.dir, 'cache', filename)
+      path = nil
+
+      Gem.path.find do |gem_dir|
+        path = File.join gem_dir, 'cache', filename
+        File.exist? path
+      end
+
+      path
     else
-      return nil
+      nil
     end
   end
 

data/lib/rubygems/commands/update_command.rb

@@ -1,8 +1,10 @@
 require 'rubygems/command'
+require 'rubygems/command_manager'
 require 'rubygems/install_update_options'
 require 'rubygems/local_remote_options'
 require 'rubygems/source_info_cache'
 require 'rubygems/version_option'
+require 'rubygems/commands/install_command'
 
 class Gem::Commands::UpdateCommand < Gem::Command
 
@@ -45,7 +47,7 @@ class Gem::Commands::UpdateCommand < Gem::Command
 
   def execute
     if options[:system] then
-      say "Updating RubyGems..."
+      say "Updating RubyGems"
 
       unless options[:args].empty? then
         fail "No gem names are allowed with the --system option"
@@ -53,10 +55,10 @@ class Gem::Commands::UpdateCommand < Gem::Command
 
       options[:args] = ["rubygems-update"]
     else
-      say "Updating installed gems..."
+      say "Updating installed gems"
     end
 
-    hig = highest_installed_gems = {}
+    hig = {}
 
     Gem::SourceIndex.from_installed_gems.each do |name, spec|
       if hig[spec.name].nil? or hig[spec.name].version < spec.version then
@@ -64,25 +66,28 @@ class Gem::Commands::UpdateCommand < Gem::Command
       end
     end
 
-    remote_gemspecs = Gem::SourceInfoCache.search(//)
+    pattern = if options[:args].empty? then
+             //
+              else
+                Regexp.union(*options[:args])
+              end
 
-    gems_to_update = if options[:args].empty? then
-                       which_to_update(highest_installed_gems, remote_gemspecs)
-                     else
-                       options[:args]
-                     end
+    remote_gemspecs = Gem::SourceInfoCache.search pattern
 
-    options[:domain] = :remote # install from remote source
+    gems_to_update = which_to_update hig, remote_gemspecs
 
-    # HACK use the real API
-    install_command = Gem::CommandManager.instance['install']
+    updated = []
 
+    # HACK use the real API
     gems_to_update.uniq.sort.each do |name|
-      say "Attempting remote update of #{name}"
-      options[:args] = [name]
-      options[:ignore_dependencies] = true # HACK skip seen gems instead
-      install_command.merge_options(options)
-      install_command.execute
+      next if updated.any? { |spec| spec.name == name }
+      say "Updating #{name}"
+      installer = Gem::DependencyInstaller.new options
+      installer.install name
+      installer.installed_gems.each do |spec|
+        updated << spec
+        say "Successfully installed #{spec.full_name}"
+      end
     end
 
     if gems_to_update.include? "rubygems-update" then
@@ -97,12 +102,10 @@ class Gem::Commands::UpdateCommand < Gem::Command
 
       say "RubyGems system software updated" if installed
     else
-      updated = gems_to_update.uniq.sort.collect { |g| g.to_s }
-
       if updated.empty? then
         say "Nothing to update"
       else
-        say "Gems updated: #{updated.join ', '}"
+        say "Gems updated: #{updated.map { |spec| spec.name }.join ', '}"
       end
     end
   end
@@ -122,11 +125,10 @@ class Gem::Commands::UpdateCommand < Gem::Command
       setup_cmd = "#{Gem.ruby} setup.rb #{args.join ' '}"
 
       # Make sure old rubygems isn't loaded
-      if Gem.win_platform? then
-        system "set RUBYOPT= & #{setup_cmd}"
-      else
-        system "RUBYOPT=\"\" #{setup_cmd}"
-      end
+      old = ENV["RUBYOPT"]
+      ENV.delete("RUBYOPT")
+      system setup_cmd
+      ENV["RUBYOPT"] = old if old
     end
   end
 

data/lib/rubygems/custom_require.rb

@@ -28,7 +28,7 @@ module Kernel
   rescue LoadError => load_error
     if load_error.message =~ /\A[Nn]o such file to load -- #{Regexp.escape path}\z/ and
        spec = Gem.searcher.find(path) then
-      Gem.activate(spec.name, false, "= #{spec.version}")
+      Gem.activate(spec.name, "= #{spec.version}")
       gem_original_require path
     else
       raise load_error

data/lib/rubygems/defaults.rb

@@ -11,6 +11,9 @@ module Gem
     if defined? RUBY_FRAMEWORK_VERSION then
       File.join File.dirname(ConfigMap[:sitedir]), 'Gems',
                 ConfigMap[:ruby_version]
+    elsif defined? RUBY_ENGINE then
+      File.join ConfigMap[:libdir], RUBY_ENGINE, 'gems',
+                ConfigMap[:ruby_version]
     else
       File.join ConfigMap[:libdir], 'ruby', 'gems', ConfigMap[:ruby_version]
     end
@@ -29,7 +32,11 @@ module Gem
 
   # The default directory for binaries
   def self.default_bindir
-    Config::CONFIG['bindir']
+    if defined? RUBY_FRAMEWORK_VERSION then # mac framework support
+      '/usr/bin'
+    else # generic install
+      ConfigMap[:bindir]
+    end
   end
 
   # The default system-wide source info cache directory.

data/lib/rubygems/dependency_installer.rb

@@ -22,8 +22,7 @@ class Gem::DependencyInstaller
   }
 
   ##
-  # Creates a new installer instance that will install +gem_name+ using
-  # version requirement +version+ and +options+.
+  # Creates a new installer instance.
   #
   # Options are:
   # :env_shebang:: See Gem::Installer::new.
@@ -36,7 +35,7 @@ class Gem::DependencyInstaller
   # :install_dir: See Gem::Installer#install.
   # :security_policy: See Gem::Installer::new and Gem::Security.
   # :wrappers: See Gem::Installer::new
-  def initialize(gem_name, version = nil, options = {})
+  def initialize(options = {})
     options = DEFAULT_OPTIONS.merge options
     @env_shebang = options[:env_shebang]
     @domain = options[:domain]
@@ -46,49 +45,9 @@ class Gem::DependencyInstaller
     @install_dir = options[:install_dir] || Gem.dir
     @security_policy = options[:security_policy]
     @wrappers = options[:wrappers]
+    @bin_dir = options[:bin_dir]
 
     @installed_gems = []
-
-    spec_and_source = nil
-
-    glob = if File::ALT_SEPARATOR then
-             gem_name.gsub File::ALT_SEPARATOR, File::SEPARATOR
-           else
-             gem_name
-           end
-
-    local_gems = Dir["#{glob}*"].sort.reverse
-
-    unless local_gems.empty? then
-      local_gems.each do |gem_file|
-        next unless gem_file =~ /gem$/
-        begin
-          spec = Gem::Format.from_file_by_path(gem_file).spec
-          spec_and_source = [spec, gem_file]
-          break
-        rescue SystemCallError, Gem::Package::FormatError
-        end
-      end
-    end
-
-    if spec_and_source.nil? then
-      version ||= Gem::Requirement.default
-      @dep = Gem::Dependency.new gem_name, version
-      spec_and_sources = find_gems_with_sources(@dep).reverse
-
-      spec_and_source = spec_and_sources.find do |spec, source|
-        Gem::Platform.match spec.platform
-      end
-    end
-
-    if spec_and_source.nil? then
-      raise Gem::GemNotFoundException,
-        "could not find #{gem_name} locally or in a repository"
-    end
-
-    @specs_and_sources = [spec_and_source]
-
-    gather_dependencies
   end
 
   ##
@@ -107,71 +66,30 @@ class Gem::DependencyInstaller
     end
 
     if @domain == :both or @domain == :remote then
-      gems_and_sources.push(*Gem::SourceInfoCache.search_with_source(dep, true))
-    end
-
-    gems_and_sources.sort_by do |gem, source|
-      [gem, source !~ /^http:\/\// ? 1 : 0] # local gems win
-    end
-  end
-
-  ##
-  # Moves the gem +spec+ from +source_uri+ to the cache dir unless it is
-  # already there.  If the source_uri is local the gem cache dir copy is
-  # always replaced.
-  def download(spec, source_uri)
-    gem_file_name = "#{spec.full_name}.gem"
-    local_gem_path = File.join @install_dir, 'cache', gem_file_name
-
-    Gem.ensure_gem_subdirectories @install_dir
-
-    source_uri = URI.parse source_uri unless URI::Generic === source_uri
-    scheme = source_uri.scheme
-
-    # URI.parse gets confused by MS Windows paths with forward slashes.
-    scheme = nil if scheme =~ /^[a-z]$/i
-
-    case scheme
-    when 'http' then
-      unless File.exist? local_gem_path then
-        begin
-          say "Downloading gem #{gem_file_name}" if
-            Gem.configuration.really_verbose
-
-          remote_gem_path = source_uri + "gems/#{gem_file_name}"
-
-          gem = Gem::RemoteFetcher.fetcher.fetch_path remote_gem_path
-        rescue Gem::RemoteFetcher::FetchError
-          raise if spec.original_platform == spec.platform
-
-          alternate_name = "#{spec.name}-#{spec.version}-#{spec.original_platform}.gem"
+      begin
+        requirements = dep.version_requirements.requirements.map do |req, ver|
+          req
+        end
 
-          say "Failed, downloading gem #{alternate_name}" if
-            Gem.configuration.really_verbose
+        all = requirements.length > 1 ||
+                requirements.first != ">=" || requirements.first != ">"
 
-          remote_gem_path = source_uri + "gems/#{alternate_name}"
+        found = Gem::SourceInfoCache.search_with_source dep, true, all
 
-          gem = Gem::RemoteFetcher.fetcher.fetch_path remote_gem_path
-        end
+        gems_and_sources.push(*found)
 
-        File.open local_gem_path, 'wb' do |fp|
-          fp.write gem
+      rescue Gem::RemoteFetcher::FetchError => e
+        if Gem.configuration.really_verbose then
+          say "Error fetching remote data:\t\t#{e.message}"
+          say "Falling back to local-only install"
         end
+        @domain = :local
       end
-    when nil, 'file' then # TODO test for local overriding cache
-      begin
-        FileUtils.cp source_uri.to_s, local_gem_path
-      rescue Errno::EACCES
-        local_gem_path = source_uri.to_s
-      end
-
-      say "Using local gem #{local_gem_path}" if
-        Gem.configuration.really_verbose
-    else
-      raise Gem::InstallError, "unsupported URI scheme #{source_uri.scheme}"
     end
 
-    local_gem_path
+    gems_and_sources.sort_by do |gem, source|
+      [gem, source =~ /^http:\/\// ? 0 : 1] # local gems win
+    end
   end
 
   ##
@@ -208,9 +126,57 @@ class Gem::DependencyInstaller
     @gems_to_install = dependency_list.dependency_order.reverse
   end
 
+  def find_spec_by_name_and_version gem_name, version = Gem::Requirement.default
+    spec_and_source = nil
+
+    glob = if File::ALT_SEPARATOR then
+             gem_name.gsub File::ALT_SEPARATOR, File::SEPARATOR
+           else
+             gem_name
+           end
+
+    local_gems = Dir["#{glob}*"].sort.reverse
+
+    unless local_gems.empty? then
+      local_gems.each do |gem_file|
+        next unless gem_file =~ /gem$/
+        begin
+          spec = Gem::Format.from_file_by_path(gem_file).spec
+          spec_and_source = [spec, gem_file]
+          break
+        rescue SystemCallError, Gem::Package::FormatError
+        end
+      end
+    end
+
+    if spec_and_source.nil? then
+      dep = Gem::Dependency.new gem_name, version
+      spec_and_sources = find_gems_with_sources(dep).reverse
+
+      spec_and_source = spec_and_sources.find { |spec, source|
+        Gem::Platform.match spec.platform
+      }
+    end
+
+    if spec_and_source.nil? then
+      raise Gem::GemNotFoundException,
+        "could not find #{gem_name} locally or in a repository"
+    end
+
+    @specs_and_sources = [spec_and_source]
+  end
+
   ##
   # Installs the gem and all its dependencies.
-  def install
+  def install dep_or_name, version = Gem::Requirement.default
+    if String === dep_or_name then
+      find_spec_by_name_and_version dep_or_name, version
+    else
+      @specs_and_sources = [find_gems_with_sources(dep_or_name).last]
+    end
+
+    gather_dependencies
+
     spec_dir = File.join @install_dir, 'specifications'
     source_index = Gem::SourceIndex.from_gems_in spec_dir
 
@@ -219,10 +185,11 @@ class Gem::DependencyInstaller
       # HACK is this test for full_name acceptable?
       next if source_index.any? { |n,_| n == spec.full_name } and not last
 
+      # TODO: make this sorta_verbose so other users can benefit from it
       say "Installing gem #{spec.full_name}" if Gem.configuration.really_verbose
 
       _, source_uri = @specs_and_sources.assoc spec
-      local_gem_path = download spec, source_uri
+      local_gem_path = Gem::RemoteFetcher.fetcher.download spec, source_uri
 
       inst = Gem::Installer.new local_gem_path,
                                 :env_shebang => @env_shebang,
@@ -231,7 +198,8 @@ class Gem::DependencyInstaller
                                 :ignore_dependencies => @ignore_dependencies,
                                 :install_dir => @install_dir,
                                 :security_policy => @security_policy,
-                                :wrappers => @wrappers
+                                :wrappers => @wrappers,
+                                :bin_dir => @bin_dir
 
       spec = inst.install