rubygems-update 1.8.30 → 2.0.0.preview2

data/lib/rubygems/defaults.rb

@@ -1,8 +1,8 @@
 module Gem
-
-  # TODO: move this whole file back into rubygems.rb
+  DEFAULT_HOST = "https://rubygems.org"
 
   @post_install_hooks   ||= []
+  @done_installing_hooks  ||= []
   @post_uninstall_hooks ||= []
   @pre_uninstall_hooks  ||= []
   @pre_install_hooks    ||= []
@@ -57,11 +57,18 @@ module Gem
     File.join Gem.user_home, '.gem', ruby_engine, ConfigMap[:ruby_version]
   end
 
+  ##
+  # How String Gem paths should be split.  Overridable for esoteric platforms.
+
+  def self.path_separator
+    File::PATH_SEPARATOR
+  end
+
   ##
   # Default gem load path
 
   def self.default_path
-    if File.exist? Gem.user_home then
+    if Gem.user_home && File.exist?(Gem.user_home) then
       [user_dir, default_dir]
     else
       [default_dir]
@@ -93,24 +100,6 @@ module Gem
     end
   end
 
-  ##
-  # The default system-wide source info cache directory
-
-  def self.default_system_source_cache_dir
-    File.join(Gem.dir, 'source_cache')
-  end
-
-  ##
-  # The default user-specific source info cache directory
-
-  def self.default_user_source_cache_dir
-    #
-    # NOTE Probably an argument for moving this to per-ruby supported dirs like
-    # user_dir
-    #
-    File.join(Gem.user_home, '.gem', 'source_cache')
-  end
-
   ##
   # A wrapper around RUBY_ENGINE const that may not be defined
 

data/lib/rubygems/dependency.rb

@@ -1,8 +1,8 @@
-require "rubygems/requirement"
-
 ##
 # The Dependency class holds a Gem name and a Gem::Requirement.
 
+require "rubygems/requirement"
+
 class Gem::Dependency
 
   ##
@@ -11,6 +11,9 @@ class Gem::Dependency
   # When this list is updated, be sure to change
   # Gem::Specification::CURRENT_SPECIFICATION_VERSION as well.
 
+  # REFACTOR: This type of constant, TYPES, indicates we might want
+  # two classes, used via inheretance or duck typing.
+
   TYPES = [
            :development,
            :runtime,
@@ -32,18 +35,23 @@ class Gem::Dependency
   # <tt>:runtime</tt>.
 
   def initialize name, *requirements
-    if Regexp === name then
+    case name
+    when String then # ok
+    when Regexp then
       msg = ["NOTE: Dependency.new w/ a regexp is deprecated.",
              "Dependency.new called from #{Gem.location_of_caller.join(":")}"]
       warn msg.join("\n") unless Gem::Deprecate.skip
+    else
+      raise ArgumentError,
+            "dependency name must be a String, was #{name.inspect}"
     end
 
     type         = Symbol === requirements.last ? requirements.pop : :runtime
     requirements = requirements.first if 1 == requirements.length # unpack
 
     unless TYPES.include? type
-      raise ArgumentError, "Valid types are #{TYPES.inspect}, "
-        + "not #{type.inspect}"
+      raise ArgumentError, "Valid types are #{TYPES.inspect}, " +
+                           "not #{type.inspect}"
     end
 
     @name        = name
@@ -66,8 +74,13 @@ class Gem::Dependency
   end
 
   def inspect # :nodoc:
-    "<%s type=%p name=%p requirements=%p>" %
-      [self.class, self.type, self.name, requirement.to_s]
+    if @prerelease
+      "<%s type=%p name=%p requirements=%p prerelease=ok>" %
+        [self.class, self.type, self.name, requirement.to_s]
+    else
+      "<%s type=%p name=%p requirements=%p>" %
+        [self.class, self.type, self.name, requirement.to_s]
+    end
   end
 
   ##
@@ -77,6 +90,14 @@ class Gem::Dependency
     @prerelease || requirement.prerelease?
   end
 
+  ##
+  # Is this dependency simply asking for the latest version
+  # of a gem?
+
+  def latest_version?
+    @requirement.none?
+  end
+
   def pretty_print q # :nodoc:
     q.group 1, 'Gem::Dependency.new(', ')' do
       q.pp name
@@ -113,6 +134,8 @@ class Gem::Dependency
     # Children, define explicit marshal and unmarshal behavior for
     # public classes. Marshal formats are part of your public API.
 
+    # REFACTOR: See above
+
     if defined?(@version_requirement) && @version_requirement
       version = @version_requirement.instance_variable_get :@version
       @version_requirement  = nil
@@ -122,6 +145,7 @@ class Gem::Dependency
     @requirement = @version_requirements if defined?(@version_requirements)
   end
 
+  # DOC: this method needs documentation or :nodoc''d
   def requirements_list
     requirement.as_list
   end
@@ -179,13 +203,24 @@ class Gem::Dependency
     requirement.satisfied_by? version
   end
 
-  def match? name, version
+  # DOC: this method needs either documented or :nodoc'd
+
+  def match? obj, version=nil
+    if !version
+      name = obj.name
+      version = obj.version
+    else
+      name = obj
+    end
+
     return false unless self.name === name
     return true if requirement.none?
 
     requirement.satisfied_by? Gem::Version.new(version)
   end
 
+  # DOC: this method needs either documented or :nodoc'd
+
   def matches_spec? spec
     return false unless name === spec.name
     return true  if requirement.none?
@@ -212,6 +247,8 @@ class Gem::Dependency
     self.class.new name, self_req.as_list.concat(other_req.as_list)
   end
 
+  # DOC: this method needs either documented or :nodoc'd
+
   def matching_specs platform_only = false
     matches = Gem::Specification.find_all { |spec|
       self.name === spec.name and # TODO: == instead of ===
@@ -234,14 +271,26 @@ class Gem::Dependency
     @requirement.specific?
   end
 
+  # DOC: this method needs either documented or :nodoc'd
+
   def to_specs
     matches = matching_specs true
 
     # TODO: check Gem.activated_spec[self.name] in case matches falls outside
 
     if matches.empty? then
-      specs = Gem::Specification.all_names.join ", "
-      error = Gem::LoadError.new "Could not find #{name} (#{requirement}) amongst [#{specs}]"
+      specs = Gem::Specification.find_all { |s|
+                s.name == name
+              }.map { |x| x.full_name }
+
+      if specs.empty?
+        total = Gem::Specification.to_a.size
+        error = Gem::LoadError.new \
+          "Could not find '#{name}' (#{requirement}) among #{total} total gem(s)"
+      else
+        error = Gem::LoadError.new \
+          "Could not find '#{name}' (#{requirement}) - did find: [#{specs.join ','}]"
+      end
       error.name        = self.name
       error.requirement = self.requirement
       raise error
@@ -252,6 +301,8 @@ class Gem::Dependency
     matches
   end
 
+  # DOC: this method needs either documented or :nodoc'd
+
   def to_spec
     matches = self.to_specs
 

data/lib/rubygems/dependency_installer.rb

@@ -1,8 +1,12 @@
 require 'rubygems'
 require 'rubygems/dependency_list'
+require 'rubygems/package'
 require 'rubygems/installer'
 require 'rubygems/spec_fetcher'
 require 'rubygems/user_interaction'
+require 'rubygems/source_local'
+require 'rubygems/source_specific_file'
+require 'rubygems/available_set'
 
 ##
 # Installs a gem along with all its dependencies from local and remote gems.
@@ -14,8 +18,14 @@ class Gem::DependencyInstaller
   attr_reader :gems_to_install
   attr_reader :installed_gems
 
+  ##
+  # Documentation types.  For use by the Gem.done_installing hook
+
+  attr_reader :document
+
   DEFAULT_OPTIONS = {
     :env_shebang         => false,
+    :document            => %w[ri],
     :domain              => :both, # HACK dup
     :force               => false,
     :format_executable   => false, # HACK dup
@@ -23,7 +33,8 @@ class Gem::DependencyInstaller
     :prerelease          => false,
     :security_policy     => nil, # HACK NoSecurity requires OpenSSL. AlmostNo? Low?
     :wrappers            => true,
-  }
+    :build_docs_in_background => false,
+  }.freeze
 
   ##
   # Creates a new installer instance.
@@ -47,6 +58,7 @@ class Gem::DependencyInstaller
     if options[:install_dir] then
       @gem_home = options[:install_dir]
 
+      # HACK shouldn't change the global settings
       Gem::Specification.dirs = @gem_home
       Gem.ensure_gem_subdirectories @gem_home
       options[:install_dir] = @gem_home # FIX: because we suck and reuse below
@@ -55,7 +67,9 @@ class Gem::DependencyInstaller
     options = DEFAULT_OPTIONS.merge options
 
     @bin_dir             = options[:bin_dir]
+    @dev_shallow         = options[:dev_shallow]
     @development         = options[:development]
+    @document            = options[:document]
     @domain              = options[:domain]
     @env_shebang         = options[:env_shebang]
     @force               = options[:force]
@@ -65,8 +79,14 @@ class Gem::DependencyInstaller
     @security_policy     = options[:security_policy]
     @user_install        = options[:user_install]
     @wrappers            = options[:wrappers]
+    @build_docs_in_background = options[:build_docs_in_background]
+
+    # Indicates that we should not try to update any deps unless
+    # we absolutely must.
+    @minimal_deps        = options[:minimal_deps]
 
     @installed_gems = []
+    @toplevel_specs = nil
 
     @install_dir = options[:install_dir] || Gem.dir
     @cache_dir = options[:cache_dir] || @install_dir
@@ -76,6 +96,24 @@ class Gem::DependencyInstaller
     @errors = nil
   end
 
+  attr_reader :errors
+
+  ##
+  # Indicated, based on the requested domain, if local
+  # gems should be considered.
+
+  def consider_local?
+    @domain == :both or @domain == :local
+  end
+
+  ##
+  # Indicated, based on the requested domain, if remote
+  # gems should be considered.
+
+  def consider_remote?
+    @domain == :both or @domain == :remote
+  end
+
   ##
   # Returns a list of pairs of gemspecs and source_uris that match
   # Gem::Dependency +dep+ from both local (Dir.pwd) and remote (Gem.sources)
@@ -83,35 +121,34 @@ class Gem::DependencyInstaller
   # local gems preferred over remote gems.
 
   def find_gems_with_sources(dep)
-    # Reset the errors
-    @errors = nil
-    gems_and_sources = []
+    set = Gem::AvailableSet.new
+
+    if consider_local?
+      sl = Gem::Source::Local.new
 
-    if @domain == :both or @domain == :local then
-      Dir[File.join(Dir.pwd, "#{dep.name}-[0-9]*.gem")].each do |gem_file|
-        spec = Gem::Format.from_file_by_path(gem_file).spec
-        gems_and_sources << [spec, gem_file] if spec.name == dep.name
+      if spec = sl.find_gem(dep.name)
+        if dep.matches_spec? spec
+          set.add spec, sl
+        end
       end
     end
 
-    if @domain == :both or @domain == :remote then
+    if consider_remote?
       begin
-        # REFACTOR: all = dep.requirement.needs_all?
-        requirements = dep.requirement.requirements.map do |req, ver|
-          req
-        end
-
-        all = !dep.prerelease? &&
-              # we only need latest if there's one requirement and it is
-              # guaranteed to match the newest specs
-              (requirements.length > 1 or
-                (requirements.first != ">=" and requirements.first != ">"))
+        found, errors = Gem::SpecFetcher.fetcher.spec_for_dependency dep
 
-        found, @errors = Gem::SpecFetcher.fetcher.fetch_with_errors dep, all, true, dep.prerelease?
+        if @errors
+          @errors += errors
+        else
+          @errors = errors
+        end
 
-        gems_and_sources.push(*found)
+        set << found
 
       rescue Gem::RemoteFetcher::FetchError => e
+        # FIX if there is a problem talking to the network, we either need to always tell
+        # the user (no really_verbose) or fail hard, not silently tell them that we just
+        # couldn't find their requested gem.
         if Gem.configuration.really_verbose then
           say "Error fetching remote data:\t\t#{e.message}"
           say "Falling back to local-only install"
@@ -120,9 +157,7 @@ class Gem::DependencyInstaller
       end
     end
 
-    gems_and_sources.sort_by do |gem, source|
-      [gem, source =~ /^http:\/\// ? 0 : 1] # local gems win
-    end
+    set
   end
 
   ##
@@ -130,17 +165,22 @@ class Gem::DependencyInstaller
   # remote sources unless the ignore_dependencies was given.
 
   def gather_dependencies
-    specs = @specs_and_sources.map { |spec,_| spec }
+    specs = @available.all_specs
 
     # these gems were listed by the user, always install them
     keep_names = specs.map { |spec| spec.full_name }
 
+    if @dev_shallow
+      @toplevel_specs = keep_names
+    end
+
     dependency_list = Gem::DependencyList.new @development
     dependency_list.add(*specs)
     to_do = specs.dup
-
     add_found_dependencies to_do, dependency_list unless @ignore_dependencies
 
+    # REFACTOR maybe abstract away using Gem::Specification.include? so
+    # that this isn't dependent only on the currently installed gems
     dependency_list.specs.reject! { |spec|
       not keep_names.include?(spec.full_name) and
       Gem::Specification.include?(spec)
@@ -162,32 +202,43 @@ class Gem::DependencyInstaller
 
     until to_do.empty? do
       spec = to_do.shift
+
+      # HACK why is spec nil?
       next if spec.nil? or seen[spec.name]
       seen[spec.name] = true
 
       deps = spec.runtime_dependencies
-      deps |= spec.development_dependencies if @development
+
+      if @development
+        if @dev_shallow
+          if @toplevel_specs.include? spec.full_name
+            deps |= spec.development_dependencies
+          end
+        else
+          deps |= spec.development_dependencies
+        end
+      end
 
       deps.each do |dep|
         dependencies[dep.name] = dependencies[dep.name].merge dep
 
-        results = find_gems_with_sources(dep).reverse
+        if @minimal_deps
+          next if Gem::Specification.any? do |installed_spec|
+                    dep.name == installed_spec.name and
+                      dep.requirement.satisfied_by? installed_spec.version
+                  end
+        end
 
-        results.reject! do |dep_spec,|
-          to_do.push dep_spec
+        results = find_gems_with_sources(dep)
 
-          # already locally installed
-          Gem::Specification.any? do |installed_spec|
-            dep.name == installed_spec.name and
-              dep.requirement.satisfied_by? installed_spec.version
-          end
+        results.sorted.each do |t|
+          to_do.push t.spec
         end
 
-        results.each do |dep_spec, source_uri|
-          @specs_and_sources << [dep_spec, source_uri]
+        results.remove_installed! dep
 
-          dependency_list.add dep_spec
-        end
+        @available << results
+        results.inject_into_list dependency_list
       end
     end
 
@@ -202,42 +253,36 @@ class Gem::DependencyInstaller
   def find_spec_by_name_and_version(gem_name,
                                     version = Gem::Requirement.default,
                                     prerelease = false)
-    spec_and_source = nil
 
-    glob = if File::ALT_SEPARATOR then
-             gem_name.gsub File::ALT_SEPARATOR, File::SEPARATOR
-           else
-             gem_name
-           end
+    set = Gem::AvailableSet.new
 
-    local_gems = Dir["#{glob}*"].sort.reverse
+    if consider_local?
+      if File.exists? gem_name
+        src = Gem::Source::SpecificFile.new(gem_name)
+        set.add src.spec, src
+      else
+        local = Gem::Source::Local.new
 
-    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
+        if s = local.find_gem(gem_name, version)
+          set.add s, local
+        end
       end
     end
 
-    unless spec_and_source then
+    if set.empty?
       dep = Gem::Dependency.new gem_name, version
+      # HACK Dependency objects should be immutable
       dep.prerelease = true if prerelease
-      spec_and_sources = find_gems_with_sources(dep).reverse
-      spec_and_source = spec_and_sources.find { |spec, source|
-        Gem::Platform.match spec.platform
-      }
+
+      set = find_gems_with_sources(dep)
+      set.match_platform!
     end
 
-    if spec_and_source.nil? then
-      raise Gem::GemNotFoundException.new(
-        "Could not find a valid gem '#{gem_name}' (#{version}) locally or in a repository",
-        gem_name, version, @errors)
+    if set.empty?
+      raise Gem::SpecificGemNotFoundException.new(gem_name, version, @errors)
     end
 
-    @specs_and_sources = [spec_and_source]
+    @available = set
   end
 
   ##
@@ -258,33 +303,49 @@ class Gem::DependencyInstaller
     if String === dep_or_name then
       find_spec_by_name_and_version dep_or_name, version, @prerelease
     else
-      dep_or_name.prerelease = @prerelease
-      @specs_and_sources = [find_gems_with_sources(dep_or_name).last]
+      dep = dep_or_name.dup
+      dep.prerelease = @prerelease
+      @available = find_gems_with_sources(dep).pick_best!
     end
 
     @installed_gems = []
 
     gather_dependencies
 
+    # REFACTOR is the last gem always the one that the user requested?
+    # This code assumes that but is that actually validated by the code?
+
     last = @gems_to_install.size - 1
     @gems_to_install.each_with_index do |spec, index|
+      # REFACTOR more current spec set hardcoding, should be abstracted?
       next if Gem::Specification.include?(spec) and index != 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
+      source = @available.source_for spec
+
       begin
-        local_gem_path = Gem::RemoteFetcher.fetcher.download spec, source_uri,
-                                                             @cache_dir
+        # REFACTOR make the fetcher to use configurable
+        local_gem_path = source.download spec, @cache_dir
       rescue Gem::RemoteFetcher::FetchError
+        # TODO I doubt all fetch errors are recoverable, we should at least
+        # report the errors probably.
         next if @force
         raise
       end
 
+      if @development
+        if @dev_shallow
+          is_dev = @toplevel_specs.include? spec.full_name
+        else
+          is_dev = true
+        end
+      end
+
       inst = Gem::Installer.new local_gem_path,
                                 :bin_dir             => @bin_dir,
-                                :development         => @development,
+                                :development         => is_dev,
                                 :env_shebang         => @env_shebang,
                                 :force               => @force,
                                 :format_executable   => @format_executable,
@@ -299,6 +360,33 @@ class Gem::DependencyInstaller
       @installed_gems << spec
     end
 
+    # Since this is currently only called for docs, we can be lazy and just say
+    # it's documentation. Ideally the hook adder could decide whether to be in
+    # the background or not, and what to call it.
+    in_background "Installing documentation" do
+      start = Time.now
+      Gem.done_installing_hooks.each do |hook|
+        hook.call self, @installed_gems
+      end
+      finish = Time.now
+      say "Done installing documentation for #{@installed_gems.map(&:name).join(', ')} (#{(finish-start).to_i} sec)."
+    end unless Gem.done_installing_hooks.empty?
+
     @installed_gems
   end
+
+  def in_background what
+    fork_happened = false
+    if @build_docs_in_background and Process.respond_to?(:fork)
+      begin
+        Process.fork do
+          yield
+        end
+        fork_happened = true
+        say "#{what} in a background process."
+      rescue NotImplementedError
+      end
+    end
+    yield unless fork_happened
+  end
 end