Class: Git::Base

Inherits:
Object
  • Object
show all
Defined in:
lib/git/base.rb

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(options = {}) ⇒ Base

Returns a new instance of Base.



69
70
71
72
73
74
75
76
77
78
79
80
81
82
 
# File 'lib/git/base.rb', line 69

def initialize(options = {})
  if working_dir = options[:working_directory]
    options[:repository] = File.join(working_dir, '.git') if !options[:repository]
    options[:index] = File.join(working_dir, '.git', 'index') if !options[:index]
  end
  if options[:log]
    @logger = options[:log]
    @logger.info("Starting Git")
  end
  
  @working_directory = Git::WorkingDirectory.new(options[:working_directory]) if options[:working_directory]
  @repository = Git::Repository.new(options[:repository]) if options[:repository]
  @index = Git::Index.new(options[:index], false) if options[:index]
end

Class Method Details

.bare(git_dir, opts = {}) ⇒ Object

opens a bare Git Repository - no working directory options



13
14
15
16
17
18
 
# File 'lib/git/base.rb', line 13

def self.bare(git_dir, opts = {})
  default = {:repository => git_dir}
  git_options = default.merge(opts)
  
  self.new(git_options)
end

.clone(repository, name, opts = {}) ⇒ Object

clones a git repository locally

repository - http://repo.or.cz/w/sinatra.git
name - sinatra

options:

:repository

 :bare
or 
 :working_directory
 :index_file



64
65
66
67
 
# File 'lib/git/base.rb', line 64

def self.clone(repository, name, opts = {})
  # run git-clone 
  self.new(Git::Lib.new.clone(repository, name, opts))
end

.init(working_dir, opts = {}) ⇒ Object

initializes a git repository

options:

:repository
:index_file



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/git/base.rb', line 35

def self.init(working_dir, opts = {})
  default = {:working_directory => working_dir,
             :repository => File.join(working_dir, '.git')}
  git_options = default.merge(opts)
  
  if git_options[:working_directory]
    # if !working_dir, make it
    FileUtils.mkdir_p(git_options[:working_directory]) if !File.directory?(git_options[:working_directory])
  end
  
  # run git_init there
  Git::Lib.new(git_options).init
   
  self.new(git_options)
end

.open(working_dir, opts = {}) ⇒ Object

opens a new Git Project from a working directory you can specify non-standard git_dir and index file in the options



22
23
24
25
26
27
 
# File 'lib/git/base.rb', line 22

def self.open(working_dir, opts={})    
  default = {:working_directory => working_dir}
  git_options = default.merge(opts)
  
  self.new(git_options)
end

Instance Method Details

#add(path = '.') ⇒ Object

adds files from the working directory to the git repository



242
243
244
 
# File 'lib/git/base.rb', line 242

def add(path = '.')
  self.lib.add(path)
end

#add_remote(name, url, opts = {}) ⇒ Object

adds a new remote to this repository url can be a git url or a Git::Base object if it’s a local reference

@git.add_remote('scotts_git', 'git://repo.or.cz/rubygit.git')
@git.fetch('scotts_git')
@git.merge('scotts_git/master')



332
333
334
335
336
337
338
 
# File 'lib/git/base.rb', line 332

def add_remote(name, url, opts = {})
  if url.is_a?(Git::Base)
    url = url.repo.path
  end
  self.lib.remote_add(name, url, opts)
  Git::Remote.new(self, name)
end

#add_tag(tag_name) ⇒ Object

creates a new git tag (Git::Tag)



351
352
353
354
 
# File 'lib/git/base.rb', line 351

def add_tag(tag_name)
  self.lib.tag(tag_name)
  tag(tag_name)
end

#apply(file) ⇒ Object 



370
371
372
373
374
 
# File 'lib/git/base.rb', line 370

def apply(file)
  if File.exists?(file)
    self.lib.apply(file)
  end
end

#apply_mail(file) ⇒ Object 



376
377
378
379
380
 
# File 'lib/git/base.rb', line 376

def apply_mail(file)
  if File.exists?(file)
    self.lib.apply_mail(file)
  end
end

#archive(treeish, file = nil, opts = {}) ⇒ Object

creates an archive file of the given tree-ish



357
358
359
 
# File 'lib/git/base.rb', line 357

def archive(treeish, file = nil, opts = {})
  self.object(treeish).archive(file, opts)
end

#branch(branch_name = 'master') ⇒ Object

returns a Git::Branch object for branch_name



197
198
199
 
# File 'lib/git/base.rb', line 197

def branch(branch_name = 'master')
  Git::Branch.new(self, branch_name)
end

#branches ⇒ Object

returns a Git::Branches object of all the Git::Branch objects for this repo



192
193
194
 
# File 'lib/git/base.rb', line 192

def branches
  Git::Branches.new(self)
end

#cat_file(objectish) ⇒ Object 



463
464
465
 
# File 'lib/git/base.rb', line 463

def cat_file(objectish)
  self.lib.object_contents(objectish)
end

#chdir ⇒ Object

changes current working directory for a block to the git working directory

example

@git.chdir do 
  # write files
  @git.add
  @git.commit('message')
end



123
124
125
126
127
 
# File 'lib/git/base.rb', line 123

def chdir
  Dir.chdir(dir.path) do
    yield dir.path
  end
end

#checkout(branch = 'master', opts = {}) ⇒ Object

checks out a branch as the new git working directory



276
277
278
 
# File 'lib/git/base.rb', line 276

def checkout(branch = 'master', opts = {})
  self.lib.checkout(branch, opts)
end

#checkout_file(version, file) ⇒ Object

checks out an old version of a file



281
282
283
 
# File 'lib/git/base.rb', line 281

def checkout_file(version, file)
  self.lib.checkout_file(version,file)
end

#checkout_index(opts = {}) ⇒ Object 



399
400
401
 
# File 'lib/git/base.rb', line 399

def checkout_index(opts = {})
  self.lib.checkout_index(opts)
end

#commit(message, opts = {}) ⇒ Object

commits all pending changes in the index file to the git repository



263
264
265
 
# File 'lib/git/base.rb', line 263

def commit(message, opts = {})
  self.lib.commit(message, opts)
end

#commit_all(message, opts = {}) ⇒ Object

commits all pending changes in the index file to the git repository, but automatically adds all modified files without having to explicitly calling @git.add() on them.



270
271
272
273
 
# File 'lib/git/base.rb', line 270

def commit_all(message, opts = {})
  opts = {:add_all => true}.merge(opts)
  self.lib.commit(message, opts)
end

#commit_tree(tree = nil, opts = {}) ⇒ Object 



411
412
413
 
# File 'lib/git/base.rb', line 411

def commit_tree(tree = nil, opts = {})
  Git::Object::Commit.new(self, self.lib.commit_tree(tree, opts))
end

#config(name = nil, value = nil) ⇒ Object

g.config(‘user.name’, ‘Scott Chacon’) # sets value g.config(‘user.email’, ‘[email protected]’) # sets value g.config(‘user.name’) # returns ‘Scott Chacon’ g.config # returns whole config hash



142
143
144
145
146
147
148
149
150
151
152
153
 
# File 'lib/git/base.rb', line 142

def config(name = nil, value = nil)
  if(name && value)
    # set value
    lib.config_set(name, value)
  elsif (name)
    # return value
    lib.config_get(name)
  else
    # return hash
    lib.config_list
  end
end

#current_branch ⇒ Object

returns the name of the branch the working directory is currently on



468
469
470
 
# File 'lib/git/base.rb', line 468

def current_branch
  self.lib.branch_current
end

#diff(objectish = 'HEAD', obj2 = nil) ⇒ Object

returns a Git::Diff object



237
238
239
 
# File 'lib/git/base.rb', line 237

def diff(objectish = 'HEAD', obj2 = nil)
  Git::Diff.new(self, objectish, obj2)
end

#dir ⇒ Object

returns a reference to the working directory

@git.dir.path
@git.dir.writeable?



88
89
90
 
# File 'lib/git/base.rb', line 88

def dir
  @working_directory
end

#each_conflict(&block) ⇒ Object

iterates over the files which are unmerged

yields file, your_version, their_version



310
311
312
 
# File 'lib/git/base.rb', line 310

def each_conflict(&block)
  self.lib.conflicts(&block)
end

#fetch(remote = 'origin') ⇒ Object

fetches changes from a remote branch - this does not modify the working directory, it just gets the changes from the remote if there are any



287
288
289
 
# File 'lib/git/base.rb', line 287

def fetch(remote = 'origin')
  self.lib.fetch(remote)
end

#gblob(objectish) ⇒ Object 



177
178
179
 
# File 'lib/git/base.rb', line 177

def gblob(objectish)
  Git::Object.new(self, objectish, 'blob')
end

#gc ⇒ Object 



366
367
368
 
# File 'lib/git/base.rb', line 366

def gc
  self.lib.gc
end

#gcommit(objectish) ⇒ Object 



173
174
175
 
# File 'lib/git/base.rb', line 173

def gcommit(objectish)
  Git::Object.new(self, objectish, 'commit')
end

#grep(string) ⇒ Object

will run a grep for ‘string’ on the HEAD of the git repository

to be more surgical in your grep, you can call grep() off a specific git object. for example:

@git.object("v2.3").grep('TODO')

in any case, it returns a hash of arrays of the type:

hsh[tree-ish] = [[line_no, match], [line_no, match2]]
hsh[tree-ish] = [[line_no, match], [line_no, match2]]

so you might use it like this:

@git.grep("TODO").each do |sha, arr|
  puts "in blob #{sha}:"
  arr.each do |match|
    puts "\t line #{match[0]}: '#{match[1]}'"
  end
end



232
233
234
 
# File 'lib/git/base.rb', line 232

def grep(string)
  self.object('HEAD').grep(string)
end

#gtree(objectish) ⇒ Object 



169
170
171
 
# File 'lib/git/base.rb', line 169

def gtree(objectish)
  Git::Object.new(self, objectish, 'tree')
end

#index ⇒ Object

returns reference to the git index file



99
100
101
 
# File 'lib/git/base.rb', line 99

def index
  @index
end

#lib ⇒ Object

this is a convenience method for accessing the class that wraps all the actual ‘git’ forked system calls. At some point I hope to replace the Git::Lib class with one that uses native methods or libgit C bindings



209
210
211
 
# File 'lib/git/base.rb', line 209

def lib
  @lib ||= Git::Lib.new(self, @logger)
end

#log(count = 30) ⇒ Object

returns a Git::Log object with count commits



182
183
184
 
# File 'lib/git/base.rb', line 182

def log(count = 30)
  Git::Log.new(self, count)
end

#ls_files ⇒ Object 



425
426
427
 
# File 'lib/git/base.rb', line 425

def ls_files
  self.lib.ls_files
end

#ls_tree(objectish) ⇒ Object 



459
460
461
 
# File 'lib/git/base.rb', line 459

def ls_tree(objectish)
  self.lib.ls_tree(objectish)
end

#merge(branch, message = 'merge') ⇒ Object

merges one or more branches into the current working branch

you can specify more than one branch to merge by passing an array of branches



303
304
305
 
# File 'lib/git/base.rb', line 303

def merge(branch, message = 'merge')
  self.lib.merge(branch, message)
end

#object(objectish) ⇒ Object

returns a Git::Object of the appropriate type you can also call @git.gtree(‘tree’), but that’s just for readability. If you call @git.gtree(‘HEAD’) it will still return a Git::Object::Commit object.

on the objectish and determine the type of the object and return an appropriate object for that type



165
166
167
 
# File 'lib/git/base.rb', line 165

def object(objectish)
  Git::Object.new(self, objectish)
end

#pull(remote = 'origin', branch = 'master', message = 'origin pull') ⇒ Object

fetches a branch from a remote and merges it into the current working branch



315
316
317
318
 
# File 'lib/git/base.rb', line 315

def pull(remote = 'origin', branch = 'master', message = 'origin pull')
  fetch(remote)
  merge(branch, message)
end

#push(remote = 'origin', branch = 'master') ⇒ Object

pushes changes to a remote repository - easiest if this is a cloned repository, otherwise you may have to run something like this first to setup the push parameters:

@git.config('remote.remote-name.push', 'refs/heads/master:refs/heads/master')



296
297
298
 
# File 'lib/git/base.rb', line 296

def push(remote = 'origin', branch = 'master')
  self.lib.push(remote, branch)
end

#read_tree(treeish, opts = {}) ⇒ Object 



403
404
405
 
# File 'lib/git/base.rb', line 403

def read_tree(treeish, opts = {})
  self.lib.read_tree(treeish, opts)
end

#remote(remote_name = 'origin') ⇒ Object

returns a Git::Remote object



202
203
204
 
# File 'lib/git/base.rb', line 202

def remote(remote_name = 'origin')
  Git::Remote.new(self, remote_name)
end

#remotes ⇒ Object

returns an array of Git:Remote objects



321
322
323
 
# File 'lib/git/base.rb', line 321

def remotes
  self.lib.remotes.map { |r| Git::Remote.new(self, r) }
end

#remove(path = '.', opts = {}) ⇒ Object

removes file(s) from the git repository



247
248
249
 
# File 'lib/git/base.rb', line 247

def remove(path = '.', opts = {})
  self.lib.remove(path, opts)
end

#repack ⇒ Object

repacks the repository



362
363
364
 
# File 'lib/git/base.rb', line 362

def repack
  self.lib.repack
end

#repo ⇒ Object

returns reference to the git repository directory

@git.dir.path



94
95
96
 
# File 'lib/git/base.rb', line 94

def repo
  @repository
end

#repo_size ⇒ Object

returns the repository size in bytes



130
131
132
133
134
135
136
 
# File 'lib/git/base.rb', line 130

def repo_size
  size = 0
  Dir.chdir(repo.path) do
    (size, dot) = `du -s`.chomp.split
  end
  size.to_i
end

#reset(commitish = nil, opts = {}) ⇒ Object

resets the working directory to the provided commitish



252
253
254
 
# File 'lib/git/base.rb', line 252

def reset(commitish = nil, opts = {})
  self.lib.reset(commitish, opts)
end

#reset_hard(commitish = nil, opts = {}) ⇒ Object

resets the working directory to the commitish with ‘–hard’



257
258
259
260
 
# File 'lib/git/base.rb', line 257

def reset_hard(commitish = nil, opts = {})
  opts = {:hard => true}.merge(opts)
  self.lib.reset(commitish, opts)
end

#revparse(objectish) ⇒ Object

runs git rev-parse to convert the objectish to a full sha

@git.revparse("HEAD^^")
@git.revparse('v2.4^{tree}')
@git.revparse('v2.4:/doc/index.html')



455
456
457
 
# File 'lib/git/base.rb', line 455

def revparse(objectish)
  self.lib.revparse(objectish)
end

#set_index(index_file, check = true) ⇒ Object 



109
110
111
112
 
# File 'lib/git/base.rb', line 109

def set_index(index_file, check = true)
  @lib = nil
  @index = Git::Index.new(index_file.to_s, check)
end

#set_working(work_dir, check = true) ⇒ Object 



104
105
106
107
 
# File 'lib/git/base.rb', line 104

def set_working(work_dir, check = true)
  @lib = nil
  @working_directory = Git::WorkingDirectory.new(work_dir.to_s, check)
end

#status ⇒ Object

returns a Git::Status object



187
188
189
 
# File 'lib/git/base.rb', line 187

def status
  Git::Status.new(self)
end

#tag(tag_name) ⇒ Object

returns a Git::Tag object



346
347
348
 
# File 'lib/git/base.rb', line 346

def tag(tag_name)
  Git::Object.new(self, tag_name, 'tag', true)
end

#tags ⇒ Object

returns an array of all Git::Tag objects for this repository



341
342
343
 
# File 'lib/git/base.rb', line 341

def tags
  self.lib.tags.map { |r| tag(r) }
end

#update_ref(branch, commit) ⇒ Object 



420
421
422
 
# File 'lib/git/base.rb', line 420

def update_ref(branch, commit)
  branch(branch).update_ref(commit)
end

#with_index(new_index) ⇒ Object

LOWER LEVEL INDEX OPERATIONS ##



384
385
386
387
388
389
390
 
# File 'lib/git/base.rb', line 384

def with_index(new_index)
  old_index = @index
  set_index(new_index, false)
  return_value = yield @index
  set_index(old_index)
  return_value
end

#with_temp_index(&blk) ⇒ Object 



392
393
394
395
396
397
 
# File 'lib/git/base.rb', line 392

def with_temp_index &blk
  tempfile = Tempfile.new('temp-index')
  temp_path = tempfile.path
  tempfile.unlink
  with_index(temp_path, &blk)
end

#with_temp_working(&blk) ⇒ Object 



440
441
442
443
444
445
446
 
# File 'lib/git/base.rb', line 440

def with_temp_working &blk
  tempfile = Tempfile.new("temp-workdir")
  temp_dir = tempfile.path
  tempfile.unlink
  Dir.mkdir(temp_dir, 0700)
  with_working(temp_dir, &blk)
end

#with_working(work_dir) ⇒ Object 



429
430
431
432
433
434
435
436
437
438
 
# File 'lib/git/base.rb', line 429

def with_working(work_dir)
  return_value = false
  old_working = @working_directory
  set_working(work_dir) 
  Dir.chdir work_dir do
    return_value = yield @working_directory
  end
  set_working(old_working)
  return_value
end

#write_and_commit_tree(opts = {}) ⇒ Object 



415
416
417
418
 
# File 'lib/git/base.rb', line 415

def write_and_commit_tree(opts = {})
  tree = write_tree
  commit_tree(tree, opts)
end

#write_tree ⇒ Object 



407
408
409
 
# File 'lib/git/base.rb', line 407

def write_tree
  self.lib.write_tree
end