# class Gem::DependencyInstaller

Installs a gem along with all its dependencies from local and remote gems.

### Attributes

document[R]

Documentation types. For use by the `Gem.done_installing` hook

errors[R]

Errors from SpecFetcher while searching for remote specifications

installed_gems[R]

List of gems installed by `install` in alphabetic order

### Public Class Methods

new(options = {}) click to toggle source

Creates a new installer instance.

Options are:

:cache_dir

  Alternate repository path to store .gem files in.

:domain

  :local, :remote, or :both. :local only searches gems in the current directory. :remote searches only gems in `Gem::sources`. :both searches both.

:env_shebang

  See `Gem::Installer::new`.

:force

  See `Gem::Installer#install`.

:format_executable

  See Gem::Installer#initialize.

:ignore_dependencies

  Don't install any dependencies.

:install_dir

  See `Gem::Installer#install`.

:prerelease

  Allow prerelease versions. See `install`.

:security_policy

  See `Gem::Installer::new` and `Gem::Security`.

:user_install

  See `Gem::Installer.new`

:wrappers

  See `Gem::Installer::new`

:build_args

  See `Gem::Installer::new`

    # File lib/rubygems/dependency_installer.rb, line 69
    def initialize(options = {})
      @only_install_dir = !!options[:install_dir]
      @install_dir = options[:install_dir] || Gem.dir
      @build_root = options[:build_root]

      options = DEFAULT_OPTIONS.merge options

      @bin_dir             = options[:bin_dir]
      @dev_shallow         = options[:dev_shallow]
      @development         = options[:development]
      @document            = options[:document]
      @domain              = options[:domain]
      @env_shebang         = options[:env_shebang]
      @force               = options[:force]
      @format_executable   = options[:format_executable]
      @ignore_dependencies = options[:ignore_dependencies]
      @prerelease          = options[:prerelease]
      @security_policy     = options[:security_policy]
      @user_install        = options[:user_install]
      @wrappers            = options[:wrappers]
      @build_args          = options[:build_args]
      @build_docs_in_background = options[:build_docs_in_background]
      @install_as_default = options[:install_as_default]
      @dir_mode = options[:dir_mode]
      @data_mode = options[:data_mode]
      @prog_mode = options[:prog_mode]

      # Indicates that we should not try to update any deps unless
      # we absolutely must.
      @minimal_deps = options[:minimal_deps]

      @available      = nil
      @installed_gems = []
      @toplevel_specs = nil

      @cache_dir = options[:cache_dir] || @install_dir

      @errors = []
    end

### Public Instance Methods

consider_local?() click to toggle source

Indicated, based on the requested domain, if local gems should be considered.

    # File lib/rubygems/dependency_installer.rb, line 134
    def consider_local?
      @domain == :both or @domain == :local
    end

consider_remote?() click to toggle source

Indicated, based on the requested domain, if remote gems should be considered.

    # File lib/rubygems/dependency_installer.rb, line 142
    def consider_remote?
      @domain == :both or @domain == :remote
    end

find_spec_by_name_and_version(gem_name, version = Gem::Requirement.default, prerelease = false) click to toggle source

Finds a spec and the source_uri it came from for gem `gem_name` and `version`. Returns an `Array` of specs and sources required for installation of the gem.

    # File lib/rubygems/dependency_installer.rb, line 226
    def find_spec_by_name_and_version(gem_name,
                                      version = Gem::Requirement.default,
                                      prerelease = false)
      set = Gem::AvailableSet.new

      if consider_local?
        if gem_name =~ /\.gem$/ and File.file? gem_name
          src = Gem::Source::SpecificFile.new(gem_name)
          set.add src.spec, src
        elsif gem_name =~ /\.gem$/
          Dir[gem_name].each do |name|
            begin
              src = Gem::Source::SpecificFile.new name
              set.add src.spec, src
            rescue Gem::Package::FormatError
            end
          end
        else
          local = Gem::Source::Local.new

          if s = local.find_gem(gem_name, version)
            set.add s, local
          end
        end
      end

      if set.empty?
        dep = Gem::Dependency.new gem_name, version
        dep.prerelease = true if prerelease

        set = Gem::Deprecate.skip_during do
          find_gems_with_sources(dep, true)
        end

        set.match_platform!
      end

      if set.empty?
        raise Gem::SpecificGemNotFoundException.new(gem_name, version, @errors)
      end

      @available = set
    end

install(dep_or_name, version = Gem::Requirement.default) click to toggle source

Installs the gem `dep_or_name` and all its dependencies. Returns an `Array` of installed gem specifications.

If the `:prerelease` option is set and there is a prerelease for `dep_or_name` the prerelease version will be installed.

Unless explicitly specified as a prerelease dependency, prerelease gems that `dep_or_name` depend on will not be installed.

If c-1.a depends on b-1 and a-1.a and there is a gem b-1.a available then c-1.a, b-1 and a-1.a will be installed. b-1.a will need to be installed separately.

    # File lib/rubygems/dependency_installer.rb, line 300
    def install(dep_or_name, version = Gem::Requirement.default)
      request_set = resolve_dependencies dep_or_name, version

      @installed_gems = []

      options = {
        :bin_dir             => @bin_dir,
        :build_args          => @build_args,
        :document            => @document,
        :env_shebang         => @env_shebang,
        :force               => @force,
        :format_executable   => @format_executable,
        :ignore_dependencies => @ignore_dependencies,
        :prerelease          => @prerelease,
        :security_policy     => @security_policy,
        :user_install        => @user_install,
        :wrappers            => @wrappers,
        :build_root          => @build_root,
        :install_as_default  => @install_as_default,
        :dir_mode            => @dir_mode,
        :data_mode           => @data_mode,
        :prog_mode           => @prog_mode,
      }
      options[:install_dir] = @install_dir if @only_install_dir

      request_set.install options do |_, installer|
        @installed_gems << installer.spec if installer
      end

      @installed_gems.sort!

      # Since this is currently only called for docs, we can be lazy and just say
      # it's documentation. Ideally the hook adder could decide whether to be in
      # the background or not, and what to call it.
      in_background "Installing documentation" do
        Gem.done_installing_hooks.each do |hook|
          hook.call self, @installed_gems
        end
      end unless Gem.done_installing_hooks.empty?

      @installed_gems
    end