In Files

  • rubygems/request_set.rb
  • rubygems/request_set/gem_dependency_api.rb
  • rubygems/request_set/lockfile.rb

Class/Module Index [+]

Quicksearch

Gem::RequestSet

A RequestSet groups a request to activate a set of dependencies.

nokogiri = Gem::Dependency.new 'nokogiri', '~> 1.6'
pg = Gem::Dependency.new 'pg', '~> 0.14'

set = Gem::RequestSet.new nokogiri, pg

requests = set.resolve

p requests.map { |r| r.full_name }
#=> ["nokogiri-1.6.0", "mini_portile-0.5.1", "pg-0.17.0"]

Attributes

always_install[R]

Array of gems to install even if already installed

dependencies[R]
development[RW]
ignore_dependencies[RW]

When true, dependency resolution is not performed, only the requested gems are installed.

soft_missing[RW]

Treat missing dependencies as silent errors

Public Class Methods

new(*deps) click to toggle source

Creates a RequestSet for a list of Gem::Dependency objects, deps. You can then resolve and install the resolved list of dependencies.

nokogiri = Gem::Dependency.new 'nokogiri', '~> 1.6'
pg = Gem::Dependency.new 'pg', '~> 0.14'

set = Gem::RequestSet.new nokogiri, pg
 
               # File rubygems/request_set.rb, line 65
def initialize *deps
  @dependencies = deps

  @always_install      = []
  @dependency_names    = {}
  @development         = false
  @git_set             = nil
  @ignore_dependencies = false
  @install_dir         = Gem.dir
  @requests            = []
  @sets                = []
  @soft_missing        = false
  @sorted              = nil
  @specs               = nil
  @vendor_set          = nil

  yield self if block_given?
end
            

Public Instance Methods

gem(name, *reqs) click to toggle source

Declare that a gem of name name with reqs requirements is needed.

 
               # File rubygems/request_set.rb, line 87
def gem name, *reqs
  if dep = @dependency_names[name] then
    dep.requirement.concat reqs
  else
    dep = Gem::Dependency.new name, reqs
    @dependency_names[name] = dep
    @dependencies << dep
  end
end
            
import(deps) click to toggle source

Add deps Gem::Dependency objects to the set.

 
               # File rubygems/request_set.rb, line 100
def import deps
  @dependencies.concat deps
end
            
install(options, &block) click to toggle source

Installs gems for this RequestSet using the Gem::Installer options.

If a block is given an activation request and installer are yielded. The installer will be nil if a gem matching the request was already installed.

 
               # File rubygems/request_set.rb, line 111
def install options, &block # :yields: request, installer
  if dir = options[:install_dir]
    return install_into dir, false, options, &block
  end

  cache_dir = options[:cache_dir] || Gem.dir

  specs = []

  sorted_requests.each do |req|
    if req.installed? then
      req.spec.spec.build_extensions

      if @always_install.none? { |spec| spec == req.spec.spec } then
        yield req, nil if block_given?
        next
      end
    end

    path = req.download cache_dir

    inst = Gem::Installer.new path, options

    yield req, inst if block_given?

    specs << inst.install
  end

  specs
end
            
install_from_gemdeps(options, &block) click to toggle source

Installs from the gem dependencies files in the :gemdeps option in options, yielding to the block as in install.

If :without_groups is given in the options, those groups in the gem dependencies file are not used. See Gem::Installer for other options.

 
               # File rubygems/request_set.rb, line 149
def install_from_gemdeps options, &block
  gemdeps = options[:gemdeps]

  @install_dir = options[:install_dir] || Gem.dir

  load_gemdeps gemdeps, options[:without_groups]

  resolve

  if options[:explain]
    puts "Gems to install:"

    specs.map { |s| s.full_name }.sort.each do |s|
      puts "  #{s}"
    end

    if Gem.configuration.really_verbose
      @resolver.stats.display
    end
  else
    installed = install options, &block

    lockfile = Gem::RequestSet::Lockfile.new self, gemdeps
    lockfile.write

    installed
  end
end
            
install_into(dir, force = true, options = {}) click to toggle source
 
               # File rubygems/request_set.rb, line 178
def install_into dir, force = true, options = {}
  gem_home, ENV['GEM_HOME'] = ENV['GEM_HOME'], dir

  existing = force ? [] : specs_in(dir)
  existing.delete_if { |s| @always_install.include? s }

  dir = File.expand_path dir

  installed = []

  options[:install_dir] = dir
  options[:only_install_dir] = true

  sorted_requests.each do |request|
    spec = request.spec

    if existing.find { |s| s.full_name == spec.full_name } then
      yield request, nil if block_given?
      next
    end

    spec.install options do |installer|
      yield request, installer if block_given?
    end

    installed << request
  end

  installed
ensure
  ENV['GEM_HOME'] = gem_home
end
            
load_gemdeps(path, without_groups = []) click to toggle source

Load a dependency management file.

 
               # File rubygems/request_set.rb, line 214
def load_gemdeps path, without_groups = []
  @git_set    = Gem::Resolver::GitSet.new
  @vendor_set = Gem::Resolver::VendorSet.new

  @git_set.root_dir = @install_dir

  lockfile = Gem::RequestSet::Lockfile.new self, path
  lockfile.parse

  gf = Gem::RequestSet::GemDependencyAPI.new self, path
  gf.without_groups = without_groups if without_groups
  gf.load
end
            
resolve(set = Gem::Resolver::BestSet.new) click to toggle source

Resolve the requested dependencies and return an Array of Specification objects to be activated.

 
               # File rubygems/request_set.rb, line 232
def resolve set = Gem::Resolver::BestSet.new
  @sets << set
  @sets << @git_set
  @sets << @vendor_set

  set = Gem::Resolver.compose_sets(*@sets)

  resolver = Gem::Resolver.new @dependencies, set
  resolver.development         = @development
  resolver.ignore_dependencies = @ignore_dependencies
  resolver.soft_missing        = @soft_missing

  @resolver = resolver

  @requests = resolver.resolve
end
            
resolve_current() click to toggle source

Resolve the requested dependencies against the gems available via Gem.path and return an Array of Specification objects to be activated.

 
               # File rubygems/request_set.rb, line 253
def resolve_current
  resolve Gem::Resolver::CurrentSet.new
end
            
sorted_requests() click to toggle source
 
               # File rubygems/request_set.rb, line 257
def sorted_requests
  @sorted ||= strongly_connected_components.flatten
end
            
specs() click to toggle source
 
               # File rubygems/request_set.rb, line 261
def specs
  @specs ||= @requests.map { |r| r.full_spec }
end
            
specs_in(dir) click to toggle source
 
               # File rubygems/request_set.rb, line 265
def specs_in dir
  Dir["#{dir}/specifications/*.gemspec"].map do |g|
    Gem::Specification.load g
  end
end
            

Commenting is here to help enhance the documentation. For example, code samples, or clarification of the documentation.

If you have questions about Ruby or the documentation, please post to one of the Ruby mailing lists. You will get better, faster, help that way.

If you wish to post a correction of the docs, please do so, but also file bug report so that it can be corrected for the next release. Thank you.

If you want to help improve the Ruby documentation, please visit Documenting-ruby.org.

blog comments powered by Disqus