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
  @checksum_store = Checksum::Store.new
  @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 49

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 263

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 357

def cached?
  cache_path.exist?
end

#cached_revision_checked_out?Boolean (readonly, private)

[ GitHub ]

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

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 335

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 307

def has_app_cache?
  cached_revision && super
end

#local?Boolean (readonly)

[ GitHub ]

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

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 311

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 83

alias_method :==, :eql?

#app_cache_dirname

[ GitHub ]

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

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

#base_name (private)

[ GitHub ]

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

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 221

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 243

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!

[ GitHub ]

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

def cached!
  return if @allow_cached

  @local_specs = nil
  @allow_cached = true
end

#cached_revision (private)

[ GitHub ]

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

def cached_revision
  options["revision"]
end

#current_branch

[ GitHub ]

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

def current_branch
  git_proxy.current_branch
end

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

[ GitHub ]

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

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 385

def extension_cache_slug(_)
  extension_dir_name
end

#extension_dir_name

[ GitHub ]

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

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

#fetch (private)

[ GitHub ]

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

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 361

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 381

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

#glob_for_display (private)

[ GitHub ]

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

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

#hash

[ GitHub ]

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

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

#humanized_ref (private)

[ GitHub ]

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

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 104

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

#include?(other) ⇒ Boolean

[ GitHub ]

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

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 202

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 128

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 375

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
  StubSpecification.from_stub(stub)
end

#load_spec_files

[ GitHub ]

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

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 149

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 121

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

#override_for(path) (private)

[ GitHub ]

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

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

#path

Alias for #install_path.

[ GitHub ]

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

alias_method :path, :install_path

#remote!

[ GitHub ]

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

def remote!
  return if @allow_remote

  @local_specs = nil
  @allow_remote = true
end

#revision

[ GitHub ]

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

def revision
  git_proxy.revision
end

#serialize_gemspecs_in(destination) (private)

[ GitHub ]

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

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 301

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 323

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

#shortref_for_path(ref) (private)

[ GitHub ]

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

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

#specs

[ GitHub ]

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

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 64

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 53

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 92

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 142

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

  @unlocked = true
end

#uri_hash (private)

[ GitHub ]

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

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 = Gem::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 108

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 373

def validate_spec(_spec); end