123456789_123456789_123456789_123456789_123456789_

Class: Bundler::Source::Git

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

Constant Summary

Path - Inherited

DEFAULT_GLOB

Class Method Summary

Instance Attribute Summary

Instance Method Summary

Path - Inherited

::Bundler::Source - Inherited

#add_dependency_names, #cached!, #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, #identifier, #include?, #inspect, #local!, #local_only!, #remote!, #spec_names, #unmet_deps, #version_message, #earlier_version?, #extension_cache_slug, #print_using_message, #version_color

Constructor Details

.new(options) ⇒ Git

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 12

def initialize(options)
  @options = options
  @glob = options["glob"] || DEFAULT_GLOB

  @allow_cached = false
  @allow_remote = false

  # Stringify options that could be set as symbols
  %w[ref branch tag revision].each {|k| options[k] = options[k].to_s if options[k] }

  @uri        = URINormalizer.normalize_suffix(options["uri"] || "", :trailing_slash => false)
  @safe_uri   = URICredentialsFilter.credential_filtered_uri(@uri)
  @branch     = options["branch"]
  @ref        = options["ref"] || options["branch"] || options["tag"]
  @submodules = options["submodules"]
  @name       = options["name"]
  @version    = options["version"].to_s.strip.gsub("-", ".pre.")

  @copied     = false
  @local      = false
end

Class Method Details

.from_lock(options)

[ GitHub ]

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

def self.from_lock(options)
  new(options.merge("uri" => options.delete("remote")))
end

Instance Attribute Details

#allow_git_ops?Boolean (readonly)

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 248

def allow_git_ops?
  @allow_remote || @allow_cached
end

#branch (readonly)

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 10

attr_reader :uri, :ref, :branch, :options, :glob, :submodules

#cached?Boolean (readonly, private)

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 342

def cached?
  cache_path.exist?
end

#cached_revision_checked_out?Boolean (readonly, private)

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 300

def cached_revision_checked_out?
  cached_revision && cached_revision == revision && install_path.exist?
end

#default_glob?Boolean (readonly, private)

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 320

def default_glob?
  @glob == DEFAULT_GLOB
end

#glob (readonly)

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 10

attr_reader :uri, :ref, :branch, :options, :glob, :submodules

#has_app_cache?Boolean (readonly, private)

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 292

def has_app_cache?
  cached_revision && super
end

#local?Boolean (readonly)

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 252

def local?
  @local
end

#options (readonly)

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 10

attr_reader :uri, :ref, :branch, :options, :glob, :submodules

#ref (readonly)

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 10

attr_reader :uri, :ref, :branch, :options, :glob, :submodules

#requires_checkout?Boolean (readonly, private)

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 296

def requires_checkout?
  allow_git_ops? && !local? && !cached_revision_checked_out?
end

#submodules (readonly)

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 10

attr_reader :uri, :ref, :branch, :options, :glob, :submodules

#uri (readonly)

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 10

attr_reader :uri, :ref, :branch, :options, :glob, :submodules

Instance Method Details

#==(other)

Alias for #eql?.

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 68

alias_method :==, :eql?

#app_cache_dirname

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 236

def app_cache_dirname
  "#{base_name}-#{shortref_for_path(cached_revision || revision)}"
end

#base_name (private)

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 304

def base_name
  File.basename(uri.sub(%r{^(\w://)?([^/:]:)?(//\w*/)?(\w*/)*}, ""), ".git")
end

#cache(spec, custom_path = nil)

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 206

def cache(spec, custom_path = nil)
  app_cache_path = app_cache_path(custom_path)
  return unless Bundler.feature_flag.cache_all?
  return if path == app_cache_path
  cached!
  FileUtils.rm_rf(app_cache_path)
  git_proxy.checkout if requires_checkout?
  git_proxy.copy_to(app_cache_path, @submodules)
  serialize_gemspecs_in(app_cache_path)
end

#cache_path

This is the path which is going to contain a cache of the git repository. When using the same git repository across different projects, this cache will be shared. When using local git repos, this is set to the local repo.

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 228

def cache_path
  @cache_path ||= if Bundler.feature_flag.global_gem_cache?
    Bundler.user_cache
  else
    Bundler.bundle_path.join("cache", "bundler")
  end.join("git", git_scope)
end

#cached_revision (private)

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 338

def cached_revision
  options["revision"]
end

#current_branch

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 244

def current_branch
  git_proxy.current_branch
end

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

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 61

def eql?(other)
  other.is_a?(Git) && uri == other.uri && ref == other.ref &&
    branch == other.branch && name == other.name &&
    version == other.version && glob == other.glob &&
    submodules == other.submodules
end

#extension_cache_slug(_) (private)

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 370

def extension_cache_slug(_)
  extension_dir_name
end

#extension_dir_name

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 123

def extension_dir_name
  "#{base_name}-#{shortref_for_path(revision)}"
end

#fetch (private)

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 350

def fetch
  git_proxy.checkout
rescue GitError => e
  raise unless Bundler.feature_flag.allow_offline_install?
  Bundler.ui.warn "Using cached git data because of network errors:\n#{e}"
end

#git_proxy (private)

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 346

def git_proxy
  @git_proxy ||= GitProxy.new(cache_path, uri, options, cached_revision, self)
end

#git_scope (private)

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 366

def git_scope
  "#{base_name}-#{uri_hash}"
end

#glob_for_display (private)

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 316

def glob_for_display
  default_glob? ? nil : "glob: #{@glob}"
end

#hash

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 57

def hash
  [self.class, uri, ref, branch, name, version, glob, submodules].hash
end

#humanized_ref (private)

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 258

def humanized_ref
  if local?
    path
  elsif user_ref = options["ref"]
    if /\A[a-z0-9]{4,}\z/i.match?(ref)
      shortref_for_display(user_ref)
    else
      user_ref
    end
  elsif ref
    ref
  end
end

#identifier

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 89

def identifier
  uri_with_specifiers([humanized_ref, cached_revision, glob_for_display])
end

#include?(other) ⇒ Boolean

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 70

def include?(other)
  other.is_a?(Git) && uri == other.uri &&
    name == other.name &&
    glob == other.glob &&
    submodules == other.submodules
end

#install(spec, options = {})

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 187

def install(spec, options = {})
  return if Bundler.settings[:no_install]
  force = options[:force]

  print_using_message "Using #{version_message(spec, options[:previous_spec])} from #{self}"

  if (requires_checkout? && !@copied) || force
    Bundler.ui.debug "  * Checking out revision: #{ref}"
    git_proxy.copy_to(install_path, submodules)
    serialize_gemspecs_in(install_path)
    @copied = true
  end

  generate_bin_options = { :disable_extensions => !Bundler.rubygems.spec_missing_extensions?(spec), :build_args => options[:build_args] }
  generate_bin(spec, generate_bin_options)

  requires_checkout? ? spec.post_install_message : nil
end

#install_path Also known as: #path

This is the path which is going to contain a specific checkout of the git repository. When using local git repos, this is set to the local repo.

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 113

def install_path
  @install_path ||= begin
    git_scope = "#{base_name}-#{shortref_for_path(revision)}"

    Bundler.install_path.join(git_scope)
  end
end

#load_gemspec(file) (private)

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 360

def load_gemspec(file)
  stub = Gem::StubSpecification.gemspec_stub(file, install_path.parent, install_path.parent)
  stub.full_gem_path = Pathname.new(file).dirname.expand_path(root).to_s.tap {|x| x.untaint if RUBY_VERSION < "2.7" }
  StubSpecification.from_stub(stub)
end

#load_spec_files

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 217

def load_spec_files
  super
rescue PathError => e
  Bundler.ui.trace e
  raise GitError, "#{self} is not yet checked out. Run `bundle install` first."
end

#local_override!(path)

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 134

def local_override!(path)
  return false if local?

  original_path = path
  path = Pathname.new(path)
  path = path.expand_path(Bundler.root) unless path.relative?

  unless branch || Bundler.settings[:disable_local_branch_check]
    raise GitError, "Cannot use local override for #{name} at #{path} because " \
      ":branch is not specified in Gemfile. Specify a branch or run " \
      "`bundle config unset local.#{override_for(original_path)}` to remove the local override"
  end

  unless path.exist?
    raise GitError, "Cannot use local override for #{name} because #{path} " \
      "does not exist. Run `bundle config unset local.#{override_for(original_path)}` to remove the local override"
  end

  set_local!(path)

  # Create a new git proxy without the cached revision
  # so the Gemfile.lock always picks up the new revision.
  @git_proxy = GitProxy.new(path, uri, options)

  if current_branch != branch && !Bundler.settings[:disable_local_branch_check]
    raise GitError, "Local override for #{name} at #{path} is using branch " \
      "#{current_branch} but Gemfile specifies #{branch}"
  end

  changed = cached_revision && cached_revision != revision

  if !Bundler.settings[:disable_local_revision_check] && changed && !@unlocked && !git_proxy.contains?(cached_revision)
    raise GitError, "The Gemfile lock is pointing to revision #{shortref_for_display(cached_revision)} " \
      "but the current branch in your local override for #{name} does not contain such commit. " \
      "Please make sure your branch is up to date."
  end

  changed
end

#name

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 106

def name
  File.basename(@uri, ".git")
end

#override_for(path) (private)

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 374

def override_for(path)
  Bundler.settings.local_overrides.key(path)
end

#path

Alias for #install_path.

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 121

alias_method :path, :install_path

#revision

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 240

def revision
  git_proxy.revision
end

#serialize_gemspecs_in(destination) (private)

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 272

def serialize_gemspecs_in(destination)
  destination = destination.expand_path(Bundler.root) if destination.relative?
  Dir["#{destination}/#{@glob}"].each do |spec_path|
    # Evaluate gemspecs and cache the result. Gemspecs
    # in git might require git or other dependencies.
    # The gemspecs we cache should already be evaluated.
    spec = Bundler.load_gemspec(spec_path)
    next unless spec
    Bundler.rubygems.set_installed_by_version(spec)
    Bundler.rubygems.validate(spec)
    File.open(spec_path, "wb") {|file| file.write(spec.to_ruby) }
  end
end

#set_local!(path) (private)

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 286

def set_local!(path)
  @local       = true
  @local_specs = @git_proxy = nil
  @cache_path  = @install_path = path
end

#shortref_for_display(ref) (private)

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 308

def shortref_for_display(ref)
  ref[0..6]
end

#shortref_for_path(ref) (private)

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 312

def shortref_for_path(ref)
  ref[0..11]
end

#specs

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 174

def specs(*)
  set_local!(app_cache_path) if has_app_cache? && !local?

  if requires_checkout? && !@copied
    fetch
    git_proxy.copy_to(install_path, submodules)
    serialize_gemspecs_in(install_path)
    @copied = true
  end

  local_specs
end

#to_gemfile

[ GitHub ]

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

def to_gemfile
  specifiers = %w[ref branch tag submodules glob].map do |opt|
    "#{opt}: #{options[opt]}" if options[opt]
  end

  uri_with_specifiers(specifiers)
end

#to_lock

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 38

def to_lock
  out = String.new("GIT\n")
  out << "  remote: #{@uri}\n"
  out << "  revision: #{revision}\n"
  %w[ref branch tag submodules].each do |opt|
    out << "  #{opt}: #{options[opt]}\n" if options[opt]
  end
  out << "  glob: #{@glob}\n" unless default_glob?
  out << "  specs:\n"
end

#to_s

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 77

def to_s
  begin
    at = humanized_ref || current_branch

    rev = "at #{at}@#{shortref_for_display(revision)}"
  rescue GitError
    ""
  end

  uri_with_specifiers([rev, glob_for_display])
end

#unlock!

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 127

def unlock!
  git_proxy.revision = nil
  options["revision"] = nil

  @unlocked = true
end

#uri_hash (private)

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 324

def uri_hash
  if %r{^\w://(\w@)?}.match?(uri)
    # Downcase the domain component of the URI
    # and strip off a trailing slash, if one is present
    input = Bundler::URI.parse(uri).normalize.to_s.sub(%r{/$}, "")
  else
    # If there is no URI scheme, assume it is an ssh/git URI
    input = uri
  end
  # We use SHA1 here for historical reason and to preserve backward compatibility.
  # But a transition to a simpler mangling algorithm would be welcome.
  Bundler::Digest.sha1(input)
end

#uri_with_specifiers(specifiers)

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 93

def uri_with_specifiers(specifiers)
  specifiers.compact!

  suffix =
    if specifiers.any?
      " (#{specifiers.join(", ")})"
    else
      ""
    end

  "#{@safe_uri}#{suffix}"
end

#validate_spec(_spec) (private)

no-op, since we validate when re-serializing the gemspec

[ GitHub ]

  
# File 'lib/bundler/source/git.rb', line 358

def validate_spec(_spec); end