Class: Gem::DependencyInstaller

Inherits:
Object
  • Object
show all
Includes:
UserInteraction
Defined in:
lib/rubygems/dependency_installer.rb

Overview

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

Constant Summary collapse

DEFAULT_OPTIONS =
{
  :env_shebang         => false,
  :document            => %w[ri],
  :domain              => :both, # HACK dup
  :force               => false,
  :format_executable   => false, # HACK dup
  :ignore_dependencies => false,
  :prerelease          => false,
  :security_policy     => nil, # HACK NoSecurity requires OpenSSL. AlmostNo? Low?
  :wrappers            => true,
  :build_args          => nil,
  :build_docs_in_background => false,
}.freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from UserInteraction

#alert, #alert_error, #alert_warning, #ask, #ask_for_password, #ask_yes_no, #choose_from_list, #say, #terminate_interaction

Methods included from DefaultUserInteraction

ui, #ui, ui=, #ui=, use_ui, #use_ui

Constructor Details

#initialize(options = {}) ⇒ DependencyInstaller

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



59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
# File 'lib/rubygems/dependency_installer.rb', line 59

def initialize(options = {})
  @install_dir = options[:install_dir] || Gem.dir

  if options[:install_dir] then
    # HACK shouldn't change the global settings, needed for -i behavior
    # maybe move to the install command?  See also github #442
    Gem::Specification.dirs = @install_dir
    Gem.ensure_gem_subdirectories @install_dir
  end

  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]

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

  @installed_gems = []
  @toplevel_specs = nil

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

  # Set with any errors that SpecFetcher finds while search through
  # gemspecs for a dep
  @errors = nil
end

Instance Attribute Details

#documentObject (readonly)

Documentation types. For use by the Gem.done_installing hook



24
25
26
# File 'lib/rubygems/dependency_installer.rb', line 24

def document
  @document
end

#errorsObject (readonly)

Returns the value of attribute errors



101
102
103
# File 'lib/rubygems/dependency_installer.rb', line 101

def errors
  @errors
end

#gems_to_installObject (readonly)

Returns the value of attribute gems_to_install



18
19
20
# File 'lib/rubygems/dependency_installer.rb', line 18

def gems_to_install
  @gems_to_install
end

#installed_gemsObject (readonly)

Returns the value of attribute installed_gems



19
20
21
# File 'lib/rubygems/dependency_installer.rb', line 19

def installed_gems
  @installed_gems
end

Instance Method Details

#add_found_dependencies(to_do, dependency_list) ⇒ Object



201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
# File 'lib/rubygems/dependency_installer.rb', line 201

def add_found_dependencies to_do, dependency_list
  seen = {}
  dependencies = Hash.new { |h, name| h[name] = Gem::Dependency.new name }

  until to_do.empty? do
    spec = to_do.shift

    # HACK why is spec nil?
    next if spec.nil? or seen[spec.name]
    seen[spec.name] = true

    deps = spec.runtime_dependencies

    if @development
      if @dev_shallow
        if @toplevel_specs.include? spec.full_name
          deps |= spec.development_dependencies
        end
      else
        deps |= spec.development_dependencies
      end
    end

    deps.each do |dep|
      dependencies[dep.name] = dependencies[dep.name].merge dep

      if @minimal_deps
        next if Gem::Specification.any? do |installed_spec|
                  dep.name == installed_spec.name and
                    dep.requirement.satisfied_by? installed_spec.version
                end
      end

      results = find_gems_with_sources(dep)

      results.sorted.each do |t|
        to_do.push t.spec
      end

      results.remove_installed! dep

      @available << results
      results.inject_into_list dependency_list
    end
  end

  dependency_list.remove_specs_unsatisfied_by dependencies
end

#consider_local?Boolean

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

Returns:

  • (Boolean)


107
108
109
# File 'lib/rubygems/dependency_installer.rb', line 107

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

#consider_remote?Boolean

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

Returns:

  • (Boolean)


115
116
117
# File 'lib/rubygems/dependency_installer.rb', line 115

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

#find_gems_with_sources(dep) ⇒ Object

Returns a list of pairs of gemspecs and source_uris that match Gem::Dependency dep from both local (Dir.pwd) and remote (Gem.sources) sources. Gems are sorted with newer gems preferred over older gems, and local gems preferred over remote gems.



125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
# File 'lib/rubygems/dependency_installer.rb', line 125

def find_gems_with_sources(dep)
  set = Gem::AvailableSet.new

  if consider_local?
    sl = Gem::Source::Local.new

    if spec = sl.find_gem(dep.name)
      if dep.matches_spec? spec
        set.add spec, sl
      end
    end
  end

  if consider_remote?
    begin
      found, errors = Gem::SpecFetcher.fetcher.spec_for_dependency dep

      if @errors
        @errors += errors
      else
        @errors = errors
      end

      set << found

    rescue Gem::RemoteFetcher::FetchError => e
      # FIX if there is a problem talking to the network, we either need to always tell
      # the user (no really_verbose) or fail hard, not silently tell them that we just
      # couldn't find their requested gem.
      if Gem.configuration.really_verbose then
        say "Error fetching remote data:\t\t#{e.message}"
        say "Falling back to local-only install"
      end
      @domain = :local
    end
  end

  set
end

#find_spec_by_name_and_version(gem_name, version = Gem::Requirement.default, prerelease = false) ⇒ Object

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.



255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
# File 'lib/rubygems/dependency_installer.rb', line 255

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 then
      src = Gem::Source::SpecificFile.new(gem_name)
      set.add src.spec, src
    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
    # HACK Dependency objects should be immutable
    dep.prerelease = true if prerelease

    set = find_gems_with_sources(dep)
    set.match_platform!
  end

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

  @available = set
end

#gather_dependenciesObject

Gathers all dependencies necessary for the installation from local and remote sources unless the ignore_dependencies was given.



169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
# File 'lib/rubygems/dependency_installer.rb', line 169

def gather_dependencies
  specs = @available.all_specs

  # these gems were listed by the user, always install them
  keep_names = specs.map { |spec| spec.full_name }

  if @dev_shallow
    @toplevel_specs = keep_names
  end

  dependency_list = Gem::DependencyList.new @development
  dependency_list.add(*specs)
  to_do = specs.dup
  add_found_dependencies to_do, dependency_list unless @ignore_dependencies

  # REFACTOR maybe abstract away using Gem::Specification.include? so
  # that this isn't dependent only on the currently installed gems
  dependency_list.specs.reject! { |spec|
    not keep_names.include?(spec.full_name) and
    Gem::Specification.include?(spec)
  }

  unless dependency_list.ok? or @ignore_dependencies or @force then
    reason = dependency_list.why_not_ok?.map { |k,v|
      "#{k} requires #{v.join(", ")}"
    }.join("; ")
    raise Gem::DependencyError, "Unable to resolve dependencies: #{reason}"
  end

  @gems_to_install = dependency_list.dependency_order.reverse
end

#in_background(what) ⇒ Object



381
382
383
384
385
386
387
388
389
390
391
392
393
394
# File 'lib/rubygems/dependency_installer.rb', line 381

def in_background what
  fork_happened = false
  if @build_docs_in_background and Process.respond_to?(:fork)
    begin
      Process.fork do
        yield
      end
      fork_happened = true
      say "#{what} in a background process."
    rescue NotImplementedError
    end
  end
  yield unless fork_happened
end

#install(dep_or_name, version = Gem::Requirement.default) ⇒ Object

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.



304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
# File 'lib/rubygems/dependency_installer.rb', line 304

def install dep_or_name, version = Gem::Requirement.default
  if String === dep_or_name then
    find_spec_by_name_and_version dep_or_name, version, @prerelease
  else
    dep = dep_or_name.dup
    dep.prerelease = @prerelease
    @available = find_gems_with_sources(dep).pick_best!
  end

  @installed_gems = []

  gather_dependencies

  # REFACTOR is the last gem always the one that the user requested?
  # This code assumes that but is that actually validated by the code?

  last = @gems_to_install.size - 1
  @gems_to_install.each_with_index do |spec, index|
    # REFACTOR more current spec set hardcoding, should be abstracted?
    next if Gem::Specification.include?(spec) and index != last

    # TODO: make this sorta_verbose so other users can benefit from it
    say "Installing gem #{spec.full_name}" if Gem.configuration.really_verbose

    source = @available.source_for spec

    begin
      # REFACTOR make the fetcher to use configurable
      local_gem_path = source.download spec, @cache_dir
    rescue Gem::RemoteFetcher::FetchError
      # TODO I doubt all fetch errors are recoverable, we should at least
      # report the errors probably.
      next if @force
      raise
    end

    if @development
      if @dev_shallow
        is_dev = @toplevel_specs.include? spec.full_name
      else
        is_dev = true
      end
    end

    inst = Gem::Installer.new local_gem_path,
                              :bin_dir             => @bin_dir,
                              :development         => is_dev,
                              :env_shebang         => @env_shebang,
                              :force               => @force,
                              :format_executable   => @format_executable,
                              :ignore_dependencies => @ignore_dependencies,
                              :install_dir         => @install_dir,
                              :security_policy     => @security_policy,
                              :user_install        => @user_install,
                              :wrappers            => @wrappers,
                              :build_args          => @build_args

    spec = inst.install

    @installed_gems << spec
  end

  # 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
    start = Time.now
    Gem.done_installing_hooks.each do |hook|
      hook.call self, @installed_gems
    end
    finish = Time.now
    say "Done installing documentation for #{@installed_gems.map(&:name).join(', ')} (#{(finish-start).to_i} sec)."
  end unless Gem.done_installing_hooks.empty?

  @installed_gems
end