rubygems-update 1.1.1 → 1.2.0

data/lib/rubygems/commands/sources_command.rb

@@ -1,7 +1,8 @@
+require 'fileutils'
 require 'rubygems/command'
 require 'rubygems/remote_fetcher'
 require 'rubygems/source_info_cache'
-require 'rubygems/source_info_cache_entry'
+require 'rubygems/spec_fetcher'
 
 class Gem::Commands::SourcesCommand < Gem::Command
 
@@ -21,14 +22,14 @@ class Gem::Commands::SourcesCommand < Gem::Command
       options[:remove] = value
     end
 
-    add_option '-u', '--update', 'Update source cache' do |value, options|
-      options[:update] = value
-    end
-
     add_option '-c', '--clear-all',
                'Remove all sources (clear the cache)' do |value, options|
       options[:clear_all] = value
     end
+
+    add_option '-u', '--update', 'Update source cache' do |value, options|
+      options[:update] = value
+    end
   end
 
   def defaults_str
@@ -36,9 +37,23 @@ class Gem::Commands::SourcesCommand < Gem::Command
   end
 
   def execute
-    options[:list] = !(options[:add] || options[:remove] || options[:clear_all] || options[:update])
+    options[:list] = !(options[:add] ||
+                       options[:clear_all] ||
+                       options[:remove] ||
+                       options[:update])
 
     if options[:clear_all] then
+      path = Gem::SpecFetcher.fetcher.dir
+      FileUtils.rm_rf path
+
+      if not File.exist?(path) then
+        say "*** Removed specs cache ***"
+      elsif not File.writable?(path) then
+        say "*** Unable to remove source cache (write protected) ***"
+      else
+        say "*** Unable to remove source cache ***"
+      end
+
       sic = Gem::SourceInfoCache
       remove_cache_file 'user',          sic.user_cache_file
       remove_cache_file 'latest user',   sic.latest_user_cache_file
@@ -48,15 +63,10 @@ class Gem::Commands::SourcesCommand < Gem::Command
 
     if options[:add] then
       source_uri = options[:add]
+      uri = URI.parse source_uri
 
-      sice = Gem::SourceInfoCacheEntry.new nil, nil
       begin
-        sice.refresh source_uri, true
-
-        Gem::SourceInfoCache.cache_data[source_uri] = sice
-        Gem::SourceInfoCache.cache.update
-        Gem::SourceInfoCache.cache.flush
-
+        Gem::SpecFetcher.fetcher.load_specs uri, 'specs'
         Gem.sources << source_uri
         Gem.configuration.write
 
@@ -64,15 +74,24 @@ class Gem::Commands::SourcesCommand < Gem::Command
       rescue URI::Error, ArgumentError
         say "#{source_uri} is not a URI"
       rescue Gem::RemoteFetcher::FetchError => e
-        say "Error fetching #{source_uri}:\n\t#{e.message}"
-      end
-    end
+        yaml_uri = uri + 'yaml'
+        gem_repo = Gem::RemoteFetcher.fetcher.fetch_size yaml_uri rescue false
 
-    if options[:update] then
-      Gem::SourceInfoCache.cache true
-      Gem::SourceInfoCache.cache.flush
+        if e.uri =~ /specs\.#{Regexp.escape Gem.marshal_version}\.gz$/ and
+           gem_repo then
 
-      say "source cache successfully updated"
+          alert_warning <<-EOF
+RubyGems 1.2+ index not found for:
+\t#{source_uri}
+
+Will cause RubyGems to revert to legacy indexes, degrading performance.
+          EOF
+
+          say "#{source_uri} added to sources"
+        else
+          say "Error fetching #{source_uri}:\n\t#{e.message}"
+        end
+      end
     end
 
     if options[:remove] then
@@ -81,14 +100,6 @@ 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
         Gem.sources.delete source_uri
         Gem.configuration.write
 
@@ -96,6 +107,23 @@ class Gem::Commands::SourcesCommand < Gem::Command
       end
     end
 
+    if options[:update] then
+      fetcher = Gem::SpecFetcher.fetcher
+
+      if fetcher.legacy_repos.empty? then
+        Gem.sources.each do |update_uri|
+          update_uri = URI.parse update_uri
+          fetcher.load_specs update_uri, 'specs'
+          fetcher.load_specs update_uri, 'latest_specs'
+        end
+      else
+        Gem::SourceInfoCache.cache true
+        Gem::SourceInfoCache.cache.flush
+      end
+
+      say "source cache successfully updated"
+    end
+
     if options[:list] then
       say "*** CURRENT SOURCES ***"
       say

data/lib/rubygems/commands/specification_command.rb

@@ -52,9 +52,10 @@ class Gem::Commands::SpecificationCommand < Gem::Command
     end
 
     if remote? then
-      Gem::SourceInfoCache.cache_data.each do |_,sice|
-        specs.push(*sice.source_index.search(gem, options[:version]))
-      end
+      dep = Gem::Dependency.new gem, options[:version]
+      found = Gem::SpecFetcher.fetcher.fetch dep
+
+      specs.push(*found.map { |spec,| spec })
     end
 
     if specs.empty? then

data/lib/rubygems/commands/stale_command.rb

@@ -0,0 +1,27 @@
+require 'rubygems/command'
+
+class Gem::Commands::StaleCommand < Gem::Command
+  def initialize
+    super('stale', 'List gems along with access times')
+  end
+
+  def usage # :nodoc:
+    "#{program_name}"
+  end
+
+  def execute
+    gem_to_atime = {}
+    Gem.source_index.each do |name, spec|
+      Dir["#{spec.full_gem_path}/**/*.*"].each do |file|
+        next if File.directory?(file)
+        stat = File.stat(file)
+        gem_to_atime[name] ||= stat.atime
+        gem_to_atime[name] = stat.atime if gem_to_atime[name] < stat.atime
+      end
+    end
+
+    gem_to_atime.sort_by { |_, atime| atime }.each do |name, atime|
+      say "#{name} at #{atime.strftime '%c'}"
+    end
+  end
+end

data/lib/rubygems/commands/update_command.rb

@@ -2,7 +2,7 @@ require 'rubygems/command'
 require 'rubygems/command_manager'
 require 'rubygems/install_update_options'
 require 'rubygems/local_remote_options'
-require 'rubygems/source_info_cache'
+require 'rubygems/spec_fetcher'
 require 'rubygems/version_option'
 require 'rubygems/commands/install_command'
 
@@ -15,11 +15,10 @@ class Gem::Commands::UpdateCommand < Gem::Command
   def initialize
     super 'update',
           'Update the named gems (or all installed gems) in the local repository',
-      :generate_rdoc => true, 
-      :generate_ri => true, 
-      :force => false, 
-      :test => false,
-      :install_dir => Gem.dir
+      :generate_rdoc => true,
+      :generate_ri => true,
+      :force => false,
+      :test => false
 
     add_install_update_options
 
@@ -60,21 +59,13 @@ class Gem::Commands::UpdateCommand < Gem::Command
 
     hig = {} # highest installed gems
 
-    Gem::SourceIndex.from_installed_gems.each do |name, spec|
+    Gem.source_index.each do |name, spec|
       if hig[spec.name].nil? or hig[spec.name].version < spec.version then
         hig[spec.name] = spec
       end
     end
 
-    pattern = if options[:args].empty? then
-                //
-              else
-                Regexp.union(*options[:args])
-              end
-
-    remote_gemspecs = Gem::SourceInfoCache.search pattern
-
-    gems_to_update = which_to_update hig, remote_gemspecs
+    gems_to_update = which_to_update hig, options[:args]
 
     updated = []
 
@@ -135,20 +126,42 @@ class Gem::Commands::UpdateCommand < Gem::Command
     end
   end
 
-  def which_to_update(highest_installed_gems, remote_gemspecs)
+  def which_to_update(highest_installed_gems, gem_names)
     result = []
 
     highest_installed_gems.each do |l_name, l_spec|
-      matching_gems = remote_gemspecs.select do |spec|
-        spec.name == l_name and Gem.platforms.any? do |platform|
-          platform == spec.platform
+      next if not gem_names.empty? and
+              gem_names.all? { |name| /#{name}/ !~ l_spec.name }
+
+      dependency = Gem::Dependency.new l_spec.name, "> #{l_spec.version}"
+
+      begin
+        fetcher = Gem::SpecFetcher.fetcher
+        spec_tuples = fetcher.find_matching dependency
+      rescue Gem::RemoteFetcher::FetchError => e
+        raise unless fetcher.warn_legacy e do
+          require 'rubygems/source_info_cache'
+
+          dependency.name = '' if dependency.name == //
+
+          specs = Gem::SourceInfoCache.search_with_source dependency
+
+          spec_tuples = specs.map do |spec, source_uri|
+            [[spec.name, spec.version, spec.original_platform], source_uri]
+          end
         end
       end
 
-      highest_remote_gem = matching_gems.sort_by { |spec| spec.version }.last
+      matching_gems = spec_tuples.select do |(name, version, platform),|
+        name == l_name and Gem::Platform.match platform
+      end
+
+      highest_remote_gem = matching_gems.sort_by do |(name, version),|
+        version
+      end.last
 
       if highest_remote_gem and
-         l_spec.version < highest_remote_gem.version then
+         l_spec.version < highest_remote_gem.first[1] then
         result << l_name
       end
     end

data/lib/rubygems/config_file.rb

@@ -18,6 +18,22 @@ class Gem::ConfigFile
   DEFAULT_VERBOSITY = true
   DEFAULT_UPDATE_SOURCES = true
 
+  system_config_path = 
+    begin
+      require 'Win32API'
+
+      CSIDL_COMMON_APPDATA = 0x0023
+      path = 0.chr * 260
+      SHGetFolderPath = Win32API.new 'shell32', 'SHGetFolderPath', 'LLLLP', 'L'
+      SHGetFolderPath.call 0, CSIDL_COMMON_APPDATA, 0, 1, path
+
+      path.strip
+    rescue LoadError
+      '/etc'
+    end
+
+  SYSTEM_WIDE_CONFIG_FILE = File.join system_config_path, 'gemrc'
+  
   # List of arguments supplied to the config file object.
   attr_reader :args
 
@@ -63,6 +79,7 @@ class Gem::ConfigFile
     arg_list = arg_list.map do |arg|
       if need_config_file_name then
         @config_file_name = arg
+        need_config_file_name = false
         nil
       elsif arg =~ /^--config-file=(.*)/ then
         @config_file_name = $1
@@ -81,18 +98,8 @@ class Gem::ConfigFile
     @verbose = DEFAULT_VERBOSITY
     @update_sources = DEFAULT_UPDATE_SOURCES
 
-    begin
-      # HACK $SAFE ok?
-      @hash = open(config_file_name.dup.untaint) {|f| YAML.load(f) }
-    rescue ArgumentError
-      warn "Failed to load #{config_file_name}"
-    rescue Errno::ENOENT
-      # Ignore missing config file error.
-    rescue Errno::EACCES
-      warn "Failed to load #{config_file_name} due to permissions problem."
-    end
-
-    @hash ||= {}
+    @hash = load_file(SYSTEM_WIDE_CONFIG_FILE)
+    @hash.merge!(load_file(config_file_name.dup.untaint))
 
     # HACK these override command-line args, which is bad
     @backtrace = @hash[:backtrace] if @hash.key? :backtrace
@@ -105,6 +112,16 @@ class Gem::ConfigFile
     handle_arguments arg_list
   end
 
+  def load_file(filename)
+    begin
+      YAML.load(File.read(filename)) if filename and File.exist?(filename)
+    rescue ArgumentError
+      warn "Failed to load #{config_file_name}"
+    rescue Errno::EACCES
+      warn "Failed to load #{config_file_name} due to permissions problem."
+    end or {}
+  end
+
   # True if the backtrace option has been specified, or debug is on.
   def backtrace
     @backtrace or $DEBUG

data/lib/rubygems/custom_require.rb

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

data/lib/rubygems/defaults.rb

@@ -2,7 +2,7 @@ module Gem
 
   # An Array of the default sources that come with RubyGems.
   def self.default_sources
-    %w[http://gems.rubyforge.org]
+    %w[http://gems.rubyforge.org/]
   end
 
   # Default home directory path to be used if an alternate value is not

data/lib/rubygems/dependency.rb

@@ -8,24 +8,54 @@ require 'rubygems'
 
 ##
 # The Dependency class holds a Gem name and a Gem::Requirement
+
 class Gem::Dependency
 
+  ##
+  # Valid dependency types.
+  #--
+  # When this list is updated, be sure to change
+  # Gem::Specification::CURRENT_SPECIFICATION_VERSION as well.
+
+  TYPES = [
+    :development,
+    :runtime,
+  ]
+
+  ##
+  # Dependency name or regular expression.
+
   attr_accessor :name
 
+  ##
+  # Dependency type.
+
+  attr_reader :type
+
+  ##
+  # Dependent versions.
+
   attr_writer :version_requirements
 
+  ##
+  # Orders dependencies by name only.
+
   def <=>(other)
     [@name] <=> [other.name]
   end
 
   ##
-  # Constructs the dependency
-  #
-  # name:: [String] name of the Gem
-  # version_requirements:: [String Array] version requirement (e.g. ["> 1.2"])
-  #
-  def initialize(name, version_requirements)
+  # Constructs a dependency with +name+ and +requirements+.
+
+  def initialize(name, version_requirements, type=:runtime)
     @name = name
+
+    unless TYPES.include? type
+      raise ArgumentError, "Valid types are #{TYPES.inspect}, not #{@type.inspect}"
+    end
+
+    @type = type
+
     @version_requirements = Gem::Requirement.create version_requirements
     @version_requirement = nil   # Avoid warnings.
   end
@@ -48,17 +78,41 @@ class Gem::Dependency
   end
 
   def to_s # :nodoc:
-    "#{name} (#{version_requirements})"
+    "#{name} (#{version_requirements}, #{@type || :runtime})"
   end
 
   def ==(other) # :nodoc:
     self.class === other &&
       self.name == other.name &&
+      self.type == other.type &&
       self.version_requirements == other.version_requirements
   end
 
-  def hash
-    name.hash + version_requirements.hash
+  ##
+  # Uses this dependency as a pattern to compare to the dependency +other+.
+  # This dependency will match if the name matches the other's name, and other
+  # has only an equal version requirement that satisfies this dependency.
+
+  def =~(other)
+    return false unless self.class === other
+
+    pattern = @name
+    pattern = /\A#{@name}\Z/ unless Regexp === pattern
+
+    return false unless pattern =~ other.name
+
+    reqs = other.version_requirements.requirements
+
+    return false unless reqs.length == 1
+    return false unless reqs.first.first == '='
+
+    version = reqs.first.last
+
+    version_requirements.satisfied_by? version
+  end
+
+  def hash # :nodoc:
+    name.hash + type.hash + version_requirements.hash
   end
 
 end