From 47f0248b0858898dd24d1e654cedf174059ca677 Mon Sep 17 00:00:00 2001
From: drbrain <drbrain@b2dd03c8-39d4-4d8f-98ff-823fe69b080e>
Date: Tue, 9 Jul 2013 23:21:36 +0000
Subject: * lib/rubygems:  Import RubyGems 2.1 * test/rubygems:  Ditto.

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@41873 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
---
 lib/rubygems/request_set.rb | 248 ++++++++++++++++++++++----------------------
 1 file changed, 123 insertions(+), 125 deletions(-)

(limited to 'lib/rubygems/request_set.rb')

diff --git a/lib/rubygems/request_set.rb b/lib/rubygems/request_set.rb
index 6c52b90c40..748c320c28 100644
--- a/lib/rubygems/request_set.rb
+++ b/lib/rubygems/request_set.rb
@@ -5,178 +5,176 @@ require 'rubygems/dependency_list'
 require 'rubygems/installer'
 require 'tsort'
 
-module Gem
-  class RequestSet
+class Gem::RequestSet
 
-    include TSort
+  include TSort
 
-    def initialize(*deps)
-      @dependencies = deps
+  ##
+  # Array of gems to install even if already installed
 
-      yield self if block_given?
-    end
+  attr_reader :always_install
 
-    attr_reader :dependencies
+  attr_reader :dependencies
 
-    # Declare that a gem of name +name+ with +reqs+ requirements
-    # is needed.
-    #
-    def gem(name, *reqs)
-      @dependencies << Gem::Dependency.new(name, reqs)
-    end
+  attr_accessor :development
 
-    # Add +deps+ Gem::Depedency objects to the set.
-    #
-    def import(deps)
-      @dependencies += deps
-    end
+  ##
+  # Treat missing dependencies as silent errors
 
-    # Resolve the requested dependencies and return an Array of
-    # Specification objects to be activated.
-    #
-    def resolve(set=nil)
-      r = Gem::DependencyResolver.new(@dependencies, set)
-      @requests = r.resolve
-    end
+  attr_accessor :soft_missing
 
-    # Resolve the requested dependencies against the gems
-    # available via Gem.path and return an Array of Specification
-    # objects to be activated.
-    #
-    def resolve_current
-      resolve DependencyResolver::CurrentSet.new
-    end
+  def initialize *deps
+    @dependencies = deps
 
-    # Load a dependency management file.
-    #
-    def load_gemdeps(path)
-      gf = GemDepedencyAPI.new(self, path)
-      gf.load
-    end
+    @always_install = []
+    @development    = false
+    @soft_missing   = false
 
-    def specs
-      @specs ||= @requests.map { |r| r.full_spec }
-    end
+    yield self if block_given?
+  end
 
-    def tsort_each_node(&block)
-      @requests.each(&block)
-    end
+  ##
+  # Declare that a gem of name +name+ with +reqs+ requirements is needed.
 
-    def tsort_each_child(node)
-      node.spec.dependencies.each do |dep|
-        next if dep.type == :development
-
-        match = @requests.find { |r| dep.match? r.spec.name, r.spec.version }
-        if match
-          begin
-            yield match
-          rescue TSort::Cyclic
-          end
-        else
-          raise Gem::DependencyError, "Unresolved depedency found during sorting - #{dep}"
-        end
-      end
-    end
+  def gem name, *reqs
+    @dependencies << Gem::Dependency.new(name, reqs)
+  end
+
+  ##
+  # Add +deps+ Gem::Dependency objects to the set.
+
+  def import deps
+    @dependencies += deps
+  end
 
-    def sorted_requests
-      @sorted ||= strongly_connected_components.flatten
+  def install options, &block
+    if dir = options[:install_dir]
+      return install_into dir, false, options, &block
     end
 
-    def specs_in(dir)
-      Dir["#{dir}/specifications/*.gemspec"].map do |g|
-        Gem::Specification.load g
+    cache_dir = options[:cache_dir] || Gem.dir
+
+    specs = []
+
+    sorted_requests.each do |req|
+      if req.installed? and
+         @always_install.none? { |spec| spec == req.spec.spec } then
+        yield req, nil if block_given?
+        next
       end
-    end
 
-    def install_into(dir, force=true, &b)
-      existing = force ? [] : specs_in(dir)
+      path = req.download cache_dir
 
-      dir = File.expand_path dir
+      inst = Gem::Installer.new path, options
 
-      installed = []
+      yield req, inst if block_given?
 
-      sorted_requests.each do |req|
-        if existing.find { |s| s.full_name == req.spec.full_name }
-          b.call req, nil if b
-          next
-        end
+      specs << inst.install
+    end
 
-        path = req.download(dir)
+    specs
+  end
 
-        inst = Gem::Installer.new path, :install_dir => dir,
-                                        :only_install_dir => true
+  def install_into dir, force = true, options = {}
+    existing = force ? [] : specs_in(dir)
+    existing.delete_if { |s| @always_install.include? s }
 
-        b.call req, inst if b
+    dir = File.expand_path dir
 
-        inst.install
+    installed = []
 
-        installed << req
+    sorted_requests.each do |req|
+      if existing.find { |s| s.full_name == req.spec.full_name }
+        yield req, nil if block_given?
+        next
       end
 
-      installed
-    end
+      path = req.download(dir)
 
-    def install(options, &b)
-      if dir = options[:install_dir]
-        return install_into(dir, false, &b)
+      unless path then # already installed
+        yield req, nil if block_given?
+        next
       end
 
-      cache_dir = options[:cache_dir] || Gem.dir
+      options[:install_dir] = dir
+      options[:only_install_dir] = true
 
-      specs = []
+      inst = Gem::Installer.new path, options
 
-      sorted_requests.each do |req|
-        if req.installed?
-          b.call req, nil if b
-          next
-        end
+      yield req, inst if block_given?
 
-        path = req.download cache_dir
+      inst.install
 
-        inst = Gem::Installer.new path, options
+      installed << req
+    end
 
-        b.call req, inst if b
+    installed
+  end
 
-        specs << inst.install
-      end
+  ##
+  # Load a dependency management file.
 
-      specs
-    end
+  def load_gemdeps path
+    gf = Gem::RequestSet::GemDepedencyAPI.new self, path
+    gf.load
+  end
 
-    # A semi-compatible DSL for Bundler's Gemfile format
-    #
-    class GemDepedencyAPI
-      def initialize(set, path)
-        @set = set
-        @path = path
-      end
+  ##
+  # Resolve the requested dependencies and return an Array of Specification
+  # objects to be activated.
 
-      def load
-        instance_eval File.read(@path).untaint, @path, 1
-      end
+  def resolve set = nil
+    resolver = Gem::DependencyResolver.new @dependencies, set
+    resolver.development  = @development
+    resolver.soft_missing = @soft_missing
 
-      # DSL
+    @requests = resolver.resolve
+  end
 
-      def source(url)
-      end
+  ##
+  # Resolve the requested dependencies against the gems available via Gem.path
+  # and return an Array of Specification objects to be activated.
 
-      def gem(name, *reqs)
-        # Ignore the opts for now.
-        reqs.pop if reqs.last.kind_of?(Hash)
+  def resolve_current
+    resolve Gem::DependencyResolver::CurrentSet.new
+  end
 
-        @set.gem name, *reqs
-      end
+  def sorted_requests
+    @sorted ||= strongly_connected_components.flatten
+  end
 
-      def platform(what)
-        if what == :ruby
-          yield
-        end
-      end
+  def specs
+    @specs ||= @requests.map { |r| r.full_spec }
+  end
+
+  def specs_in dir
+    Dir["#{dir}/specifications/*.gemspec"].map do |g|
+      Gem::Specification.load g
+    end
+  end
+
+  def tsort_each_node &block # :nodoc:
+    @requests.each(&block)
+  end
 
-      alias_method :platforms, :platform
+  def tsort_each_child node # :nodoc:
+    node.spec.dependencies.each do |dep|
+      next if dep.type == :development and not @development
 
-      def group(*what)
+      match = @requests.find { |r| dep.match? r.spec.name, r.spec.version }
+      if match
+        begin
+          yield match
+        rescue TSort::Cyclic
+        end
+      else
+        unless @soft_missing
+          raise Gem::DependencyError, "Unresolved depedency found during sorting - #{dep}"
+        end
       end
     end
   end
+
 end
+
+require 'rubygems/request_set/gem_dependency_api'
-- 
cgit v1.2.3