123456789_123456789_123456789_123456789_123456789_

Class: Bundler::Source::Rubygems

Relationships & Source Files
Namespace Children
Classes:
Extension / Inclusion / Inheritance Descendants
Subclasses:
Super Chains via Extension / Inclusion / Inheritance
Class Chain:
Instance Chain:
Inherits: Bundler::Source
Defined in: lib/bundler/source/rubygems.rb,
lib/bundler/source/rubygems/remote.rb

Constant Summary

Class Method Summary

Instance Attribute Summary

Instance Method Summary

::Bundler::Source - Inherited

#can_lock?, #dependency_names_to_double_check,
#double_check_for

it’s possible that gems from one source depend on gems from some other source, so now we download gemspecs and iterate over those dependencies, looking for gems we don’t have info on yet.

#extension_cache_path, #include?, #inspect, #unmet_deps, #version_message, #earlier_version?, #extension_cache_slug, #print_using_message, #version_color

Constructor Details

.new(options = {}) ⇒ Rubygems

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 18

def initialize(options = {})
  @options = options
  @remotes = []
  @dependency_names = []
  @allow_remote = false
  @allow_cached = false
  @caches = [cache_path, *Bundler.rubygems.gem_cache]

  Array(options["remotes"] || []).reverse_each {|r| add_remote(r) }
end

Class Method Details

.from_lock(options)

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 62

def self.from_lock(options)
  new(options)
end

Instance Attribute Details

#caches (readonly)

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 16

attr_reader :remotes, :caches

#remotes (readonly)

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 16

attr_reader :remotes, :caches

#requires_sudo?Boolean (readonly, protected)

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 453

def requires_sudo?
  Bundler.requires_sudo?
end

Instance Method Details

#==(other)

Alias for #eql?.

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 47

alias_method :==, :eql?

#add_remote(source)

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 220

def add_remote(source)
  uri = normalize_uri(source)
  @remotes.unshift(uri) unless @remotes.include?(uri)
end

#api_fetchers (protected)

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 381

def api_fetchers
  fetchers.select {|f| f.use_api && f.fetchers.first.api_fetcher? }
end

#builtin_gem?(spec) ⇒ Boolean (protected)

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 441

def builtin_gem?(spec)
  # Ruby 2.1, where all included gems have this summary
  return true if spec.summary =~ /is bundled with Ruby/

  # Ruby 2.0, where gemspecs are stored in specifications/default/
  spec.loaded_from && spec.loaded_from.include?("specifications/default/")
end

#cache(spec, custom_path = nil)

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 192

def cache(spec, custom_path = nil)
  if builtin_gem?(spec)
    cached_path = cached_built_in_gem(spec)
  else
    cached_path = cached_gem(spec)
  end
  raise GemNotFound, "Missing gem file '#{spec.full_name}.gem'." unless cached_path
  return if File.dirname(cached_path) == Bundler.app_cache.to_s
  Bundler.ui.info "  * #{File.basename(cached_path)}"
  FileUtils.cp(cached_path, Bundler.app_cache(custom_path))
rescue Errno::EACCES => e
  Bundler.ui.debug(e)
  raise InstallError, e.message
end

#cache_globally(spec, local_cache_path) (private)

Checks if the requested spec exists in the global cache. If it does not, we create the relevant global cache subdirectory if it does not exist and copy the spec from the local cache to the global cache.

Parameters:

  • spec (Specification)

    the spec we want to copy to the global cache.

  • local_cache_path (String)

    the local directory from which we want to copy the .gem.

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 504

def cache_globally(spec, local_cache_path)
  return unless cache_path = download_cache_path(spec)
  return if cache_path.exist?

  SharedHelpers.filesystem_access(cache_path.dirname, &:mkpath)
  SharedHelpers.filesystem_access(cache_path) do
    FileUtils.cp(local_cache_path, cache_path)
  end
end

#cache_path (protected)

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 461

def cache_path
  Bundler.app_cache
end

#cached!

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 34

def cached!
  @specs = nil
  @allow_cached = true
end

#cached_built_in_gem(spec)

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 207

def cached_built_in_gem(spec)
  cached_path = cached_path(spec)
  if cached_path.nil?
    remote_spec = remote_specs.search(spec).first
    if remote_spec
      cached_path = fetch_gem(remote_spec)
    else
      Bundler.ui.warn "#{spec.full_name} is built in to Ruby, and can't be cached because your Gemfile doesn't have any sources that contain it."
    end
  end
  cached_path
end

#cached_gem(spec) (protected)

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 309

def cached_gem(spec)
  cached_gem = cached_path(spec)
  unless cached_gem
    raise Bundler::GemNotFound, "Could not find #{spec.file_name} for installation"
  end
  cached_gem
end

#cached_path(spec) (protected)

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 317

def cached_path(spec)
  possibilities = @caches.map {|p| "#{p}/#{spec.file_name}" }
  possibilities.find {|p| File.exist?(p) }
end

#cached_specs (protected)

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 362

def cached_specs
  @cached_specs ||= begin
    idx = installed_specs.dup

    Dir["#{cache_path}/*.gem"].each do |gemfile|
      next if gemfile =~ /^bundler\-[\d\.]+?\.gem/
      s ||= Bundler.rubygems.spec_from_gem(gemfile)
      s.source = self
      if Bundler.rubygems.spec_missing_extensions?(s, false)
        Bundler.ui.debug "Source #{self} is ignoring #{s} because it is missing extensions"
        next
      end
      idx << s
    end

    idx
  end
end

#can_lock?(spec) ⇒ Boolean

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 53

def can_lock?(spec)
  return super if Bundler.feature_flag.lockfile_uses_separate_rubygems_sources?
  spec.source.is_a?(Rubygems)
end

#credless_remotes (protected)

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 294

def credless_remotes
  remotes.map(&method(:suppress_configured_credentials))
end

#dependency_names_to_double_check

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 276

def dependency_names_to_double_check
  names = []
  remote_specs.each do |spec|
    case spec
    when EndpointSpecification, Gem::Specification, StubSpecification, LazySpecification
      names.concat(spec.runtime_dependencies)
    when RemoteSpecification # from the full index
      return nil
    else
      raise "unhandled spec type (#{spec.inspect})"
    end
  end
  names.map!(&:name) if names
  names
end

#double_check_for(unmet_dependency_names)

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 257

def double_check_for(unmet_dependency_names)
  return unless @allow_remote
  return unless api_fetchers.any?

  unmet_dependency_names = unmet_dependency_names.call
  unless unmet_dependency_names.nil?
    if api_fetchers.size <= 1
      # can't do this when there are multiple fetchers because then we might not fetch from _all_
      # of them
      unmet_dependency_names -= remote_specs.spec_names # avoid re-fetching things we've already gotten
    end
    return if unmet_dependency_names.empty?
  end

  Bundler.ui.debug "Double checking for #{unmet_dependency_names || "all specs (due to the size of the request)"} in #{self}"

  fetch_names(api_fetchers, unmet_dependency_names, specs, false)
end

#download_cache_path(spec) ⇒ Pathname (private)

Returns the global cache path of the calling Rubygems::Source object.

Note that the ::Bundler::Source determines the path’s subdirectory. We use this subdirectory in the global cache path so that gems with the same name – and possibly different versions – from different sources are saved to their respective subdirectories and do not override one another.

Parameters:

Returns:

  • (Pathname)

    The global cache path.

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 525

def download_cache_path(spec)
  return unless Bundler.feature_flag.global_gem_cache?
  return unless remote = spec.remote
  return unless cache_slug = remote.cache_slug

  Bundler.user_cache.join("gems", cache_slug, spec.file_name)
end

#download_gem(spec, download_path) (private)

Checks if the requested spec exists in the global cache. If it does, we copy it to the download path, and if it does not, we download it.

Parameters:

  • spec (Specification)

    the spec we want to download or retrieve from the cache.

  • download_path (String)

    the local directory the .gem will end up in.

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 476

def download_gem(spec, download_path)
  local_path = File.join(download_path, "cache/#{spec.full_name}.gem")

  if (cache_path = download_cache_path(spec)) && cache_path.file?
    SharedHelpers.filesystem_access(local_path) do
      FileUtils.cp(cache_path, local_path)
    end
  else
    uri = spec.remote.uri
    Bundler.ui.confirm("Fetching #{version_message(spec)}")
    rubygems_local_path = Bundler.rubygems.download_gem(spec, uri, download_path)
    if rubygems_local_path != local_path
      FileUtils.mv(rubygems_local_path, local_path)
    end
    cache_globally(spec, local_path)
  end
end

#eql?(other) ⇒ Boolean Also known as: #==

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 43

def eql?(other)
  other.is_a?(Rubygems) && other.credless_remotes == credless_remotes
end

#equivalent_remotes?(other_remotes) ⇒ Boolean

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 225

def equivalent_remotes?(other_remotes)
  other_remotes.map(&method(:remove_auth)) == @remotes.map(&method(:remove_auth))
end

#extension_cache_slug(spec) (private)

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 533

def extension_cache_slug(spec)
  return unless remote = spec.remote
  remote.cache_slug
end

#fetch_gem(spec) (protected)

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 416

def fetch_gem(spec)
  return false unless spec.remote

  spec.fetch_platform

  download_path = requires_sudo? ? Bundler.tmp(spec.full_name) : rubygems_dir
  gem_path = "#{rubygems_dir}/cache/#{spec.full_name}.gem"

  SharedHelpers.filesystem_access("#{download_path}/cache") do |p|
    FileUtils.mkdir_p(p)
  end
  download_gem(spec, download_path)

  if requires_sudo?
    SharedHelpers.filesystem_access("#{rubygems_dir}/cache") do |p|
      Bundler.mkdir_p(p)
    end
    Bundler.sudo "mv #{download_path}/cache/#{spec.full_name}.gem #{gem_path}"
  end

  gem_path
ensure
  Bundler.rm_rf(download_path) if requires_sudo?
end

#fetch_names(fetchers, dependency_names, index, override_dupes) (protected)

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 403

def fetch_names(fetchers, dependency_names, index, override_dupes)
  fetchers.each do |f|
    if dependency_names
      Bundler.ui.info "Fetching gem metadata from #{f.uri}", Bundler.ui.debug?
      index.use f.specs_with_retry(dependency_names, self), override_dupes
      Bundler.ui.info "" unless Bundler.ui.debug? # new line now that the dots are over
    else
      Bundler.ui.info "Fetching source index from #{f.uri}"
      index.use f.specs_with_retry(nil, self), override_dupes
    end
  end
end

#fetchers

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 250

def fetchers
  @fetchers ||= remotes.map do |uri|
    remote = Source::Rubygems::Remote.new(uri)
    Bundler::Fetcher.new(remote)
  end
end

#hash

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 39

def hash
  @remotes.hash
end

#include?(o) ⇒ Boolean

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 49

def include?(o)
  o.is_a?(Rubygems) && (o.credless_remotes - credless_remotes).empty?
end

#install(spec, opts = {})

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 96

def install(spec, opts = {})
  force = opts[:force]
  ensure_builtin_gems_cached = opts[:ensure_builtin_gems_cached]

  if ensure_builtin_gems_cached && builtin_gem?(spec)
    if !cached_path(spec)
      cached_built_in_gem(spec) unless spec.remote
      force = true
    else
      spec.loaded_from = loaded_from(spec)
    end
  end

  if installed?(spec) && !force
    print_using_message "Using #{version_message(spec)}"
    return nil # no post-install message
  end

  # Download the gem to get the spec, because some specs that are returned
  # by rubygems.org are broken and wrong.
  if spec.remote
    # Check for this spec from other sources
    uris = [spec.remote.anonymized_uri]
    uris += remotes_for_spec(spec).map(&:anonymized_uri)
    uris.uniq!
    Installer.ambiguous_gems << [spec.name, *uris] if uris.length > 1

    s = Bundler.rubygems.spec_from_gem(fetch_gem(spec), Bundler.settings["trust-policy"])
    spec.__swap__(s)
  end

  unless Bundler.settings[:no_install]
    message = "Installing #{version_message(spec)}"
    message += " with native extensions" if spec.extensions.any?
    Bundler.ui.confirm message

    path = cached_gem(spec)
    if requires_sudo?
      install_path = Bundler.tmp(spec.full_name)
      bin_path     = install_path.join("bin")
    else
      install_path = rubygems_dir
      bin_path     = Bundler.system_bindir
    end

    Bundler.mkdir_p bin_path, :no_sudo => true unless spec.executables.empty? || Bundler.rubygems.provides?(">= 2.7.5")

    installed_spec = nil
    Bundler.rubygems.preserve_paths do
      installed_spec = Bundler::RubyGemsGemInstaller.at(
        path,
        :install_dir         => install_path.to_s,
        :bin_dir             => bin_path.to_s,
        :ignore_dependencies => true,
        :wrappers            => true,
        :env_shebang         => true,
        :build_args          => opts[:build_args],
        :bundler_expected_checksum => spec.respond_to?(:checksum) && spec.checksum,
        :bundler_extension_cache_path => extension_cache_path(spec)
      ).install
    end
    spec.full_gem_path = installed_spec.full_gem_path

    # SUDO HAX
    if requires_sudo?
      Bundler.rubygems.repository_subdirectories.each do |name|
        src = File.join(install_path, name, "*")
        dst = File.join(rubygems_dir, name)
        if name == "extensions" && Dir.glob(src).any?
          src = File.join(src, "*/*")
          ext_src = Dir.glob(src).first
          ext_src.gsub!(src[0..-6], "")
          dst = File.dirname(File.join(dst, ext_src))
        end
        SharedHelpers.filesystem_access(dst) do |p|
          Bundler.mkdir_p(p)
        end
        Bundler.sudo "cp -R #{src} #{dst}" if Dir[src].any?
      end

      spec.executables.each do |exe|
        SharedHelpers.filesystem_access(Bundler.system_bindir) do |p|
          Bundler.mkdir_p(p)
        end
        Bundler.sudo "cp -R #{install_path}/bin/#{exe} #{Bundler.system_bindir}/"
      end
    end
    installed_spec.loaded_from = loaded_from(spec)
  end
  spec.loaded_from = loaded_from(spec)

  spec.post_install_message
ensure
  Bundler.rm_rf(install_path) if requires_sudo?
end

#installed?(spec) ⇒ Boolean (protected)

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 449

def installed?(spec)
  installed_specs[spec].any?
end

#installed_specs (protected)

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 348

def installed_specs
  @installed_specs ||= Index.build do |idx|
    Bundler.rubygems.all_specs.reverse_each do |spec|
      next if spec.name == "bundler"
      spec.source = self
      if Bundler.rubygems.spec_missing_extensions?(spec, false)
        Bundler.ui.debug "Source #{self} is ignoring #{spec} because it is missing extensions"
        next
      end
      idx << spec
    end
  end
end

#loaded_from(spec) (protected)

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 305

def loaded_from(spec)
  "#{rubygems_dir}/specifications/#{spec.full_name}.gemspec"
end

#name

Alias for #to_s.

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 82

alias_method :name, :to_s

#normalize_uri(uri) (protected)

Raises:

  • (ArgumentError)
[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 322

def normalize_uri(uri)
  uri = uri.to_s
  uri = "#{uri}/" unless uri =~ %r{/$}
  uri = URI(uri)
  raise ArgumentError, "The source must be an absolute URI. For example:\n" \
    "source 'https://rubygems.org'" if !uri.absolute? || (uri.is_a?(URI::HTTP) && uri.host.nil?)
  uri
end

#options

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 58

def options
  { "remotes" => @remotes.map(&:to_s) }
end

#remote!

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 29

def remote!
  @specs = nil
  @allow_remote = true
end

#remote_specs (protected)

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 385

def remote_specs
  @remote_specs ||= Index.build do |idx|
    index_fetchers = fetchers - api_fetchers

    # gather lists from non-api sites
    fetch_names(index_fetchers, nil, idx, false)

    # because ensuring we have all the gems we need involves downloading
    # the gemspecs of those gems, if the non-api sites contain more than
    # about 500 gems, we treat all sites as non-api for speed.
    allow_api = idx.size < API_REQUEST_LIMIT && dependency_names.size < API_REQUEST_LIMIT
    Bundler.ui.debug "Need to query more than #{API_REQUEST_LIMIT} gems." \
      " Downloading full index instead..." unless allow_api

    fetch_names(api_fetchers, allow_api && dependency_names, idx, false)
  end
end

#remotes_for_spec(spec) (protected)

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 298

def remotes_for_spec(spec)
  specs.search_all(spec.name).inject([]) do |uris, s|
    uris << s.remote if s.remote
    uris
  end
end

#remove_auth(remote) (protected)

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 340

def remove_auth(remote)
  if remote.user || remote.password
    remote.dup.tap {|uri| uri.user = uri.password = nil }.to_s
  else
    remote.to_s
  end
end

#replace_remotes(other_remotes, allow_equivalent = false)

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 229

def replace_remotes(other_remotes, allow_equivalent = false)
  return false if other_remotes == @remotes

  equivalent = allow_equivalent && equivalent_remotes?(other_remotes)

  @remotes = []
  other_remotes.reverse_each do |r|
    add_remote r.to_s
  end

  !equivalent
end

#rubygems_dir (protected)

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 457

def rubygems_dir
  Bundler.rubygems.gem_dir
end

#specs

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 84

def specs
  @specs ||= begin
    # remote_specs usually generates a way larger Index than the other
    # sources, and large_idx.use small_idx is way faster than
    # small_idx.use large_idx.
    idx = @allow_remote ? remote_specs.dup : Index.new
    idx.use(cached_specs, :override_dupes) if @allow_cached || @allow_remote
    idx.use(installed_specs, :override_dupes)
    idx
  end
end

#suppress_configured_credentials(remote) (protected)

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 331

def suppress_configured_credentials(remote)
  remote_nouser = remove_auth(remote)
  if remote.userinfo && remote.userinfo == Bundler.settings[remote_nouser]
    remote_nouser
  else
    remote
  end
end

#to_lock

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 66

def to_lock
  out = String.new("GEM\n")
  remotes.reverse_each do |remote|
    out << "  remote: #{suppress_configured_credentials remote}\n"
  end
  out << "  specs:\n"
end

#to_s Also known as: #name

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 74

def to_s
  if remotes.empty?
    "locally installed gems"
  else
    remote_names = remotes.map(&:to_s).join(", ")
    "rubygems repository #{remote_names} or installed locally"
  end
end

#unmet_deps

[ GitHub ]

  
# File 'lib/bundler/source/rubygems.rb', line 242

def unmet_deps
  if @allow_remote && api_fetchers.any?
    remote_specs.unmet_dependency_names
  else
    []
  end
end