rubygems-update 1.1.1 → 1.2.0

data/lib/rubygems/source_index.rb

@@ -7,6 +7,7 @@
 require 'rubygems'
 require 'rubygems/user_interaction'
 require 'rubygems/specification'
+require 'rubygems/spec_fetcher'
 
 ##
 # The SourceIndex object indexes all the gems available from a
@@ -27,6 +28,11 @@ class Gem::SourceIndex
 
   attr_reader :gems # :nodoc:
 
+  ##
+  # Directories to use to refresh this SourceIndex when calling refresh!
+
+  attr_accessor :spec_dirs
+
   class << self
     include Gem::UserInteraction
 
@@ -39,7 +45,7 @@ class Gem::SourceIndex
     #   +from_gems_in+.  This argument is deprecated and is provided
     #   just for backwards compatibility, and should not generally
     #   be used.
-    # 
+    #
     # return::
     #   SourceIndex instance
 
@@ -63,7 +69,9 @@ class Gem::SourceIndex
     # +spec_dirs+.
 
     def from_gems_in(*spec_dirs)
-      self.new.load_gems_in(*spec_dirs)
+      source_index = new
+      source_index.spec_dirs = spec_dirs
+      source_index.refresh!
     end
 
     ##
@@ -79,6 +87,8 @@ class Gem::SourceIndex
           return gemspec
         end
         alert_warning "File '#{file_name}' does not evaluate to a gem specification"
+      rescue SignalException, SystemExit
+        raise
       rescue SyntaxError => e
         alert_warning e
         alert_warning spec_code
@@ -100,6 +110,7 @@ class Gem::SourceIndex
 
   def initialize(specifications={})
     @gems = specifications
+    @spec_dirs = nil
   end
 
   ##
@@ -121,8 +132,8 @@ class Gem::SourceIndex
   end
 
   ##
-  # Returns a Hash of name => Specification of the latest versions of each
-  # gem in this index.
+  # Returns an Array specifications for the latest versions of each gem in
+  # this index.
 
   def latest_specs
     result = Hash.new { |h,k| h[k] = [] }
@@ -241,7 +252,9 @@ class Gem::SourceIndex
     when Gem::Dependency then
       only_platform = platform_only
       version_requirement = gem_pattern.version_requirements
-      gem_pattern = if gem_pattern.name.empty? then
+      gem_pattern = if Regexp === gem_pattern.name then
+                      gem_pattern.name
+                    elsif gem_pattern.name.empty? then
                       //
                     else
                       /^#{Regexp.escape gem_pattern.name}$/
@@ -271,29 +284,41 @@ class Gem::SourceIndex
 
   ##
   # Replaces the gems in the source index from specifications in the
-  # installed_spec_directories,
+  # directories this source index was created from.  Raises an exception if
+  # this source index wasn't created from a directory (via from_gems_in or
+  # from_installed_gems, or having spec_dirs set).
 
   def refresh!
-    load_gems_in(*self.class.installed_spec_directories)
+    raise 'source index not created from disk' if @spec_dirs.nil?
+    load_gems_in(*@spec_dirs)
   end
 
   ##
   # Returns an Array of Gem::Specifications that are not up to date.
 
   def outdated
-    dep = Gem::Dependency.new '', Gem::Requirement.default
-
-    remotes = Gem::SourceInfoCache.search dep, true
-
     outdateds = []
 
     latest_specs.each do |local|
-      name = local.name
-      remote = remotes.select { |spec| spec.name == name }.
-        sort_by { |spec| spec.version.to_ints }.
-        last
+      dependency = Gem::Dependency.new local.name, ">= #{local.version}"
+
+      begin
+        fetcher = Gem::SpecFetcher.fetcher
+        remotes = fetcher.find_matching dependency
+        remotes = remotes.map { |(name, version,_),_| version }
+      rescue Gem::RemoteFetcher::FetchError => e
+        raise unless fetcher.warn_legacy e do
+          require 'rubygems/source_info_cache'
+
+          specs = Gem::SourceInfoCache.search_with_source dependency, true
+
+          remotes = specs.map { |spec,| spec.version }
+        end
+      end
+
+      latest = remotes.sort.last
 
-      outdateds << name if remote and local.version < remote.version
+      outdateds << local.name if latest and local.version < latest
     end
 
     outdateds
@@ -387,7 +412,8 @@ class Gem::SourceIndex
   end
 
   def fetch_bulk_index(source_uri)
-    say "Bulk updating Gem source index for: #{source_uri}"
+    say "Bulk updating Gem source index for: #{source_uri}" if
+      Gem.configuration.verbose
 
     index = fetch_index_from(source_uri)
     if index.nil? then
@@ -447,7 +473,7 @@ class Gem::SourceIndex
 
   def unzip(string)
     require 'zlib'
-    Zlib::Inflate.inflate(string)
+    Gem.inflate string
   end
 
   ##

data/lib/rubygems/source_info_cache.rb

@@ -8,7 +8,7 @@ require 'rubygems/user_interaction'
 # SourceInfoCache stores a copy of the gem index for each gem source.
 #
 # There are two possible cache locations, the system cache and the user cache:
-# * The system cache is prefered if it is writable or can be created.
+# * The system cache is preferred if it is writable or can be created.
 # * The user cache is used otherwise
 #
 # Once a cache is selected, it will be used for all operations.

data/lib/rubygems/spec_fetcher.rb

@@ -0,0 +1,251 @@
+require 'zlib'
+
+require 'rubygems'
+require 'rubygems/remote_fetcher'
+require 'rubygems/user_interaction'
+
+##
+# SpecFetcher handles metadata updates from remote gem repositories.
+
+class Gem::SpecFetcher
+
+  include Gem::UserInteraction
+
+  ##
+  # The SpecFetcher cache dir.
+
+  attr_reader :dir # :nodoc:
+
+  ##
+  # Cache of latest specs
+
+  attr_reader :latest_specs # :nodoc:
+
+  ##
+  # Cache of all spces
+
+  attr_reader :specs # :nodoc:
+
+  @fetcher = nil
+
+  def self.fetcher
+    @fetcher ||= new
+  end
+
+  def self.fetcher=(fetcher) # :nodoc:
+    @fetcher = fetcher
+  end
+
+  def initialize
+    @dir = File.join Gem.user_home, '.gem', 'specs'
+    @update_cache = File.stat(Gem.user_home).uid == Process.uid
+
+    @specs = {}
+    @latest_specs = {}
+
+    @fetcher = Gem::RemoteFetcher.fetcher
+  end
+
+  ##
+  # Retuns the local directory to write +uri+ to.
+
+  def cache_dir(uri)
+    File.join @dir, "#{uri.host}%#{uri.port}", File.dirname(uri.path)
+  end
+
+  ##
+  # Fetch specs matching +dependency+.  If +all+ is true, all matching
+  # versions are returned.  If +matching_platform+ is false, all platforms are
+  # returned.
+
+  def fetch(dependency, all = false, matching_platform = true)
+    specs_and_sources = find_matching dependency, all, matching_platform
+
+    specs_and_sources.map do |spec_tuple, source_uri|
+      [fetch_spec(spec_tuple, URI.parse(source_uri)), source_uri]
+    end
+
+  rescue Gem::RemoteFetcher::FetchError => e
+    raise unless warn_legacy e do
+      require 'rubygems/source_info_cache'
+
+      return Gem::SourceInfoCache.search_with_source(dependency,
+                                                     matching_platform, all)
+    end
+  end
+
+  def fetch_spec(spec, source_uri)
+    spec = spec - [nil, 'ruby', '']
+    spec_file_name = "#{spec.join '-'}.gemspec"
+
+    uri = source_uri + "#{Gem::MARSHAL_SPEC_DIR}#{spec_file_name}"
+
+    cache_dir = cache_dir uri
+
+    local_spec = File.join cache_dir, spec_file_name
+
+    if File.exist? local_spec then
+      spec = Gem.read_binary local_spec
+    else
+      uri.path << '.rz'
+
+      spec = @fetcher.fetch_path uri
+      spec = Gem.inflate spec
+
+      if @update_cache then
+        FileUtils.mkdir_p cache_dir
+
+        open local_spec, 'wb' do |io|
+          io.write spec
+        end
+      end
+    end
+
+    # TODO: Investigate setting Gem::Specification#loaded_from to a URI
+    Marshal.load spec
+  end
+
+  ##
+  # Find spec names that match +dependency+.  If +all+ is true, all matching
+  # versions are returned.  If +matching_platform+ is false, gems for all
+  # platforms are returned.
+
+  def find_matching(dependency, all = false, matching_platform = true)
+    found = {}
+
+    list(all).each do |source_uri, specs|
+      found[source_uri] = specs.select do |spec_name, version, spec_platform|
+        dependency =~ Gem::Dependency.new(spec_name, version) and
+          (not matching_platform or Gem::Platform.match(spec_platform))
+      end
+    end
+
+    specs_and_sources = []
+
+    found.each do |source_uri, specs|
+      uri_str = source_uri.to_s
+      specs_and_sources.push(*specs.map { |spec| [spec, uri_str] })
+    end
+
+    specs_and_sources
+  end
+
+  ##
+  # Returns Array of gem repositories that were generated with RubyGems less
+  # than 1.2.
+
+  def legacy_repos
+    Gem.sources.reject do |source_uri|
+      source_uri = URI.parse source_uri
+      spec_path = source_uri + "specs.#{Gem.marshal_version}.gz"
+
+      begin
+        @fetcher.fetch_size spec_path
+      rescue Gem::RemoteFetcher::FetchError
+        begin
+          @fetcher.fetch_size(source_uri + 'yaml') # re-raise if non-repo
+        rescue Gem::RemoteFetcher::FetchError
+          alert_error "#{source_uri} does not appear to be a repository"
+          raise
+        end
+        false
+      end
+    end
+  end
+
+  ##
+  # Returns a list of gems available for each source in Gem::sources.  If
+  # +all+ is true, all versions are returned instead of only latest versions.
+
+  def list(all = false)
+    list = {}
+
+    file = all ? 'specs' : 'latest_specs'
+
+    Gem.sources.each do |source_uri|
+      source_uri = URI.parse source_uri
+
+      if all and @specs.include? source_uri then
+        list[source_uri] = @specs[source_uri]
+      elsif @latest_specs.include? source_uri then
+        list[source_uri] = @latest_specs[source_uri]
+      else
+        specs = load_specs source_uri, file
+
+        cache = all ? @specs : @latest_specs
+
+        cache[source_uri] = specs
+        list[source_uri] = specs
+      end
+    end
+
+    list
+  end
+
+  def load_specs(source_uri, file)
+    file_name = "#{file}.#{Gem.marshal_version}.gz"
+
+    spec_path = source_uri + file_name
+
+    cache_dir = cache_dir spec_path
+
+    local_file = File.join(cache_dir, file_name).chomp '.gz'
+
+    if File.exist? local_file then
+      local_size = File.stat(local_file).size
+
+      remote_file = spec_path.dup
+      remote_file.path = remote_file.path.chomp '.gz'
+      remote_size = @fetcher.fetch_size remote_file
+
+      spec_dump = Gem.read_binary local_file if remote_size == local_size
+    end
+
+    unless spec_dump then
+      loaded = true
+
+      spec_dump_gz = @fetcher.fetch_path spec_path
+      spec_dump = Gem.gunzip spec_dump_gz
+    end
+
+    specs = Marshal.load spec_dump
+
+    if loaded and @update_cache then
+      begin
+        FileUtils.mkdir_p cache_dir
+
+        open local_file, 'wb' do |io|
+          Marshal.dump specs, io
+        end
+      rescue
+      end
+    end
+
+    specs
+  end
+
+  ##
+  # Warn about legacy repositories if +exception+ indicates only legacy
+  # repositories are available, and yield to the block.  Returns false if the
+  # exception indicates some other FetchError.
+
+  def warn_legacy(exception)
+    uri = exception.uri.to_s
+    if uri =~ /specs\.#{Regexp.escape Gem.marshal_version}\.gz$/ then
+      alert_warning <<-EOF
+RubyGems 1.2+ index not found for:
+\t#{legacy_repos.join "\n\t"}
+
+RubyGems will revert to legacy indexes degrading performance.
+      EOF
+
+      yield
+
+      return true
+    end
+
+    false
+  end
+
+end
+

data/lib/rubygems/specification.rb

@@ -6,6 +6,7 @@
 
 require 'rubygems'
 require 'rubygems/version'
+require 'rubygems/requirement'
 require 'rubygems/platform'
 
 # :stopdoc:
@@ -16,6 +17,9 @@ if RUBY_VERSION < '1.9' then
     t - ((t.to_f + t.gmt_offset) % 86400)
   end unless defined? Time.today
 end
+
+class Date; end # for ruby_code if date.rb wasn't required
+
 # :startdoc:
 
 module Gem
@@ -37,22 +41,34 @@ module Gem
   #
   class Specification
 
+    ##
     # Allows deinstallation of gems with legacy platforms.
+
     attr_accessor :original_platform # :nodoc:
 
-    # ------------------------- Specification version contstants.
+    # ------------------------- Specification version constants.
 
+    ##
     # The the version number of a specification that does not specify one
     # (i.e. RubyGems 0.7 or earlier).
+
     NONEXISTENT_SPECIFICATION_VERSION = -1
 
+    ##
     # The specification version applied to any new Specification instances
     # created.  This should be bumped whenever something in the spec format
     # changes.
+    #--
+    # When updating this number, be sure to also update #to_ruby.
+    #
+    # NOTE RubyGems < 1.2 cannot load specification versions > 2.
+
     CURRENT_SPECIFICATION_VERSION = 2
 
+    ##
     # An informal list of changes to the specification.  The highest-valued
     # key should be equal to the CURRENT_SPECIFICATION_VERSION.
+
     SPECIFICATION_VERSION_HISTORY = {
       -1 => ['(RubyGems versions up to and including 0.7 did not have versioned specifications)'],
       1  => [
@@ -231,10 +247,12 @@ module Gem
       }
     end
 
+    ##
     # Dump only crucial instance variables.
-    #
+    #--
     # MAINTAIN ORDER!
-    def _dump(limit) # :nodoc:
+
+    def _dump(limit)
       Marshal.dump [
         @rubygems_version,
         @specification_version,
@@ -256,7 +274,9 @@ module Gem
       ]
     end
 
+    ##
     # Load custom marshal format, re-initializing defaults as needed
+
     def self._load(str)
       array = Marshal.load str
 
@@ -265,9 +285,15 @@ module Gem
 
       current_version = CURRENT_SPECIFICATION_VERSION
 
-      field_count = MARSHAL_FIELDS[spec.specification_version]
+      field_count = if spec.specification_version > current_version then
+                      spec.instance_variable_set :@specification_version,
+                                                 current_version
+                      MARSHAL_FIELDS[current_version]
+                    else
+                      MARSHAL_FIELDS[spec.specification_version]
+                    end
 
-      if field_count.nil? or array.size < field_count then
+      if array.size < field_count then
         raise TypeError, "invalid Gem::Specification format #{array.inspect}"
       end
 
@@ -335,6 +361,14 @@ module Gem
 
     read_only :dependencies
 
+    def runtime_dependencies
+      dependencies.select { |d| d.type == :runtime || d.type == nil }
+    end
+
+    def development_dependencies
+      dependencies.select { |d| d.type == :development }
+    end
+
     # ALIASED gemspec attributes -------------------------------------
     
     attribute_alias_singular :executable,   :executables
@@ -629,27 +663,31 @@ module Gem
       end
     end
 
-    # Adds a dependency to this Gem.  For example,
+    # Adds a development dependency to this Gem.  For example,
+    #
+    #   spec.add_development_dependency('jabber4r', '> 0.1', '<= 0.5')
     #
-    #   spec.add_dependency('jabber4r', '> 0.1', '<= 0.5')
+    # Development dependencies aren't installed by default, and
+    # aren't activated when a gem is required.
     #
     # gem:: [String or Gem::Dependency] The Gem name/dependency.
     # requirements:: [default=">= 0"] The version requirements.
+    def add_development_dependency(gem, *requirements)
+      add_dependency_with_type(gem, :development, *requirements)
+    end
+
+    # Adds a runtime dependency to this Gem.  For example,
     #
-    def add_dependency(gem, *requirements)
-      requirements = if requirements.empty? then
-                       Gem::Requirement.default
-                     else
-                       requirements.flatten
-                     end
+    #   spec.add_runtime_dependency('jabber4r', '> 0.1', '<= 0.5')
+    #
+    # gem:: [String or Gem::Dependency] The Gem name/dependency.
+    # requirements:: [default=">= 0"] The version requirements.
+    def add_runtime_dependency(gem, *requirements)
+      add_dependency_with_type(gem, :runtime, *requirements)
+    end
 
-      unless gem.respond_to?(:name) && gem.respond_to?(:version_requirements)
-        gem = Dependency.new(gem, requirements)
-      end
+    alias add_dependency add_runtime_dependency
 
-      dependencies << gem
-    end
-    
     # Returns the full name (name-version) of this Gem.  Platform information
     # is included (name-version-platform) if it is specified (and not the
     # default Ruby platform).
@@ -673,30 +711,31 @@ module Gem
       end
     end
 
+    ##
     # The full path to the gem (install path + full name).
-    #
-    # return:: [String] the full gem path
-    #
+
     def full_gem_path
       path = File.join installation_path, 'gems', full_name
       return path if File.directory? path
       File.join installation_path, 'gems', original_name
     end
-    
+
+    ##
     # The default (generated) file name of the gem.
+
     def file_name
       full_name + ".gem"
     end
-    
-    # The root directory that the gem was installed into.
-    #
-    # return:: [String] the installation path
-    #
+
+    ##
+    # The directory that this gem was installed into.
+
     def installation_path
-      (File.dirname(@loaded_from).split(File::SEPARATOR)[0..-2]).
-        join(File::SEPARATOR)
+      path = File.dirname(@loaded_from).split(File::SEPARATOR)[0..-2]
+      path = path.join File::SEPARATOR
+      File.expand_path path
     end
-    
+
     # Checks if this Specification meets the requirement of the supplied
     # dependency.
     # 
@@ -778,9 +817,11 @@ module Gem
       self.platform = Gem::Platform.new @platform
     end
 
+    ##
     # Returns a Ruby code representation of this specification, such that it
     # can be eval'ed and reconstruct the same specification later.  Attributes
     # that still have their default values are omitted.
+
     def to_ruby
       mark_version
       result = []
@@ -792,8 +833,6 @@ module Gem
         result << "  s.platform = #{ruby_code original_platform}"
       end
       result << ""
-      result << "  s.specification_version = #{specification_version} if s.respond_to? :specification_version="
-      result << ""
       result << "  s.required_rubygems_version = #{ruby_code required_rubygems_version} if s.respond_to? :required_rubygems_version="
 
       handled = [
@@ -816,15 +855,42 @@ module Gem
         end
       end
 
-      result << "" unless dependencies.empty?
+      result << nil
+      result << "  if s.respond_to? :specification_version then"
+      result << "    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION"
+      result << "    s.specification_version = #{specification_version}"
+      result << nil
+
+      result << "    if current_version >= 3 then"
+
+      unless dependencies.empty? then
+        dependencies.each do |dep|
+          version_reqs_param = dep.requirements_list.inspect
+          dep.instance_variable_set :@type, :runtime if dep.type.nil? # HACK
+          result << "      s.add_#{dep.type}_dependency(%q<#{dep.name}>, #{version_reqs_param})"
+        end
+      end
+
+      result << "    else"
 
-      dependencies.each do |dep|
-        version_reqs_param = dep.requirements_list.inspect
-        result << "  s.add_dependency(%q<#{dep.name}>, #{version_reqs_param})"
+      unless dependencies.empty? then
+        dependencies.each do |dep|
+          version_reqs_param = dep.requirements_list.inspect
+          result << "      s.add_dependency(%q<#{dep.name}>, #{version_reqs_param})"
+        end
       end
 
+      result << '    end'
+
+      result << "  else"
+        dependencies.each do |dep|
+          version_reqs_param = dep.requirements_list.inspect
+          result << "    s.add_dependency(%q<#{dep.name}>, #{version_reqs_param})"
+        end
+      result << "  end"
+
       result << "end"
-      result << ""
+      result << nil
 
       result.join "\n"
     end
@@ -940,6 +1006,22 @@ module Gem
 
     private
 
+    def add_dependency_with_type(dependency, type, *requirements)
+      requirements = if requirements.empty? then
+                       Gem::Requirement.default
+                     else
+                       requirements.flatten
+                     end
+
+      unless dependency.respond_to?(:name) &&
+        dependency.respond_to?(:version_requirements)
+
+        dependency = Dependency.new(dependency, requirements, type)
+      end
+
+      dependencies << dependency
+    end
+
     def find_all_satisfiers(dep)
       Gem.source_index.each do |name,gem|
         if(gem.satisfies_requirement?(dep)) then