Class: Grit::Repo

Inherits:
Object
  • Object
show all
Defined in:
lib/grit/repo.rb

Constant Summary collapse

DAEMON_EXPORT_FILE = 
'git-daemon-export-ok'

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(path, options = {}) ⇒ Repo

Create a new Repo instance

+path+ is the path to either the root git directory or the bare git repo
+options+ :is_bare force to load a bare repo

Examples

g = Repo.new("/Users/tom/dev/grit")
g = Repo.new("/Users/tom/public/grit.git")

Returns Grit::Repo



23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/grit/repo.rb', line 23

def initialize(path, options = {})
  epath = File.expand_path(path)

  if File.exist?(File.join(epath, '.git'))
    self.working_dir = epath
    self.path = File.join(epath, '.git')
    @bare = false
  elsif File.exist?(epath) && (epath =~ /\.git$/ || options[:is_bare])
    self.path = epath
    @bare = true
  elsif File.exist?(epath)
    raise InvalidGitRepositoryError.new(epath)
  else
    raise NoSuchPathError.new(epath)
  end

  self.git = Git.new(self.path)
end

Instance Attribute Details

#bare ⇒ Object (readonly)

Returns the value of attribute bare.



9
10
11
 
# File 'lib/grit/repo.rb', line 9

def bare
  @bare
end

#git ⇒ Object

The git command line interface object



12
13
14
 
# File 'lib/grit/repo.rb', line 12

def git
  @git
end

#path ⇒ Object

The path of the git repo as a String



7
8
9
 
# File 'lib/grit/repo.rb', line 7

def path
  @path
end

#working_dir ⇒ Object

Returns the value of attribute working_dir.



8
9
10
 
# File 'lib/grit/repo.rb', line 8

def working_dir
  @working_dir
end

Class Method Details

.init(path) ⇒ Object

Does nothing yet…



43
44
45
46
47
48
 
# File 'lib/grit/repo.rb', line 43

def self.init(path)
  # !! TODO !!
  # create directory
  # generate initial git directory
  # create new Grit::Repo on that dir, return it
end

.init_bare(path, git_options = {}, repo_options = {}) ⇒ Object

Initialize a bare git repository at the given path

+path+ is the full path to the repo (traditionally ends with /<name>.git)
+options+ is any additional options to the git init command

Examples

Grit::Repo.init_bare('/var/git/myrepo.git')

Returns Grit::Repo (the newly created repo)



380
381
382
383
384
385
386
 
# File 'lib/grit/repo.rb', line 380

def self.init_bare(path, git_options = {}, repo_options = {})
  git_options = {:bare => true}.merge(git_options)
  git = Git.new(path)
  git.fs_mkdir('..')
  git.init(git_options)
  self.new(path, repo_options)
end

.init_bare_or_open(path, git_options = {}, repo_options = {}) ⇒ Object 



388
389
390
391
392
393
394
395
 
# File 'lib/grit/repo.rb', line 388

def self.init_bare_or_open(path, git_options = {}, repo_options = {})
  git = Git.new(path)
  if !git.exist?
    git.fs_mkdir(path)
    git.init(git_options)
  end
  self.new(path, repo_options)
end

Instance Method Details

#add(*files) ⇒ Object

Adds files to the index



103
104
105
 
# File 'lib/grit/repo.rb', line 103

def add(*files)
  self.git.add({}, *files.flatten)
end

#alternates ⇒ Object

The list of alternates for this repo

Returns Array (pathnames of alternates)



503
504
505
506
507
508
509
510
 
# File 'lib/grit/repo.rb', line 503

def alternates
  alternates_path = "objects/info/alternates"
  if self.git.fs_exist?(alternates_path)
    self.git.fs_read(alternates_path).strip.split("\n")
  else
    []
  end
end

#alternates=(alts) ⇒ Object

Sets the alternates

+alts+ is the Array of String paths representing the alternates

Returns nothing



516
517
518
519
520
521
522
523
524
525
526
527
528
 
# File 'lib/grit/repo.rb', line 516

def alternates=(alts)
  alts.each do |alt|
    unless File.exist?(alt)
      raise "Could not set alternates. Alternate path #{alt} must exist"
    end
  end

  if alts.empty?
    self.git.fs_write('objects/info/alternates', '')
  else
    self.git.fs_write('objects/info/alternates', alts.join("\n"))
  end
end

#archive_tar(treeish = 'master', prefix = nil) ⇒ Object

Archive the given treeish

+treeish+ is the treeish name/id (default 'master')
+prefix+ is the optional prefix

Examples

repo.archive_tar
# => <String containing tar archive>

repo.archive_tar('a87ff14')
# => <String containing tar archive for commit a87ff14>

repo.archive_tar('master', 'myproject/')
# => <String containing tar archive and prefixed with 'myproject/'>

Returns String (containing tar archive)



438
439
440
441
442
 
# File 'lib/grit/repo.rb', line 438

def archive_tar(treeish = 'master', prefix = nil)
  options = {}
  options[:prefix] = prefix if prefix
  self.git.archive(options, treeish)
end

#archive_tar_gz(treeish = 'master', prefix = nil) ⇒ Object

Archive and gzip the given treeish

+treeish+ is the treeish name/id (default 'master')
+prefix+ is the optional prefix

Examples

repo.archive_tar_gz
# => <String containing tar.gz archive>

repo.archive_tar_gz('a87ff14')
# => <String containing tar.gz archive for commit a87ff14>

repo.archive_tar_gz('master', 'myproject/')
# => <String containing tar.gz archive and prefixed with 'myproject/'>

Returns String (containing tar.gz archive)



459
460
461
462
463
 
# File 'lib/grit/repo.rb', line 459

def archive_tar_gz(treeish = 'master', prefix = nil)
  options = {}
  options[:prefix] = prefix if prefix
  self.git.archive(options, treeish, "| gzip -n")
end

#archive_to_file(treeish = 'master', prefix = nil, filename = 'archive.tar.gz', format = nil, pipe = "gzip") ⇒ Object

Write an archive directly to a file

+treeish+ is the treeish name/id (default 'master')
+prefix+ is the optional prefix (default nil)
+filename+ is the name of the file (default 'archive.tar.gz')
+format+ is the optional format (default nil)
+pipe+ is the command to run the output through (default 'gzip')

Returns nothing



473
474
475
476
477
478
 
# File 'lib/grit/repo.rb', line 473

def archive_to_file(treeish = 'master', prefix = nil, filename = 'archive.tar.gz', format = nil, pipe = "gzip")
  options = {}
  options[:prefix] = prefix if prefix
  options[:format] = format if format
  self.git.archive(options, treeish, "| #{pipe} > #{filename}")
end

#blame(file, commit = nil) ⇒ Object 



57
58
59
 
# File 'lib/grit/repo.rb', line 57

def blame(file, commit = nil)
  Blame.new(self, file, commit)
end

#blame_tree(commit, path = nil) ⇒ Object 



113
114
115
116
117
118
119
120
121
 
# File 'lib/grit/repo.rb', line 113

def blame_tree(commit, path = nil)
  commit_array = self.git.blame_tree(commit, path)

  final_array = {}
  commit_array.each do |file, sha|
    final_array[file] = commit(sha)
  end
  final_array
end

#blob(id) ⇒ Object

The Blob object for the given id

+id+ is the SHA1 id of the blob

Returns Grit::Blob (unbaked)



334
335
336
 
# File 'lib/grit/repo.rb', line 334

def blob(id)
  Blob.create(self, :id => id)
end

#commit(id) ⇒ Object

The Commit object for the specified id

+id+ is the SHA1 identifier of the commit

Returns Grit::Commit (baked)



258
259
260
261
262
 
# File 'lib/grit/repo.rb', line 258

def commit(id)
  options = {:max_count => 1}

  Commit.find_all(self, id, options).first
end

#commit_all(message) ⇒ Object

Commits all tracked and modified files

Returns true/false if commit worked



98
99
100
 
# File 'lib/grit/repo.rb', line 98

def commit_all(message)
  self.git.commit({}, '-a', '-m', message)
end

#commit_count(start = 'master') ⇒ Object

The number of commits reachable by the given branch/commit

+start+ is the branch/commit name (default 'master')

Returns Integer



250
251
252
 
# File 'lib/grit/repo.rb', line 250

def commit_count(start = 'master')
  Commit.count(self, start)
end

#commit_deltas_from(other_repo, ref = "master", other_ref = "master") ⇒ Object

Returns a list of commits that is in other_repo but not in self

Returns Grit::Commit[]



267
268
269
270
271
272
273
274
275
276
 
# File 'lib/grit/repo.rb', line 267

def commit_deltas_from(other_repo, ref = "master", other_ref = "master")
  # TODO: we should be able to figure out the branch point, rather than
  # rev-list'ing the whole thing
  repo_refs       = self.git.rev_list({}, ref).strip.split("\n")
  other_repo_refs = other_repo.git.rev_list({}, other_ref).strip.split("\n")

  (other_repo_refs - repo_refs).map do |ref|
    Commit.find_all(other_repo, ref, {:max_count => 1}).first
  end
end

#commit_diff(commit) ⇒ Object

The commit diff for the given commit

+commit+ is the commit name/id

Returns Grit::Diff[]



368
369
370
 
# File 'lib/grit/repo.rb', line 368

def commit_diff(commit)
  Commit.diff(self, commit)
end

#commit_index(message) ⇒ Object

Commits current index

Returns true/false if commit worked



91
92
93
 
# File 'lib/grit/repo.rb', line 91

def commit_index(message)
  self.git.commit({}, '-m', message)
end

#commit_objects(refs) ⇒ Object 



285
286
287
288
289
290
 
# File 'lib/grit/repo.rb', line 285

def commit_objects(refs)
  Grit.no_quote = true
  obj = self.git.rev_list({:timeout => false}, refs).split("\n").map { |a| a[0, 40] }
  Grit.no_quote = false
  obj
end

#commit_stats(start = 'master', max_count = 10, skip = 0) ⇒ Object 



203
204
205
206
207
208
 
# File 'lib/grit/repo.rb', line 203

def commit_stats(start = 'master', max_count = 10, skip = 0)
  options = {:max_count => max_count,
             :skip => skip}

  CommitStats.find_all(self, start, options)
end

#commits(start = 'master', max_count = 10, skip = 0) ⇒ Object

An array of Commit objects representing the history of a given ref/commit

+start+ is the branch/commit name (default 'master')
+max_count+ is the maximum number of commits to return (default 10, use +false+ for all)
+skip+ is the number of commits to skip (default 0)

Returns Grit::Commit[] (baked)



216
217
218
219
220
221
 
# File 'lib/grit/repo.rb', line 216

def commits(start = 'master', max_count = 10, skip = 0)
  options = {:max_count => max_count,
             :skip => skip}

  Commit.find_all(self, start, options)
end

#commits_between(from, to) ⇒ Object

The Commits objects that are reachable via to but not via from Commits are returned in chronological order.

+from+ is the branch/commit name of the younger item
+to+ is the branch/commit name of the older item

Returns Grit::Commit[] (baked)



229
230
231
 
# File 'lib/grit/repo.rb', line 229

def commits_between(from, to)
  Commit.find_all(self, "#{from}..#{to}").reverse
end

#commits_since(start = 'master', since = '1970-01-01', extra_options = {}) ⇒ Object

The Commits objects that are newer than the specified date. Commits are returned in chronological order.

+start+ is the branch/commit name (default 'master')
+since+ is a string represeting a date/time
+extra_options+ is a hash of extra options

Returns Grit::Commit[] (baked)



240
241
242
243
244
 
# File 'lib/grit/repo.rb', line 240

def commits_since(start = 'master', since = '1970-01-01', extra_options = {})
  options = {:since => since}.merge(extra_options)

  Commit.find_all(self, start, options)
end

#config ⇒ Object 



530
531
532
 
# File 'lib/grit/repo.rb', line 530

def config
  @config ||= Config.new(self)
end

#description ⇒ Object

The project’s description. Taken verbatim from GIT_REPO/description

Returns String



53
54
55
 
# File 'lib/grit/repo.rb', line 53

def description
  self.git.fs_read('description').chomp
end

#diff(a, b, *paths) ⇒ Object

The diff from commit a to commit b, optionally restricted to the given file(s)

+a+ is the base commit
+b+ is the other commit
+paths+ is an optional list of file paths on which to restrict the diff



353
354
355
356
357
358
359
360
361
362
 
# File 'lib/grit/repo.rb', line 353

def diff(a, b, *paths)
  diff = self.git.native('diff', {}, a, b, '--', *paths)

  if diff =~ /diff --git a/
    diff = diff.sub(/.+?(diff --git a)/m, '\1')
  else
    diff = ''
  end
  Diff.list_from_string(self, diff)
end

#diff_objects(commit_sha, parents = true) ⇒ Object 



301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
 
# File 'lib/grit/repo.rb', line 301

def diff_objects(commit_sha, parents = true)
  revs = []
  Grit.no_quote = true
  if parents
    # PARENTS:
    cmd = "-r -t -m #{commit_sha}"
    revs = self.git.diff_tree({:timeout => false}, cmd).strip.split("\n").map{ |a| r = a.split(' '); r[3] if r[1] != '160000' }
  else
    # NO PARENTS:
    cmd = "-r -t #{commit_sha}"
    revs = self.git.method_missing('ls-tree', {:timeout => false}, "-r -t #{commit_sha}").split("\n").map{ |a| a.split("\t").first.split(' ')[2] }
  end
  revs << self.commit(commit_sha).tree.id
  Grit.no_quote = false
  return revs.uniq.compact
end

#disable_daemon_serve ⇒ Object

Disable git-daemon serving of this repository by ensuring there is no git-daemon-export-ok file in its git directory

Returns nothing



492
493
494
 
# File 'lib/grit/repo.rb', line 492

def disable_daemon_serve
  self.git.fs_delete(DAEMON_EXPORT_FILE)
end

#enable_daemon_serve ⇒ Object

Enable git-daemon serving of this repository by writing the git-daemon-export-ok file to its git directory

Returns nothing



484
485
486
 
# File 'lib/grit/repo.rb', line 484

def enable_daemon_serve
  self.git.fs_write(DAEMON_EXPORT_FILE, '')
end

#fork_bare(path, options = {}) ⇒ Object

Fork a bare git repository from this repo

+path+ is the full path of the new repo (traditionally ends with /<name>.git)
+options+ is any additional options to the git clone command (:bare and :shared are true by default)

Returns Grit::Repo (the newly forked repo)



402
403
404
405
406
407
408
 
# File 'lib/grit/repo.rb', line 402

def fork_bare(path, options = {})
  default_options = {:bare => true, :shared => true}
  real_options = default_options.merge(options)
  Git.new(path).fs_mkdir('..')
  self.git.clone(real_options, self.path, path)
  Repo.new(path)
end

#fork_bare_from(path, options = {}) ⇒ Object

Fork a bare git repository from another repo

+path+ is the full path of the new repo (traditionally ends with /<name>.git)
+options+ is any additional options to the git clone command (:bare and :shared are true by default)

Returns Grit::Repo (the newly forked repo)



415
416
417
418
419
420
421
 
# File 'lib/grit/repo.rb', line 415

def fork_bare_from(path, options = {})
  default_options = {:bare => true, :shared => true}
  real_options = default_options.merge(options)
  Git.new(self.path).fs_mkdir('..')
  self.git.clone(real_options, path, self.path)
  Repo.new(self.path)
end

#gc_auto ⇒ Object 



496
497
498
 
# File 'lib/grit/repo.rb', line 496

def gc_auto
  self.git.gc({:auto => true})
end

#get_head(head_name) ⇒ Object 



72
73
74
 
# File 'lib/grit/repo.rb', line 72

def get_head(head_name)
  heads.find { |h| h.name == head_name }
end

#head ⇒ Object

Object reprsenting the current repo head.

Returns Grit::Head (baked)



83
84
85
 
# File 'lib/grit/repo.rb', line 83

def head
  Head.current(self)
end

#heads ⇒ Object Also known as: branches

An array of Head objects representing the branch heads in this repo

Returns Grit::Head[] (baked)



66
67
68
 
# File 'lib/grit/repo.rb', line 66

def heads
  Head.find_all(self)
end

#index ⇒ Object 



534
535
536
 
# File 'lib/grit/repo.rb', line 534

def index
  Index.new(self)
end

#inspect ⇒ Object

Pretty object inspection



557
558
559
 
# File 'lib/grit/repo.rb', line 557

def inspect
  %Q{#<Grit::Repo "#{@path}">}
end

#is_head?(head_name) ⇒ Boolean

Returns:

  • (Boolean) 


76
77
78
 
# File 'lib/grit/repo.rb', line 76

def is_head?(head_name)
  get_head(head_name)
end

#log(commit = 'master', path = nil, options = {}) ⇒ Object

The commit log for a treeish

Returns Grit::Commit[]



341
342
343
344
345
346
347
 
# File 'lib/grit/repo.rb', line 341

def log(commit = 'master', path = nil, options = {})
  default_options = {:pretty => "raw"}
  actual_options  = default_options.merge(options)
  arg = path ? [commit, '--', path] : [commit]
  commits = self.git.log(actual_options, *arg)
  Commit.list_from_string(self, commits)
end

#objects(refs) ⇒ Object 



278
279
280
281
282
283
 
# File 'lib/grit/repo.rb', line 278

def objects(refs)
  Grit.no_quote = true
  obj = self.git.rev_list({:objects => true, :timeout => false}, refs).split("\n").map { |a| a[0, 40] }
  Grit.no_quote = false
  obj
end

#objects_between(ref1, ref2 = nil) ⇒ Object 



292
293
294
295
296
297
298
299
 
# File 'lib/grit/repo.rb', line 292

def objects_between(ref1, ref2 = nil)
  if ref2
    refs = "#{ref2}..#{ref1}"
  else
    refs = ref1
  end
  self.objects(refs)
end

#recent_tag_name(committish = nil, options = {}) ⇒ Object

Finds the most recent annotated tag name that is reachable from a commit.

@repo.recent_tag_name('master')
# => "v1.0-0-abcdef"

committish - optional commit SHA, branch, or tag name. options - optional hash of options to pass to git.

Default: {:always => true}
:tags => true      # use lightweight tags too.
:abbrev => Integer # number of hex digits to form the unique
  name.  Defaults to 7.
:long => true      # always output tag + commit sha
# see `git describe` docs for more options.

Returns the String tag name, or just the commit if no tag is found. If there have been updates since the tag was made, a suffix is added with the number of commits since the tag, and the abbreviated object name of the most recent commit. Returns nil if the committish value is not found.



154
155
156
157
 
# File 'lib/grit/repo.rb', line 154

def recent_tag_name(committish = nil, options = {})
  value = git.describe({:always => true}.update(options), committish.to_s).to_s.strip
  value.size.zero? ? nil : value
end

#refs ⇒ Object

An array of Ref objects representing the refs in this repo

Returns Grit::Ref[] (baked)



199
200
201
 
# File 'lib/grit/repo.rb', line 199

def refs
  [ Head.find_all(self), Tag.find_all(self), Remote.find_all(self) ].flatten
end

#remote_add(name, url) ⇒ Object 



171
172
173
 
# File 'lib/grit/repo.rb', line 171

def remote_add(name, url)
  self.git.remote({}, 'add', name, url)
end

#remote_fetch(name) ⇒ Object 



175
176
177
 
# File 'lib/grit/repo.rb', line 175

def remote_fetch(name)
  self.git.fetch({}, name)
end

#remote_list ⇒ Object 



167
168
169
 
# File 'lib/grit/repo.rb', line 167

def remote_list
  self.git.list_remotes
end

#remotes ⇒ Object

An array of Remote objects representing the remote branches in this repo

Returns Grit::Remote[] (baked)



163
164
165
 
# File 'lib/grit/repo.rb', line 163

def remotes
  Remote.find_all(self)
end

#remotes_fetch_needed(remotes) ⇒ Object

takes an array of remote names and last pushed dates fetches from all of the remotes where the local fetch date is earlier than the passed date, then records the last fetched date

{ ‘origin’ => date,

'peter => date,

}



187
188
189
190
191
192
 
# File 'lib/grit/repo.rb', line 187

def remotes_fetch_needed(remotes)
  remotes.each do |remote, date|
    # TODO: check against date
    self.remote_fetch(remote)
  end
end

#remove(*files) ⇒ Object

Remove files from the index



108
109
110
 
# File 'lib/grit/repo.rb', line 108

def remove(*files)
  self.git.rm({}, *files.flatten)
end

#rename(name) ⇒ Object

Rename the current repository directory.

+name+ is the new name

Returns nothing



548
549
550
551
552
553
554
 
# File 'lib/grit/repo.rb', line 548

def rename(name)
  if @bare
    self.git.fs_move('/', "../#{name}")
  else
    self.git.fs_move('/', "../../#{name}")
  end
end

#status ⇒ Object 



123
124
125
 
# File 'lib/grit/repo.rb', line 123

def status
  Status.new(self)
end

#tags ⇒ Object

An array of Tag objects that are available in this repo

Returns Grit::Tag[] (baked)



131
132
133
 
# File 'lib/grit/repo.rb', line 131

def tags
  Tag.find_all(self)
end

#tree(treeish = 'master', paths = []) ⇒ Object

The Tree object for the given treeish reference

+treeish+ is the reference (default 'master')
+paths+ is an optional Array of directory paths to restrict the tree (deafult [])

Examples

repo.tree('master', ['lib/'])

Returns Grit::Tree (baked)



326
327
328
 
# File 'lib/grit/repo.rb', line 326

def tree(treeish = 'master', paths = [])
  Tree.construct(self, treeish, paths)
end

#update_ref(head, commit_sha) ⇒ Object 



538
539
540
541
542
 
# File 'lib/grit/repo.rb', line 538

def update_ref(head, commit_sha)
  return nil if !commit_sha || (commit_sha.size != 40)
  self.git.fs_write("refs/heads/#{head}", commit_sha)
  commit_sha
end