Class: Gem::Resolver::InstallerSet

Relationships & Source Files
Super Chains via Extension / Inclusion / Inheritance
Class Chain: self, `Set`
Instance Chain: self, `Set`
Inherits:	Gem::Resolver::Set Object Gem::Resolver::Set Gem::Resolver::InstallerSet
Defined in:	lib/rubygems/resolver/installer_set.rb

Overview

A set of gems for installation sourced from remote sources and local .gem files

Class Method Summary

.new(domain) ⇒ InstallerSet constructor

Creates a new InstallerSet that will look for gems in domain.

`Set` - Inherited

.new

Instance Attribute Summary

#prerelease=(allow_prerelease) writeonly
#always_install readonly Internal use only

::Gem::List of ::Gem::Specification objects that must always be installed.
#consider_local? ⇒ Boolean readonly Internal use only

Should local gems should be considered?
#consider_remote? ⇒ Boolean readonly Internal use only

Should remote gems should be considered?
#force rw Internal use only

Ignore ruby & rubygems specification constraints.
#ignore_dependencies rw Internal use only

Only install gems in the always_install list.
#ignore_installed rw Internal use only

Do not look in the installed set when finding specifications.
#remote=(remote) writeonly Internal use only
#remote_set readonly Internal use only

The remote_set looks up remote gems for installation.

`Set` - Inherited

#errors	Errors encountered when resolving gems.
#prerelease	When true, allows matching of requests to prerelease gems.
#remote	`Set` to true to disable network access for this set.
#remote?	When true, this set is allowed to access the network when looking up specifications or dependencies.

Instance Method Summary

#add_always_install(dependency)

Looks up the latest specification for dependency and adds it to the always_install list.
#add_local(dep_name, spec, source)

Adds a local gem requested using dep_name with the given spec that can be loaded and installed using the source.
#errors

Errors encountered while resolving gems.
#find_all(req)

Returns an array of IndexSpecification objects matching DependencyRequest req.
#prefetch(reqs)
#metadata_satisfied?(spec) ⇒ Boolean private
#inspect Internal use only
#load_spec(name, ver, platform, source) Internal use only

Called from IndexSpecification to get a true Specification object.
#local?(dep_name) ⇒ Boolean Internal use only

Has a local gem for dep_name been added to this set?
#pretty_print(q) Internal use only
#ensure_required_ruby_version_met(spec) private Internal use only
#ensure_required_rubygems_version_met(spec) private Internal use only

`Set` - Inherited

#find_all	The find_all method must be implemented.
#prefetch	The #prefetch method may be overridden, but this is not necessary.

Constructor Details

.new(domain) ⇒ `InstallerSet`

Creates a new InstallerSet that will look for gems in domain.

[ GitHub ]

# File 'lib/rubygems/resolver/installer_set.rb', line 37


def initialize(domain)
  super()

  @domain = domain

  @f = Gem::SpecFetcher.fetcher

  @always_install      = []
  @ignore_dependencies = false
  @ignore_installed    = false
  @local               = {}
  @local_source        = Gem::Source::Local.new
  @remote_set          = Gem::Resolver::BestSet.new
  @force               = false
  @specs               = {}
end

Instance Attribute Details

#always_install (readonly)

This method is for internal use only.

::Gem::List of ::Gem::Specification objects that must always be installed.

[ GitHub ]

# File 'lib/rubygems/resolver/installer_set.rb', line 10


attr_reader :always_install # :nodoc:

#consider_local? ⇒ `Boolean` (readonly)

This method is for internal use only.

Should local gems should be considered?

[ GitHub ]

# File 'lib/rubygems/resolver/installer_set.rb', line 113


def consider_local? # :nodoc:
  @domain == :both or @domain == :local
end

#consider_remote? ⇒ `Boolean` (readonly)

This method is for internal use only.

Should remote gems should be considered?

[ GitHub ]

# File 'lib/rubygems/resolver/installer_set.rb', line 120


def consider_remote? # :nodoc:
  @domain == :both or @domain == :remote
end

#force (rw)

This method is for internal use only.

Ignore ruby & rubygems specification constraints.

[ GitHub ]

# File 'lib/rubygems/resolver/installer_set.rb', line 32


attr_accessor :force # :nodoc:

#ignore_dependencies (rw)

This method is for internal use only.

Only install gems in the always_install list

[ GitHub ]

# File 'lib/rubygems/resolver/installer_set.rb', line 15


attr_accessor :ignore_dependencies # :nodoc:

#ignore_installed (rw)

This method is for internal use only.

Do not look in the installed set when finding specifications. This is used by the –install-dir option to gem install

[ GitHub ]

# File 'lib/rubygems/resolver/installer_set.rb', line 21


attr_accessor :ignore_installed # :nodoc:

#prerelease=(allow_prerelease) (writeonly)

[ GitHub ]

# File 'lib/rubygems/resolver/installer_set.rb', line 184


def prerelease=(allow_prerelease)
  super

  @remote_set.prerelease = allow_prerelease
end

#remote=(remote) (writeonly)

This method is for internal use only.

[ GitHub ]

# File 'lib/rubygems/resolver/installer_set.rb', line 236


def remote=(remote) # :nodoc:
  case @domain
  when :local then
    @domain = :both if remote
  when :remote then
    @domain = nil unless remote
  when :both then
    @domain = :local unless remote
  end
end

#remote_set (readonly)

This method is for internal use only.

The remote_set looks up remote gems for installation.

[ GitHub ]

# File 'lib/rubygems/resolver/installer_set.rb', line 26


attr_reader :remote_set # :nodoc:

Instance Method Details

#add_always_install(dependency)

Looks up the latest specification for dependency and adds it to the always_install list.

[ GitHub ]

# File 'lib/rubygems/resolver/installer_set.rb', line 58


def add_always_install(dependency)
  request = Gem::Resolver::DependencyRequest.new dependency, nil

  found = find_all request

  found.delete_if do |s|
    s.version.prerelease? and not s.local?
  end unless dependency.prerelease?

  found = found.select do |s|
    Gem::Source::SpecificFile === s.source or
      Gem::Platform::RUBY == s.platform or
      Gem::Platform.local === s.platform
  end

  found = found.sort_by do |s|
    [s.version, s.platform == Gem::Platform::RUBY ? -1 : 1]
  end

  newest = found.last

  unless @force
    found_matching_metadata = found.reverse.find do |spec|
      metadata_satisfied?(spec)
    end

    if found_matching_metadata.nil?
      if newest
        ensure_required_ruby_version_met(newest.spec)
        ensure_required_rubygems_version_met(newest.spec)
      else
        exc = Gem::UnsatisfiableDependencyError.new request
        exc.errors = errors

        raise exc
      end
    else
      newest = found_matching_metadata
    end
  end

  @always_install << newest.spec
end

#add_local(dep_name, spec, source)

Adds a local gem requested using dep_name with the given spec that can be loaded and installed using the source.

[ GitHub ]

# File 'lib/rubygems/resolver/installer_set.rb', line 106


def add_local(dep_name, spec, source)
  @local[dep_name] = [spec, source]
end

#ensure_required_ruby_version_met(spec) (private)

This method is for internal use only.

[ GitHub ]

# File 'lib/rubygems/resolver/installer_set.rb', line 254


def ensure_required_ruby_version_met(spec) # :nodoc:
  if rrv = spec.required_ruby_version
    ruby_version = Gem.ruby_version
    unless rrv.satisfied_by? ruby_version
      raise Gem::RuntimeRequirementNotMetError,
        "#{spec.full_name} requires Ruby version #{rrv}. The current ruby version is #{ruby_version}."
    end
  end
end

#ensure_required_rubygems_version_met(spec) (private)

This method is for internal use only.

[ GitHub ]

# File 'lib/rubygems/resolver/installer_set.rb', line 264


def ensure_required_rubygems_version_met(spec) # :nodoc:
  if rrgv = spec.required_rubygems_version
    unless rrgv.satisfied_by? Gem.rubygems_version
      rg_version = Gem::VERSION
      raise Gem::RuntimeRequirementNotMetError,
        "#{spec.full_name} requires RubyGems version #{rrgv}. The current RubyGems version is #{rg_version}. " +
        "Try 'gem update --system' to update RubyGems itself."
    end
  end
end

#errors

Errors encountered while resolving gems

[ GitHub ]

# File 'lib/rubygems/resolver/installer_set.rb', line 127


def errors
  @errors + @remote_set.errors
end

#find_all(req)

Returns an array of IndexSpecification objects matching DependencyRequest req.

[ GitHub ]

# File 'lib/rubygems/resolver/installer_set.rb', line 135


def find_all(req)
  res = []

  dep = req.dependency

  return res if @ignore_dependencies and
            @always_install.none? {|spec| dep.match? spec }

  name = dep.name

  dep.matching_specs.each do |gemspec|
    next if @always_install.any? {|spec| spec.name == gemspec.name }

    res << Gem::Resolver::InstalledSpecification.new(self, gemspec)
  end unless @ignore_installed

  if consider_local?
    matching_local = @local.values.select do |spec, _|
      req.match? spec
    end.map do |spec, source|
      Gem::Resolver::LocalSpecification.new self, spec, source
    end

    res.concat matching_local

    begin
      if local_spec = @local_source.find_gem(name, dep.requirement)
        res << Gem::Resolver::IndexSpecification.new(
          self, local_spec.name, local_spec.version,
          @local_source, local_spec.platform)
      end
    rescue Gem::Package::FormatError
      # ignore
    end
  end

  res.delete_if do |spec|
    spec.version.prerelease? and not dep.prerelease?
  end

  res.concat @remote_set.find_all req if consider_remote?

  res
end

#inspect

This method is for internal use only.

[ GitHub ]

# File 'lib/rubygems/resolver/installer_set.rb', line 190


def inspect # :nodoc:
  always_install = @always_install.map {|s| s.full_name }

  '#<%s domain: %s specs: %p always install: %p>' % [
    self.class, @domain, @specs.keys, always_install
  ]
end

#load_spec(name, ver, platform, source)

This method is for internal use only.

Called from IndexSpecification to get a true Specification object.

[ GitHub ]

# File 'lib/rubygems/resolver/installer_set.rb', line 202


def load_spec(name, ver, platform, source) # :nodoc:
  key = "#{name}-#{ver}-#{platform}"

  @specs.fetch key do
    tuple = Gem::NameTuple.new name, ver, platform

    @specs[key] = source.fetch_spec tuple
  end
end

#local?(dep_name) ⇒ `Boolean`

This method is for internal use only.

Has a local gem for dep_name been added to this set?

[ GitHub ]

# File 'lib/rubygems/resolver/installer_set.rb', line 215


def local?(dep_name) # :nodoc:
  spec, _ = @local[dep_name]

  spec
end

#metadata_satisfied?(spec) ⇒ `Boolean` (private)

[ GitHub ]

# File 'lib/rubygems/resolver/installer_set.rb', line 249


def metadata_satisfied?(spec)
  spec.required_ruby_version.satisfied_by?(Gem.ruby_version) &&
    spec.required_rubygems_version.satisfied_by?(Gem.rubygems_version)
end

#prefetch(reqs)

[ GitHub ]

# File 'lib/rubygems/resolver/installer_set.rb', line 180


def prefetch(reqs)
  @remote_set.prefetch(reqs) if consider_remote?
end

#pretty_print(q)

This method is for internal use only.

[ GitHub ]

# File 'lib/rubygems/resolver/installer_set.rb', line 221


def pretty_print(q) # :nodoc:
  q.group 2, '[InstallerSet', ']' do
    q.breakable
    q.text "domain: #{@domain}"

    q.breakable
    q.text 'specs: '
    q.pp @specs.keys

    q.breakable
    q.text 'always install: '
    q.pp @always_install
  end
end

Class: Gem::Resolver::InstallerSet

Overview

Class Method Summary

Set - Inherited

Instance Attribute Summary

Set - Inherited

Instance Method Summary

Set - Inherited

Constructor Details

.new(domain) ⇒ InstallerSet

Instance Attribute Details

#always_install (readonly)

#consider_local? ⇒ Boolean (readonly)

#consider_remote? ⇒ Boolean (readonly)

#force (rw)

#ignore_dependencies (rw)

#ignore_installed (rw)

#prerelease=(allow_prerelease) (writeonly)

#remote=(remote) (writeonly)

#remote_set (readonly)

Instance Method Details

#add_always_install(dependency)

#add_local(dep_name, spec, source)

#ensure_required_ruby_version_met(spec) (private)

#ensure_required_rubygems_version_met(spec) (private)

#errors

#find_all(req)

#inspect

#load_spec(name, ver, platform, source)

#local?(dep_name) ⇒ Boolean

#metadata_satisfied?(spec) ⇒ Boolean (private)

#prefetch(reqs)

#pretty_print(q)

`Set` - Inherited

`Set` - Inherited

`Set` - Inherited

.new(domain) ⇒ `InstallerSet`

#consider_local? ⇒ `Boolean` (readonly)

#consider_remote? ⇒ `Boolean` (readonly)

#local?(dep_name) ⇒ `Boolean`

#metadata_satisfied?(spec) ⇒ `Boolean` (private)