class Bundler::Source::Rubygems
Constants
- API_REQUEST_LIMIT
Use the API when installing less than X gems
- API_REQUEST_SIZE
Ask for X gems per API request
Attributes
Public Class Methods
# File lib/bundler/source/rubygems.rb, line 61 def self.from_lock(options) new(options) end
# File lib/bundler/source/rubygems.rb, line 17 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
Public Instance Methods
# File lib/bundler/source/rubygems.rb, line 219 def add_remote(source) uri = normalize_uri(source) @remotes.unshift(uri) unless @remotes.include?(uri) end
# File lib/bundler/source/rubygems.rb, line 191 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
# File lib/bundler/source/rubygems.rb, line 33 def cached! @specs = nil @allow_cached = true end
# File lib/bundler/source/rubygems.rb, line 206 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
# File lib/bundler/source/rubygems.rb, line 52 def can_lock?(spec) return super if Bundler.feature_flag.lockfile_uses_separate_rubygems_sources? spec.source.is_a?(Rubygems) end
# File lib/bundler/source/rubygems.rb, line 275 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
# File lib/bundler/source/rubygems.rb, line 256 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
# File lib/bundler/source/rubygems.rb, line 42 def eql?(other) other.is_a?(Rubygems) && other.credless_remotes == credless_remotes end
# File lib/bundler/source/rubygems.rb, line 224 def equivalent_remotes?(other_remotes) other_remotes.map(&method(:remove_auth)) == @remotes.map(&method(:remove_auth)) end
# File lib/bundler/source/rubygems.rb, line 249 def fetchers @fetchers ||= remotes.map do |uri| remote = Source::Rubygems::Remote.new(uri) Bundler::Fetcher.new(remote) end end
# File lib/bundler/source/rubygems.rb, line 38 def hash @remotes.hash end
# File lib/bundler/source/rubygems.rb, line 48 def include?(o) o.is_a?(Rubygems) && (o.credless_remotes - credless_remotes).empty? end
# File lib/bundler/source/rubygems.rb, line 95 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
# File lib/bundler/source/rubygems.rb, line 57 def options { "remotes" => @remotes.map(&:to_s) } end
# File lib/bundler/source/rubygems.rb, line 28 def remote! @specs = nil @allow_remote = true end
# File lib/bundler/source/rubygems.rb, line 228 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
# File lib/bundler/source/rubygems.rb, line 83 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
# File lib/bundler/source/rubygems.rb, line 65 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
# File lib/bundler/source/rubygems.rb, line 73 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
# File lib/bundler/source/rubygems.rb, line 241 def unmet_deps if @allow_remote && api_fetchers.any? remote_specs.unmet_dependency_names else [] end end
Protected Instance Methods
# File lib/bundler/source/rubygems.rb, line 380 def api_fetchers fetchers.select {|f| f.use_api && f.fetchers.first.api_fetcher? } end
# File lib/bundler/source/rubygems.rb, line 440 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
# File lib/bundler/source/rubygems.rb, line 460 def cache_path Bundler.app_cache end
# File lib/bundler/source/rubygems.rb, line 308 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
# File lib/bundler/source/rubygems.rb, line 316 def cached_path(spec) possibilities = @caches.map {|p| "#{p}/#{spec.file_name}" } possibilities.find {|p| File.exist?(p) } end
# File lib/bundler/source/rubygems.rb, line 361 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
# File lib/bundler/source/rubygems.rb, line 293 def credless_remotes remotes.map(&method(:suppress_configured_credentials)) end
# File lib/bundler/source/rubygems.rb, line 415 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
# File lib/bundler/source/rubygems.rb, line 402 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
# File lib/bundler/source/rubygems.rb, line 448 def installed?(spec) installed_specs[spec].any? end
# File lib/bundler/source/rubygems.rb, line 347 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
# File lib/bundler/source/rubygems.rb, line 304 def loaded_from(spec) "#{rubygems_dir}/specifications/#{spec.full_name}.gemspec" end
# File lib/bundler/source/rubygems.rb, line 321 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
# File lib/bundler/source/rubygems.rb, line 384 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
# File lib/bundler/source/rubygems.rb, line 297 def remotes_for_spec(spec) specs.search_all(spec.name).inject([]) do |uris, s| uris << s.remote if s.remote uris end end
# File lib/bundler/source/rubygems.rb, line 339 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
# File lib/bundler/source/rubygems.rb, line 452 def requires_sudo? Bundler.requires_sudo? end
# File lib/bundler/source/rubygems.rb, line 456 def rubygems_dir Bundler.rubygems.gem_dir end
# File lib/bundler/source/rubygems.rb, line 330 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
Private Instance Methods
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.
@param [Specification] spec
the spec we want to copy to the global cache.
@param [String] local_cache_path
the local directory from which we want to copy the .gem.
# File lib/bundler/source/rubygems.rb, line 503 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
Returns the global cache path of the calling Rubygems::Source object.
Note that the 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.
@param [Gem::Specification] specification
@return [Pathname] The global cache path.
# File lib/bundler/source/rubygems.rb, line 524 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
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.
@param [Specification] spec
the spec we want to download or retrieve from the cache.
@param [String] download_path
the local directory the .gem will end up in.
# File lib/bundler/source/rubygems.rb, line 475 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
# File lib/bundler/source/rubygems.rb, line 532 def extension_cache_slug(spec) return unless remote = spec.remote remote.cache_slug end