Refactored Diff::Display classes
[gitorious:yousource.git] / vendor / ruby-git / lib / git / base.rb
1 module Git
2   
3   class Base
4
5     @working_directory = nil
6     @repository = nil
7     @index = nil
8
9     @lib = nil
10     
11     # opens a bare Git Repository - no working directory options
12     def self.bare(git_dir)
13       self.new :repository => git_dir
14     end
15     
16     # opens a new Git Project from a working directory
17     # you can specify non-standard git_dir and index file in the options
18     def self.open(working_dir, opts={})    
19       default = {:working_directory => working_dir}
20       git_options = default.merge(opts)
21       
22       self.new(git_options)
23     end
24
25     # initializes a git repository
26     #
27     # options:
28     #  :repository
29     #  :index_file
30     #
31     def self.init(working_dir, opts = {})
32       default = {:working_directory => working_dir,
33                  :repository => File.join(working_dir, '.git')}
34       git_options = default.merge(opts)
35       
36       if git_options[:working_directory]
37         # if !working_dir, make it
38         FileUtils.mkdir_p(git_options[:working_directory]) if !File.directory?(git_options[:working_directory])
39       end
40       
41       # run git_init there
42       Git::Lib.new(git_options).init
43        
44       self.new(git_options)
45     end
46
47     # clones a git repository locally
48     #
49     #  repository - http://repo.or.cz/w/sinatra.git
50     #  name - sinatra
51     #
52     # options:
53     #   :repository
54     #
55     #    :bare
56     #   or 
57     #    :working_directory
58     #    :index_file
59     #
60     def self.clone(repository, name, opts = {})
61       # run git-clone 
62       self.new(Git::Lib.new.clone(repository, name, opts))
63     end
64         
65     def initialize(options = {})
66       if working_dir = options[:working_directory]
67         options[:repository] = File.join(working_dir, '.git') if !options[:repository]
68         options[:index] = File.join(working_dir, '.git', 'index') if !options[:index]
69       end
70       
71       @working_directory = Git::WorkingDirectory.new(options[:working_directory]) if options[:working_directory]
72       @repository = Git::Repository.new(options[:repository]) if options[:repository]
73       @index = Git::Index.new(options[:index], false) if options[:index]
74     end
75   
76   
77     # returns a reference to the working directory
78     #  @git.dir.path
79     #  @git.dir.writeable?
80     def dir
81       @working_directory
82     end
83
84     # returns reference to the git repository directory
85     #  @git.dir.path
86     def repo
87       @repository
88     end
89     
90     # returns reference to the git index file
91     def index
92       @index
93     end
94     
95     
96     def set_working(work_dir, check = true)
97       @lib = nil
98       @working_directory = Git::WorkingDirectory.new(work_dir.to_s, check)
99     end
100
101     def set_index(index_file, check = true)
102       @lib = nil
103       @index = Git::Index.new(index_file.to_s, check)
104     end
105     
106     # changes current working directory for a block
107     # to the git working directory
108     #
109     # example
110     #  @git.chdir do 
111     #    # write files
112     #    @git.add
113     #    @git.commit('message')
114     #  end
115     def chdir
116       Dir.chdir(dir.path) do
117         yield dir.path
118       end
119     end
120     
121     # returns the repository size in bytes
122     def repo_size
123       size = 0
124       Dir.chdir(repo.path) do
125         (size, dot) = `du -d0`.chomp.split
126       end
127       size.to_i
128     end
129     
130     #g.config('user.name', 'Scott Chacon') # sets value
131     #g.config('user.email', 'email@email.com')  # sets value
132     #g.config('user.name')  # returns 'Scott Chacon'
133     #g.config # returns whole config hash
134     def config(name = nil, value = nil)
135       if(name && value)
136         # set value
137         lib.config_set(name, value)
138       elsif (name)
139         # return value
140         lib.config_get(name)
141       else
142         # return hash
143         lib.config_list
144       end
145     end
146     
147     # factory methods
148     
149     # returns a Git::Object of the appropriate type
150     # you can also call @git.gtree('tree'), but that's 
151     # just for readability.  If you call @git.gtree('HEAD') it will
152     # still return a Git::Object::Commit object.  
153     #
154     # @git.object calls a factory method that will run a rev-parse 
155     # on the objectish and determine the type of the object and return 
156     # an appropriate object for that type 
157     def object(objectish)
158       Git::Object.new(self, objectish)
159     end
160     
161     def gtree(objectish)
162       Git::Object.new(self, objectish, 'tree')
163     end
164     
165     def gcommit(objectish)
166       Git::Object.new(self, objectish, 'commit')
167     end
168     
169     def gblob(objectish)
170       Git::Object.new(self, objectish, 'blob')
171     end
172     
173     # returns a Git::Log object with count commits
174     def log(count = 30, skip = 0, opts = {})
175       Git::Log.new(self, count, skip, opts)
176     end
177
178     # returns a Git::Status object
179     def status
180       Git::Status.new(self)
181     end
182         
183     # returns a Git::Branches object of all the Git::Branch objects for this repo
184     def branches
185       Git::Branches.new(self)
186     end
187     
188     # returns a Git::Branch object for branch_name
189     def branch(branch_name = 'master')
190       Git::Branch.new(self, branch_name)
191     end
192
193     # returns a Git::Remote object
194     def remote(remote_name = 'origin')
195       Git::Remote.new(self, remote_name)
196     end
197
198     # this is a convenience method for accessing the class that wraps all the 
199     # actual 'git' forked system calls.  At some point I hope to replace the Git::Lib
200     # class with one that uses native methods or libgit C bindings
201     def lib
202       @lib ||= Git::Lib.new(self)
203     end
204     
205     # will run a grep for 'string' on the HEAD of the git repository
206     # 
207     # to be more surgical in your grep, you can call grep() off a specific
208     # git object.  for example:
209     #
210     #  @git.object("v2.3").grep('TODO')
211     #
212     # in any case, it returns a hash of arrays of the type:
213     #  hsh[tree-ish] = [[line_no, match], [line_no, match2]]
214     #  hsh[tree-ish] = [[line_no, match], [line_no, match2]]
215     #
216     # so you might use it like this:
217     #
218     #   @git.grep("TODO").each do |sha, arr|
219     #     puts "in blob #{sha}:"
220     #     arr.each do |match|
221     #       puts "\t line #{match[0]}: '#{match[1]}'"
222     #     end
223     #   end
224     def grep(string)
225       self.object('HEAD').grep(string)
226     end
227     
228     # returns a Git::Diff object
229     def diff(objectish = 'HEAD', obj2 = nil)
230       Git::Diff.new(self, objectish, obj2)
231     end
232     
233     # adds files from the working directory to the git repository
234     def add(path = '.')
235       self.lib.add(path)
236     end
237
238     # removes file(s) from the git repository
239     def remove(path = '.', opts = {})
240       self.lib.remove(path, opts)
241     end
242
243     # resets the working directory to the provided commitish
244     def reset(commitish = nil, opts = {})
245       self.lib.reset(commitish, opts)
246     end
247
248     # resets the working directory to the commitish with '--hard'
249     def reset_hard(commitish = nil, opts = {})
250       opts = {:hard => true}.merge(opts)
251       self.lib.reset(commitish, opts)
252     end
253
254     # commits all pending changes in the index file to the git repository
255     def commit(message, opts = {})
256       self.lib.commit(message, opts)
257     end
258         
259     # commits all pending changes in the index file to the git repository,
260     # but automatically adds all modified files without having to explicitly
261     # calling @git.add() on them.  
262     def commit_all(message, opts = {})
263       opts = {:add_all => true}.merge(opts)
264       self.lib.commit(message, opts)
265     end
266
267     # checks out a branch as the new git working directory
268     def checkout(branch = 'master', opts = {})
269       self.lib.checkout(branch, opts)
270     end
271     
272     # fetches changes from a remote branch - this does not modify the working directory,
273     # it just gets the changes from the remote if there are any
274     def fetch(remote = 'origin')
275       self.lib.fetch(remote)
276     end
277
278     # pushes changes to a remote repository - easiest if this is a cloned repository,
279     # otherwise you may have to run something like this first to setup the push parameters:
280     #
281     #  @git.config('remote.remote-name.push', 'refs/heads/master:refs/heads/master')
282     #
283     def push(remote = 'origin', branch = 'master')
284       self.lib.push(remote, branch)
285     end
286     
287     # merges one or more branches into the current working branch
288     #
289     # you can specify more than one branch to merge by passing an array of branches
290     def merge(branch, message = 'merge')
291       self.lib.merge(branch, message)
292     end
293
294     # fetches a branch from a remote and merges it into the current working branch
295     def pull(remote = 'origin', branch = 'master', message = 'origin pull')
296       fetch(remote)
297       merge(branch, message)
298     end
299     
300     # returns an array of Git:Remote objects
301     def remotes
302       self.lib.remotes.map { |r| Git::Remote.new(self, r) }
303     end
304
305     # adds a new remote to this repository
306     # url can be a git url or a Git::Base object if it's a local reference
307     # 
308     #  @git.add_remote('scotts_git', 'git://repo.or.cz/rubygit.git')
309     #  @git.fetch('scotts_git')
310     #  @git.merge('scotts_git/master')
311     #
312     def add_remote(name, url, opts = {})
313       if url.is_a?(Git::Base)
314         url = url.repo.path
315       end
316       self.lib.remote_add(name, url, opts)
317       Git::Remote.new(self, name)
318     end
319
320     # returns an array of all Git::Tag objects for this repository
321     def tags
322       self.lib.tags.map { |r| tag(r) }
323     end
324     
325     # returns a Git::Tag object
326     def tag(tag_name)
327       Git::Object.new(self, tag_name, 'tag', true)
328     end
329
330     # creates a new git tag (Git::Tag)
331     def add_tag(tag_name)
332       self.lib.tag(tag_name)
333       tag(tag_name)
334     end
335     
336     # creates an archive file of the given tree-ish
337     def archive(treeish, file = nil, opts = {})
338       self.object(treeish).archive(file, opts)
339     end
340     
341     # repacks the repository
342     def repack
343       self.lib.repack
344     end
345     
346     
347     ## LOWER LEVEL INDEX OPERATIONS ##
348     
349     def with_index(new_index)
350       old_index = @index
351       set_index(new_index, false)
352       return_value = yield @index
353       set_index(old_index)
354       return_value
355     end
356     
357     def with_temp_index &blk
358       tempfile = Tempfile.new('temp-index')
359       temp_path = tempfile.path
360       tempfile.unlink
361       with_index(temp_path, &blk)
362     end
363     
364     def checkout_index(opts = {})
365       self.lib.checkout_index(opts)
366     end
367     
368     def read_tree(treeish, opts = {})
369       self.lib.read_tree(treeish, opts)
370     end
371     
372     def write_tree
373       self.lib.write_tree
374     end
375     
376     def commit_tree(tree = nil, opts = {})
377       Git::Object::Commit.new(self, self.lib.commit_tree(tree, opts))
378     end
379     
380     def write_and_commit_tree(opts = {})
381       tree = write_tree
382       commit_tree(tree, opts)
383     end
384       
385     def update_ref(branch, commit)
386       branch(branch).update_ref(commit)
387     end
388     
389     
390     def ls_files
391       self.lib.ls_files
392     end
393
394     def with_working(work_dir)
395       return_value = false
396       old_working = @working_directory
397       set_working(work_dir) 
398       Dir.chdir work_dir do
399         return_value = yield @working_directory
400       end
401       set_working(old_working)
402       return_value
403     end
404     
405     def with_temp_working &blk
406       tempfile = Tempfile.new("temp-workdir")
407       temp_dir = tempfile.path
408       tempfile.unlink
409       Dir.mkdir(temp_dir, 0700)
410       with_working(temp_dir, &blk)
411     end
412     
413     
414     # runs git rev-parse to convert the objectish to a full sha
415     #
416     #   @git.revparse("HEAD^^")
417     #   @git.revparse('v2.4^{tree}')
418     #   @git.revparse('v2.4:/doc/index.html')
419     #
420     def revparse(objectish)
421       self.lib.revparse(objectish)
422     end
423
424     # returns the name of the branch the working directory is currently on
425     def current_branch
426       self.lib.branch_current
427     end
428
429     
430   end
431   
432 end