rubygems-update 2.1.11 → 2.2.0.rc.1

data/lib/rubygems/{dependency_resolver → resolver}/installer_set.rb

@@ -1,20 +1,27 @@
-class Gem::DependencyResolver::InstallerSet
+##
+# A set of gems for installation sourced from remote sources and local .gem
+# files
+
+class Gem::Resolver::InstallerSet < Gem::Resolver::Set
 
   ##
   # List of Gem::Specification objects that must always be installed.
 
-  attr_reader :always_install
+  attr_reader :always_install # :nodoc:
 
   ##
   # Only install gems in the always_install list
 
-  attr_accessor :ignore_dependencies
+  attr_accessor :ignore_dependencies # :nodoc:
 
   ##
   # Do not look in the installed set when finding specifications.  This is
   # used by the --install-dir option to `gem install`
 
-  attr_accessor :ignore_installed
+  attr_accessor :ignore_installed # :nodoc:
+
+  ##
+  # Creates a new InstallerSet that will look for gems in +domain+.
 
   def initialize domain
     @domain = domain
@@ -32,14 +39,14 @@ class Gem::DependencyResolver::InstallerSet
   ##
   # Should local gems should be considered?
 
-  def consider_local?
+  def consider_local? # :nodoc:
     @domain == :both or @domain == :local
   end
 
   ##
   # Should remote gems should be considered?
 
-  def consider_remote?
+  def consider_remote? # :nodoc:
     @domain == :both or @domain == :remote
   end
 
@@ -60,14 +67,14 @@ class Gem::DependencyResolver::InstallerSet
     dep.matching_specs.each do |gemspec|
       next if @always_install.include? gemspec
 
-      res << Gem::DependencyResolver::InstalledSpecification.new(self, gemspec)
+      res << Gem::Resolver::InstalledSpecification.new(self, gemspec)
     end unless @ignore_installed
 
     if consider_local? then
       local_source = Gem::Source::Local.new
 
       if spec = local_source.find_gem(name, dep.requirement) then
-        res << Gem::DependencyResolver::IndexSpecification.new(
+        res << Gem::Resolver::IndexSpecification.new(
           self, spec.name, spec.version, local_source, spec.platform)
       end
     end
@@ -77,7 +84,7 @@ class Gem::DependencyResolver::InstallerSet
 
       @all[name].each do |remote_source, n|
         if dep.match? n then
-          res << Gem::DependencyResolver::IndexSpecification.new(
+          res << Gem::Resolver::IndexSpecification.new(
             self, n.name, n.version, remote_source, n.platform)
         end
       end
@@ -97,7 +104,7 @@ class Gem::DependencyResolver::InstallerSet
   ##
   # Loads remote prerelease specs if +dep+ is a prerelease dependency
 
-  def load_remote_specs dep
+  def load_remote_specs dep # :nodoc:
     types = [:released]
     types << :prerelease if dep.prerelease?
 
@@ -119,7 +126,7 @@ class Gem::DependencyResolver::InstallerSet
   # Called from IndexSpecification to get a true Specification
   # object.
 
-  def load_spec name, ver, platform, source
+  def load_spec name, ver, platform, source # :nodoc:
     key = "#{name}-#{ver}-#{platform}"
 
     @specs.fetch key do
@@ -129,12 +136,6 @@ class Gem::DependencyResolver::InstallerSet
     end
   end
 
-  ##
-  # No prefetching needed since we load the whole index in initially.
-
-  def prefetch(reqs)
-  end
-
   def pretty_print q # :nodoc:
     q.group 2, '[InstallerSet', ']' do
       q.breakable

data/lib/rubygems/resolver/local_specification.rb

@@ -0,0 +1,16 @@
+##
+# A LocalSpecification comes from a .gem file on the local filesystem.
+
+class Gem::Resolver::LocalSpecification < Gem::Resolver::SpecSpecification
+
+  ##
+  # Returns +true+ if this gem is installable for the current platform.
+
+  def installable_platform?
+    return true if @source.kind_of? Gem::Source::SpecificFile
+
+    super
+  end
+
+end
+

data/lib/rubygems/resolver/lock_set.rb

@@ -0,0 +1,78 @@
+##
+# A set of gems from a gem dependencies lockfile.
+
+class Gem::Resolver::LockSet < Gem::Resolver::Set
+
+  attr_reader :specs # :nodoc:
+
+  ##
+  # Creates a new LockSet from the given +source+
+
+  def initialize source
+    @source = Gem::Source::Lock.new source
+    @specs  = []
+  end
+
+  ##
+  # Creates a new IndexSpecification in this set using the given +name+,
+  # +version+ and +platform+.
+  #
+  # The specification's set will be the current set, and the source will be
+  # the current set's source.
+
+  def add name, version, platform # :nodoc:
+    version = Gem::Version.new version
+
+    spec =
+      Gem::Resolver::LockSpecification.new self, name, version, @source,
+                                           platform
+
+    @specs << spec
+
+    spec
+  end
+
+  ##
+  # Returns an Array of IndexSpecification objects matching the
+  # DependencyRequest +req+.
+
+  def find_all req
+    @specs.select do |spec|
+      req.matches_spec? spec
+    end
+  end
+
+  ##
+  # Loads a Gem::Specification with the given +name+, +version+ and
+  # +platform+.  +source+ is ignored.
+
+  def load_spec name, version, platform, source # :nodoc:
+    dep = Gem::Dependency.new name, version
+
+    found = @specs.find do |spec|
+      dep.matches_spec? spec and spec.platform == platform
+    end
+
+    tuple = Gem::NameTuple.new found.name, found.version, found.platform
+
+    found.source.fetch_spec tuple
+  end
+
+  def pretty_print q # :nodoc:
+    q.group 2, '[LockSet', ']' do
+      q.breakable
+      q.text 'source:'
+
+      q.breakable
+      q.pp @source
+
+      q.breakable
+      q.text 'specs:'
+
+      q.breakable
+      q.pp @specs.map { |spec| spec.full_name }
+    end
+  end
+
+end
+

data/lib/rubygems/resolver/lock_specification.rb

@@ -0,0 +1,58 @@
+##
+# The LockSpecification comes from a lockfile (Gem::RequestSet::Lockfile).
+#
+# A LockSpecification's dependency information is pre-filled from the
+# lockfile.
+
+class Gem::Resolver::LockSpecification < Gem::Resolver::Specification
+
+  def initialize set, name, version, source, platform
+    super()
+
+    @name     = name
+    @platform = platform
+    @set      = set
+    @source   = source
+    @version  = version
+
+    @dependencies = []
+    @spec         = nil
+  end
+
+  ##
+  # This is a null install as a locked specification is considered installed.
+  # +options+ are ignored.
+
+  def install options
+    destination = options[:install_dir] || Gem.dir
+
+    if File.exist? File.join(destination, 'specifications', spec.spec_name) then
+      yield nil
+      return
+    end
+
+    super
+  end
+
+  ##
+  # Adds +dependency+ from the lockfile to this specification
+
+  def add_dependency dependency # :nodoc:
+    @dependencies << dependency
+  end
+
+  ##
+  # A specification constructed from the lockfile is returned
+
+  def spec
+    @spec ||= Gem::Specification.new do |s|
+      s.name     = @name
+      s.version  = @version
+      s.platform = @platform
+
+      s.dependencies.concat @dependencies
+    end
+  end
+
+end
+

data/lib/rubygems/resolver/requirement_list.rb

@@ -0,0 +1,81 @@
+##
+# The RequirementList is used to hold the requirements being considered
+# while resolving a set of gems.
+#
+# The RequirementList acts like a queue where the oldest items are removed
+# first.
+
+class Gem::Resolver::RequirementList
+
+  include Enumerable
+
+  ##
+  # Creates a new RequirementList.
+
+  def initialize
+    @exact = []
+    @list = []
+  end
+
+  def initialize_copy other # :nodoc:
+    @exact = @exact.dup
+    @list = @list.dup
+  end
+
+  ##
+  # Adds Resolver::DependencyRequest +req+ to this requirements list.
+
+  def add(req)
+    if req.requirement.exact?
+      @exact.push req
+    else
+      @list.push req
+    end
+    req
+  end
+
+  ##
+  # Enumerates requirements in the list
+
+  def each # :nodoc:
+    return enum_for __method__ unless block_given?
+
+    @exact.each do |requirement|
+      yield requirement
+    end
+
+    @list.each do |requirement|
+      yield requirement
+    end
+  end
+
+  ##
+  # How many elements are in the list
+
+  def size
+    @exact.size + @list.size
+  end
+
+  ##
+  # Is the list empty?
+
+  def empty?
+    @exact.empty? && @list.empty?
+  end
+
+  ##
+  # Remove the oldest DependencyRequest from the list.
+
+  def remove
+    return @exact.shift unless @exact.empty?
+    @list.shift
+  end
+
+  ##
+  # Returns the oldest five entries from the list.
+
+  def next5
+    x = @exact[0,5]
+    x + @list[0,5 - x.size]
+  end
+end

data/lib/rubygems/resolver/set.rb

@@ -0,0 +1,27 @@
+##
+# Resolver sets are used to look up specifications (and their
+# dependencies) used in resolution.  This set is abstract.
+
+class Gem::Resolver::Set
+
+  ##
+  # The find_all method must be implemented.  It returns all Resolver
+  # Specification objects matching the given DependencyRequest +req+.
+
+  def find_all req
+    raise NotImplementedError
+  end
+
+  ##
+  # The #prefetch method may be overridden, but this is not necessary.  This
+  # default implementation does nothing, which is suitable for sets where
+  # looking up a specification is cheap (such as installed gems).
+  #
+  # When overridden, the #prefetch method should look up specifications
+  # matching +reqs+.
+
+  def prefetch reqs
+  end
+
+end
+

data/lib/rubygems/resolver/spec_specification.rb

@@ -0,0 +1,58 @@
+##
+# The Resolver::SpecSpecification contains common functionality for
+# Resolver specifications that are backed by a Gem::Specification.
+
+class Gem::Resolver::SpecSpecification < Gem::Resolver::Specification
+
+  attr_reader :spec # :nodoc:
+
+  ##
+  # A SpecSpecification is created for a +set+ for a Gem::Specification in
+  # +spec+.  The +source+ is either where the +spec+ came from, or should be
+  # loaded from.
+
+  def initialize set, spec, source = nil
+    @set    = set
+    @source = source
+    @spec   = spec
+  end
+
+  ##
+  # The dependencies of the gem for this specification
+
+  def dependencies
+    spec.dependencies
+  end
+
+  ##
+  # The name and version of the specification.
+  #
+  # Unlike Gem::Specification#full_name, the platform is not included.
+
+  def full_name
+    "#{spec.name}-#{spec.version}"
+  end
+
+  ##
+  # The name of the gem for this specification
+
+  def name
+    spec.name
+  end
+
+  ##
+  # The platform this gem works on.
+
+  def platform
+    spec.platform
+  end
+
+  ##
+  # The version of the gem for this specification.
+
+  def version
+    spec.version
+  end
+
+end
+

data/lib/rubygems/resolver/specification.rb

@@ -0,0 +1,89 @@
+##
+# A Resolver::Specification contains a subset of the information
+# contained in a Gem::Specification.  Only the information necessary for
+# dependency resolution in the resolver is included.
+
+class Gem::Resolver::Specification
+
+  ##
+  # The dependencies of the gem for this specification
+
+  attr_reader :dependencies
+
+  ##
+  # The name of the gem for this specification
+
+  attr_reader :name
+
+  ##
+  # The platform this gem works on.
+
+  attr_reader :platform
+
+  ##
+  # The set this specification came from.
+
+  attr_reader :set
+
+  ##
+  # The source for this specification
+
+  attr_reader :source
+
+  ##
+  # The version of the gem for this specification.
+
+  attr_reader :version
+
+  ##
+  # Sets default instance variables for the specification.
+
+  def initialize
+    @dependencies = nil
+    @name         = nil
+    @platform     = nil
+    @set          = nil
+    @source       = nil
+    @version      = nil
+  end
+
+  ##
+  # The name and version of the specification.
+  #
+  # Unlike Gem::Specification#full_name, the platform is not included.
+
+  def full_name
+    "#{@name}-#{@version}"
+  end
+
+  ##
+  # Installs this specification using the Gem::Installer +options+.  The
+  # install method yields a Gem::Installer instance, which indicates the
+  # gem will be installed, or +nil+, which indicates the gem is already
+  # installed.
+
+  def install options
+    require 'rubygems/installer'
+
+    destination = options[:install_dir] || Gem.dir
+
+    Gem.ensure_gem_subdirectories destination
+
+    gem = source.download spec, destination
+
+    installer = Gem::Installer.new gem, options
+
+    yield installer if block_given?
+
+    installer.install
+  end
+
+  ##
+  # Returns true if this specification is installable on this platform.
+
+  def installable_platform?
+    Gem::Platform.match spec.platform
+  end
+
+end
+