* lib/rubygems: Update to RubyGems 2.1.3

  Fixed installing platform gems

  Restored concurrent requires

  Fixed installing gems with extensions with --install-dir

  Fixed `gem fetch -v` to install the latest version

  Fixed installing gems with "./" in their files entries

* test/rubygems/test_gem_package.rb:  Tests for the above.

* NEWS:  Updated for RubyGems 2.1.3


git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@42938 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

1 files changed, 125 insertions, 126 deletions

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