class Gem::DependencyInstaller - Documentation for Ruby 4.0
Description: class Gem::DependencyInstaller: Installs a gem along with all its dependencies from local and remote gems.
Keywords: ruby,class,Gem::DependencyInstaller

🔍

No recent searches

# 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 = {})
Source

    # File lib/rubygems/dependency_installer.rb, line 65
    def initialize(options = {})
      @only_install_dir = !options[:install_dir].nil?
      @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_jobs          = options[:build_jobs]
      @build_docs_in_background = options[:build_docs_in_background]
      @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

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`

### Public Instance Methods

consider_local? ()
Source

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

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

consider_remote? ()
Source

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

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

install (dep_or_name, version = Gem::Requirement.default)
Source

    # File lib/rubygems/dependency_installer.rb, line 150
    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,
        build_jobs: @build_jobs,
        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,
        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

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.