From 1daa0b113d853bfa57b776cc569939b61ca14292 Mon Sep 17 00:00:00 2001 From: drbrain Date: Fri, 13 Sep 2013 19:58:57 +0000 Subject: * 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 --- lib/rubygems/request_set.rb | 251 ++++++++++++++++++++++---------------------- 1 file changed, 125 insertions(+), 126 deletions(-) (limited to 'lib/rubygems/request_set.rb') 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' -- cgit v1.2.3