Class: R10K::Git::Rugged::WorkingRepository

Inherits:
BaseRepository show all
Defined in:
lib/r10k/git/rugged/working_repository.rb

Direct Known Subclasses

ThinRepository

Constant Summary

Constants included from Logging

Logging::LOG_LEVELS

Instance Attribute Summary

Attributes inherited from BaseRepository

#path

Instance Method Summary collapse

Methods inherited from BaseRepository

#branches, #ref_type, #remotes, #resolve, #tags

Methods included from Logging

debug_formatter, default_formatter, default_outputter, #logger, #logger_name, parse_level

Constructor Details

#initialize(basedir, dirname) ⇒ WorkingRepository 



14
15
16
 
# File 'lib/r10k/git/rugged/working_repository.rb', line 14

def initialize(basedir, dirname)
  @path = Pathname.new(File.join(basedir, dirname))
end

Instance Method Details

#alternates ⇒ Object 



104
105
106
 
# File 'lib/r10k/git/rugged/working_repository.rb', line 104

def alternates
  R10K::Git::Alternates.new(git_dir)
end

#checkout(ref) ⇒ void

This method returns an undefined value.

Check out the given Git ref



63
64
65
66
67
68
69
70
71
72
73
74
75
76
 
# File 'lib/r10k/git/rugged/working_repository.rb', line 63

def checkout(ref)
  sha = resolve(ref)

  if sha
    logger.debug2 { "Checking out ref '#{ref}' (resolved to SHA '#{sha}') in repository #{@path}" }
  else
    raise R10K::Git::GitError.new("Unable to check out unresolvable ref '#{ref}'", git_dir: git_dir)
  end

  with_repo do |repo|
    repo.checkout(sha)
    repo.reset(sha, :hard)
  end
end

#clone(remote, opts = {}) ⇒ void

This method returns an undefined value.

Clone this git repository



27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
# File 'lib/r10k/git/rugged/working_repository.rb', line 27

def clone(remote, opts = {})
  logger.debug1 { "Cloning '#{remote}' into #{@path}" }

  # libgit2/rugged doesn't support cloning a repository and providing an
  # alternate object database, making the handling of :alternates a noop.
  # Unfortunately this means that this method can't really use alternates
  # and running the clone will duplicate all objects in the specified
  # repository. However alternate databases can be handled when an existing
  # repository is loaded, so loading a cloned repo will correctly use
  # alternate object database.
  options = {:credentials => credentials}
  options.merge!(:alternates => [File.join(opts[:reference], 'objects')]) if opts[:reference]

  proxy = R10K::Git.get_proxy_for_remote(remote)

  R10K::Git.with_proxy(proxy) do
    @_rugged_repo = ::Rugged::Repository.clone_at(remote, @path.to_s, options)
  end

  if opts[:reference]
    alternates << File.join(opts[:reference], 'objects')
  end

  if opts[:ref]
    # todo:  always check out something; since we're fetching a repository we
    # won't populate the working directory.
    checkout(opts[:ref])
  end
rescue Rugged::SshError, Rugged::NetworkError => e
  raise R10K::Git::GitError.new(e.message, :git_dir => git_dir, :backtrace => e.backtrace)
end

#exist? ⇒ Boolean 



96
97
98
 
# File 'lib/r10k/git/rugged/working_repository.rb', line 96

def exist?
  @path.exist?
end

#fetch(remote_name = 'origin') ⇒ Object 



78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
 
# File 'lib/r10k/git/rugged/working_repository.rb', line 78

def fetch(remote_name = 'origin')
  logger.debug1 { "Fetching remote '#{remote_name}' at #{@path}" }
  options = {:credentials => credentials}
  refspecs = ["+refs/heads/*:refs/remotes/#{remote_name}/*"]

  remote = remotes[remote_name]
  proxy = R10K::Git.get_proxy_for_remote(remote)
  results = nil

  R10K::Git.with_proxy(proxy) do
    results = with_repo { |repo| repo.fetch(remote_name, refspecs, options) }
  end

  report_transfer(results, remote)
rescue Rugged::SshError, Rugged::NetworkError => e
  raise R10K::Git::GitError.new(e.message, :git_dir => git_dir, :backtrace => e.backtrace)
end

#git_dir ⇒ Pathname 



8
9
10
 
# File 'lib/r10k/git/rugged/working_repository.rb', line 8

def git_dir
  @path + '.git'
end

#head ⇒ Object 



100
101
102
 
# File 'lib/r10k/git/rugged/working_repository.rb', line 100

def head
  resolve('HEAD')
end

#origin ⇒ Object 



108
109
110
 
# File 'lib/r10k/git/rugged/working_repository.rb', line 108

def origin
  with_repo { |repo| repo.config['remote.origin.url'] }
end