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 /.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)



281
282
283
284
285
 
# File 'lib/grit/repo.rb', line 281

def self.init_bare(path, git_options = {}, repo_options = {})
  git = Git.new(path)
  git.init(git_options)
  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)



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

def alternates
  alternates_path = File.join(self.path, *%w{objects info alternates})
  
  if File.exist?(alternates_path)
    File.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



393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
 
# File 'lib/grit/repo.rb', line 393

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?
    File.open(File.join(self.path, *%w{objects info alternates}), 'w') do |f|
      f.write ''
    end
  else
    File.open(File.join(self.path, *%w{objects info alternates}), 'w') do |f|
      f.write alts.join("\n")
    end
  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

=> 

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)



314
315
316
317
318
 
# File 'lib/grit/repo.rb', line 314

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

=> 

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)



335
336
337
338
339
 
# File 'lib/grit/repo.rb', line 335

def archive_tar_gz(treeish = 'master', prefix = nil)
  options = {}
  options[:prefix] = prefix if prefix
  self.git.archive(options, treeish, "| gzip")
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



349
350
351
352
353
354
 
# File 'lib/grit/repo.rb', line 349

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)



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

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)



206
207
208
209
210
 
# File 'lib/grit/repo.rb', line 206

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



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

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



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

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



269
270
271
 
# File 'lib/grit/repo.rb', line 269

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_stats(start = 'master', max_count = 10, skip = 0) ⇒ Object 



151
152
153
154
155
156
 
# File 'lib/grit/repo.rb', line 151

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)



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

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)



177
178
179
 
# File 'lib/grit/repo.rb', line 177

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)



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

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 



411
412
413
 
# File 'lib/grit/repo.rb', line 411

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
  File.open(File.join(self.path, 'description')).read.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



261
262
263
 
# File 'lib/grit/repo.rb', line 261

def diff(a, b, *paths)
  self.git.diff({}, a, b, '--', *paths)
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



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

def disable_daemon_serve
  FileUtils.rm_f(File.join(self.path, 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



360
361
362
 
# File 'lib/grit/repo.rb', line 360

def enable_daemon_serve
  FileUtils.touch(File.join(self.path, 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 /.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)



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

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

#gc_auto ⇒ Object 



372
373
374
 
# File 'lib/grit/repo.rb', line 372

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 



415
416
417
 
# File 'lib/grit/repo.rb', line 415

def index
  Index.new(self)
end

#inspect ⇒ Object

Pretty object inspection



432
433
434
 
# File 'lib/grit/repo.rb', line 432

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



249
250
251
252
253
254
255
 
# File 'lib/grit/repo.rb', line 249

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

#refs ⇒ Object

An array of Ref objects representing the refs in this repo

Returns Grit::Ref (baked)



147
148
149
 
# File 'lib/grit/repo.rb', line 147

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

#remotes ⇒ Object

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

Returns Grit::Remote (baked)



139
140
141
 
# File 'lib/grit/repo.rb', line 139

def remotes
  Remote.find_all(self)
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

#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)



234
235
236
 
# File 'lib/grit/repo.rb', line 234

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

#update_ref(head, commit_sha) ⇒ Object 



419
420
421
422
423
424
425
426
427
428
429
 
# File 'lib/grit/repo.rb', line 419

def update_ref(head, commit_sha)
  return nil if !commit_sha || (commit_sha.size != 40)
   
  ref_heads = File.join(self.path, 'refs', 'heads')
  FileUtils.mkdir_p(ref_heads)
  File.open(File.join(ref_heads, head), 'w') do |f|
    f.write(commit_sha)
  end
  commit_sha

end