~mdw / stgit / blob
? search:


4d01fc296c389be4155249126cbeb556744d44bf
[stgit] / stgit / git.py
1 """Python GIT interface
2 """
3
4 __copyright__ = """
5 Copyright (C) 2005, Catalin Marinas <catalin.marinas@gmail.com>
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License version 2 as
9 published by the Free Software Foundation.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 """
20
21 import sys, os, re, gitmergeonefile
22 from shutil import copyfile
23
24 from stgit.exception import *
25 from stgit import basedir
26 from stgit.utils import *
27 from stgit.out import *
28 from stgit.run import *
29 from stgit.config import config
30
31 # git exception class
32 class GitException(StgException):
33 pass
34
35 # When a subprocess has a problem, we want the exception to be a
36 # subclass of GitException.
37 class GitRunException(GitException):
38 pass
39 class GRun(Run):
40 exc = GitRunException
41 def __init__(self, *cmd):
42 """Initialise the Run object and insert the 'git' command name.
43 """
44 Run.__init__(self, 'git', *cmd)
45
46 #
47 # Classes
48 #
49
50 class Person:
51 """An author, committer, etc."""
52 def __init__(self, name = None, email = None, date = '',
53 desc = None):
54 self.name = self.email = self.date = None
55 if name or email or date:
56 assert not desc
57 self.name = name
58 self.email = email
59 self.date = date
60 elif desc:
61 assert not (name or email or date)
62 def parse_desc(s):
63 m = re.match(r'^(.+)<(.+)>(.*)$', s)
64 assert m
65 return [x.strip() or None for x in m.groups()]
66 self.name, self.email, self.date = parse_desc(desc)
67 def set_name(self, val):
68 if val:
69 self.name = val
70 def set_email(self, val):
71 if val:
72 self.email = val
73 def set_date(self, val):
74 if val:
75 self.date = val
76 def __str__(self):
77 if self.name and self.email:
78 return '%s <%s>' % (self.name, self.email)
79 else:
80 raise GitException, 'not enough identity data'
81
82 class Commit:
83 """Handle the commit objects
84 """
85 def __init__(self, id_hash):
86 self.__id_hash = id_hash
87
88 lines = GRun('cat-file', 'commit', id_hash).output_lines()
89 for i in range(len(lines)):
90 line = lines[i]
91 if not line:
92 break # we've seen all the header fields
93 key, val = line.split(' ', 1)
94 if key == 'tree':
95 self.__tree = val
96 elif key == 'author':
97 self.__author = val
98 elif key == 'committer':
99 self.__committer = val
100 else:
101 pass # ignore other headers
102 self.__log = '\n'.join(lines[i+1:])
103
104 def get_id_hash(self):
105 return self.__id_hash
106
107 def get_tree(self):
108 return self.__tree
109
110 def get_parent(self):
111 parents = self.get_parents()
112 if parents:
113 return parents[0]
114 else:
115 return None
116
117 def get_parents(self):
118 return GRun('rev-list', '--parents', '--max-count=1', self.__id_hash
119 ).output_one_line().split()[1:]
120
121 def get_author(self):
122 return self.__author
123
124 def get_committer(self):
125 return self.__committer
126
127 def get_log(self):
128 return self.__log
129
130 def __str__(self):
131 return self.get_id_hash()
132
133 # dictionary of Commit objects, used to avoid multiple calls to git
134 __commits = dict()
135
136 #
137 # Functions
138 #
139
140 def get_commit(id_hash):
141 """Commit objects factory. Save/look-up them in the __commits
142 dictionary
143 """
144 global __commits
145
146 if id_hash in __commits:
147 return __commits[id_hash]
148 else:
149 commit = Commit(id_hash)
150 __commits[id_hash] = commit
151 return commit
152
153 def get_conflicts():
154 """Return the list of file conflicts
155 """
156 names = set()
157 for line in GRun('ls-files', '-z', '--unmerged'
158 ).raw_output().split('\0')[:-1]:
159 stat, path = line.split('\t', 1)
160 names.add(path)
161 return list(names)
162
163 def exclude_files():
164 files = [os.path.join(basedir.get(), 'info', 'exclude')]
165 user_exclude = config.get('core.excludesfile')
166 if user_exclude:
167 files.append(user_exclude)
168 return files
169
170 def ls_files(files, tree = 'HEAD', full_name = True):
171 """Return the files known to GIT or raise an error otherwise. It also
172 converts the file to the full path relative the the .git directory.
173 """
174 if not files:
175 return []
176
177 args = []
178 if tree:
179 args.append('--with-tree=%s' % tree)
180 if full_name:
181 args.append('--full-name')
182 args.append('--')
183 args.extend(files)
184 try:
185 # use a set to avoid file names duplication due to different stages
186 fileset = set(GRun('ls-files', '--error-unmatch', *args).output_lines())
187 except GitRunException:
188 # just hide the details of the 'git ls-files' command we use
189 raise GitException, \
190 'Some of the given paths are either missing or not known to GIT'
191 return list(fileset)
192
193 def parse_git_ls(output):
194 """Parse the output of git diff-index, diff-files, etc. Doesn't handle
195 rename/copy output, so don't feed it output generated with the -M
196 or -C flags."""
197 t = None
198 for line in output.split('\0'):
199 if not line:
200 # There's a zero byte at the end of the output, which
201 # gives us an empty string as the last "line".
202 continue
203 if t == None:
204 mode_a, mode_b, sha1_a, sha1_b, t = line.split(' ')
205 else:
206 yield (t, line)
207 t = None
208
209 def tree_status(files = None, tree_id = 'HEAD', unknown = False,
210 noexclude = True, verbose = False):
211 """Get the status of all changed files, or of a selected set of
212 files. Returns a list of pairs - (status, filename).
213
214 If 'not files', it will check all files, and optionally all
215 unknown files. If 'files' is a list, it will only check the files
216 in the list.
217 """
218 assert not files or not unknown
219
220 if verbose:
221 out.start('Checking for changes in the working directory')
222
223 refresh_index()
224
225 if files is None:
226 files = []
227 cache_files = []
228
229 # unknown files
230 if unknown:
231 cmd = ['ls-files', '-z', '--others', '--directory',
232 '--no-empty-directory']
233 if not noexclude:
234 cmd += ['--exclude=%s' % s for s in
235 ['*.[ao]', '*.pyc', '.*', '*~', '#*', 'TAGS', 'tags']]
236 cmd += ['--exclude-per-directory=.gitignore']
237 cmd += ['--exclude-from=%s' % fn
238 for fn in exclude_files()
239 if os.path.exists(fn)]
240
241 lines = GRun(*cmd).raw_output().split('\0')
242 cache_files += [('?', line) for line in lines if line]
243
244 # conflicted files
245 conflicts = get_conflicts()
246 cache_files += [('C', filename) for filename in conflicts
247 if not files or filename in files]
248 reported_files = set(conflicts)
249 files_left = [f for f in files if f not in reported_files]
250
251 # files in the index. Only execute this code if no files were
252 # specified when calling the function (i.e. report all files) or
253 # files were specified but already found in the previous step
254 if not files or files_left:
255 args = [tree_id]
256 if files_left:
257 args += ['--'] + files_left
258 for t, fn in parse_git_ls(GRun('diff-index', '-z', *args).raw_output()):
259 # the condition is needed in case files is emtpy and
260 # diff-index lists those already reported
261 if not fn in reported_files:
262 cache_files.append((t, fn))
263 reported_files.add(fn)
264 files_left = [f for f in files if f not in reported_files]
265
266 # files in the index but changed on (or removed from) disk. Only
267 # execute this code if no files were specified when calling the
268 # function (i.e. report all files) or files were specified but
269 # already found in the previous step
270 if not files or files_left:
271 args = []
272 if files_left:
273 args += ['--'] + files_left
274 for t, fn in parse_git_ls(GRun('diff-files', '-z', *args).raw_output()):
275 # the condition is needed in case files is empty and
276 # diff-files lists those already reported
277 if not fn in reported_files:
278 cache_files.append((t, fn))
279 reported_files.add(fn)
280
281 if verbose:
282 out.done()
283
284 return cache_files
285
286 def local_changes(verbose = True):
287 """Return true if there are local changes in the tree
288 """
289 return len(tree_status(verbose = verbose)) != 0
290
291 def get_heads():
292 heads = []
293 hr = re.compile(r'^[0-9a-f]{40} refs/heads/(.+)$')
294 for line in GRun('show-ref', '--heads').output_lines():
295 m = hr.match(line)
296 heads.append(m.group(1))
297 return heads
298
299 # HEAD value cached
300 __head = None
301
302 def get_head():
303 """Verifies the HEAD and returns the SHA1 id that represents it
304 """
305 global __head
306
307 if not __head:
308 __head = rev_parse('HEAD')
309 return __head
310
311 class DetachedHeadException(GitException):
312 def __init__(self):
313 GitException.__init__(self, 'Not on any branch')
314
315 def get_head_file():
316 """Return the name of the file pointed to by the HEAD symref.
317 Throw an exception if HEAD is detached."""
318 try:
319 return strip_prefix(
320 'refs/heads/', GRun('symbolic-ref', '-q', 'HEAD'
321 ).output_one_line())
322 except GitRunException:
323 raise DetachedHeadException()
324
325 def set_head_file(ref):
326 """Resets HEAD to point to a new ref
327 """
328 # head cache flushing is needed since we might have a different value
329 # in the new head
330 __clear_head_cache()
331 try:
332 GRun('symbolic-ref', 'HEAD', 'refs/heads/%s' % ref).run()
333 except GitRunException:
334 raise GitException, 'Could not set head to "%s"' % ref
335
336 def set_ref(ref, val):
337 """Point ref at a new commit object."""
338 try:
339 GRun('update-ref', ref, val).run()
340 except GitRunException:
341 raise GitException, 'Could not update %s to "%s".' % (ref, val)
342
343 def set_branch(branch, val):
344 set_ref('refs/heads/%s' % branch, val)
345
346 def __set_head(val):
347 """Sets the HEAD value
348 """
349 global __head
350
351 if not __head or __head != val:
352 set_ref('HEAD', val)
353 __head = val
354
355 # only allow SHA1 hashes
356 assert(len(__head) == 40)
357
358 def __clear_head_cache():
359 """Sets the __head to None so that a re-read is forced
360 """
361 global __head
362
363 __head = None
364
365 def refresh_index():
366 """Refresh index with stat() information from the working directory.
367 """
368 GRun('update-index', '-q', '--unmerged', '--refresh').run()
369
370 def rev_parse(git_id):
371 """Parse the string and return a verified SHA1 id
372 """
373 try:
374 return GRun('rev-parse', '--verify', git_id
375 ).discard_stderr().output_one_line()
376 except GitRunException:
377 raise GitException, 'Unknown revision: %s' % git_id
378
379 def ref_exists(ref):
380 try:
381 rev_parse(ref)
382 return True
383 except GitException:
384 return False
385
386 def branch_exists(branch):
387 return ref_exists('refs/heads/%s' % branch)
388
389 def create_branch(new_branch, tree_id = None):
390 """Create a new branch in the git repository
391 """
392 if branch_exists(new_branch):
393 raise GitException, 'Branch "%s" already exists' % new_branch
394
395 current_head_file = get_head_file()
396 current_head = get_head()
397 set_head_file(new_branch)
398 __set_head(current_head)
399
400 # a checkout isn't needed if new branch points to the current head
401 if tree_id:
402 try:
403 switch(tree_id)
404 except GitException:
405 # Tree switching failed. Revert the head file
406 set_head_file(current_head_file)
407 delete_branch(new_branch)
408 raise
409
410 if os.path.isfile(os.path.join(basedir.get(), 'MERGE_HEAD')):
411 os.remove(os.path.join(basedir.get(), 'MERGE_HEAD'))
412
413 def switch_branch(new_branch):
414 """Switch to a git branch
415 """
416 global __head
417
418 if not branch_exists(new_branch):
419 raise GitException, 'Branch "%s" does not exist' % new_branch
420
421 tree_id = rev_parse('refs/heads/%s^{commit}' % new_branch)
422 if tree_id != get_head():
423 refresh_index()
424 try:
425 GRun('read-tree', '-u', '-m', get_head(), tree_id).run()
426 except GitRunException:
427 raise GitException, 'read-tree failed (local changes maybe?)'
428 __head = tree_id
429 set_head_file(new_branch)
430
431 if os.path.isfile(os.path.join(basedir.get(), 'MERGE_HEAD')):
432 os.remove(os.path.join(basedir.get(), 'MERGE_HEAD'))
433
434 def delete_ref(ref):
435 if not ref_exists(ref):
436 raise GitException, '%s does not exist' % ref
437 sha1 = GRun('show-ref', '-s', ref).output_one_line()
438 try:
439 GRun('update-ref', '-d', ref, sha1).run()
440 except GitRunException:
441 raise GitException, 'Failed to delete ref %s' % ref
442
443 def delete_branch(name):
444 delete_ref('refs/heads/%s' % name)
445
446 def rename_ref(from_ref, to_ref):
447 if not ref_exists(from_ref):
448 raise GitException, '"%s" does not exist' % from_ref
449 if ref_exists(to_ref):
450 raise GitException, '"%s" already exists' % to_ref
451
452 sha1 = GRun('show-ref', '-s', from_ref).output_one_line()
453 try:
454 GRun('update-ref', to_ref, sha1, '0'*40).run()
455 except GitRunException:
456 raise GitException, 'Failed to create new ref %s' % to_ref
457 try:
458 GRun('update-ref', '-d', from_ref, sha1).run()
459 except GitRunException:
460 raise GitException, 'Failed to delete ref %s' % from_ref
461
462 def rename_branch(from_name, to_name):
463 """Rename a git branch."""
464 rename_ref('refs/heads/%s' % from_name, 'refs/heads/%s' % to_name)
465 try:
466 if get_head_file() == from_name:
467 set_head_file(to_name)
468 except DetachedHeadException:
469 pass # detached HEAD, so the renamee can't be the current branch
470 reflog_dir = os.path.join(basedir.get(), 'logs', 'refs', 'heads')
471 if os.path.exists(reflog_dir) \
472 and os.path.exists(os.path.join(reflog_dir, from_name)):
473 rename(reflog_dir, from_name, to_name)
474
475 # Persons caching
476 __user = None
477 __author = None
478 __committer = None
479
480 def user():
481 """Return the user information.
482 """
483 global __user
484 if not __user:
485 name=config.get('user.name')
486 email=config.get('user.email')
487 __user = Person(name, email)
488 return __user;
489
490 def author():
491 """Return the author information.
492 """
493 global __author
494 if not __author:
495 try:
496 # the environment variables take priority over config
497 try:
498 date = os.environ['GIT_AUTHOR_DATE']
499 except KeyError:
500 date = ''
501 __author = Person(os.environ['GIT_AUTHOR_NAME'],
502 os.environ['GIT_AUTHOR_EMAIL'],
503 date)
504 except KeyError:
505 __author = user()
506 return __author
507
508 def committer():
509 """Return the author information.
510 """
511 global __committer
512 if not __committer:
513 try:
514 # the environment variables take priority over config
515 try:
516 date = os.environ['GIT_COMMITTER_DATE']
517 except KeyError:
518 date = ''
519 __committer = Person(os.environ['GIT_COMMITTER_NAME'],
520 os.environ['GIT_COMMITTER_EMAIL'],
521 date)
522 except KeyError:
523 __committer = user()
524 return __committer
525
526 def update_cache(files = None, force = False):
527 """Update the cache information for the given files
528 """
529 cache_files = tree_status(files, verbose = False)
530
531 # everything is up-to-date
532 if len(cache_files) == 0:
533 return False
534
535 # check for unresolved conflicts
536 if not force and [x for x in cache_files
537 if x[0] not in ['M', 'N', 'A', 'D']]:
538 raise GitException, 'Updating cache failed: unresolved conflicts'
539
540 # update the cache
541 add_files = [x[1] for x in cache_files if x[0] in ['N', 'A']]
542 rm_files = [x[1] for x in cache_files if x[0] in ['D']]
543 m_files = [x[1] for x in cache_files if x[0] in ['M']]
544
545 GRun('update-index', '--add', '--').xargs(add_files)
546 GRun('update-index', '--force-remove', '--').xargs(rm_files)
547 GRun('update-index', '--').xargs(m_files)
548
549 return True
550
551 def commit(message, files = None, parents = None, allowempty = False,
552 cache_update = True, tree_id = None, set_head = False,
553 author_name = None, author_email = None, author_date = None,
554 committer_name = None, committer_email = None):
555 """Commit the current tree to repository
556 """
557 if not parents:
558 parents = []
559
560 # Get the tree status
561 if cache_update and parents != []:
562 changes = update_cache(files)
563 if not changes and not allowempty:
564 raise GitException, 'No changes to commit'
565
566 # get the commit message
567 if not message:
568 message = '\n'
569 elif message[-1:] != '\n':
570 message += '\n'
571
572 # write the index to repository
573 if tree_id == None:
574 tree_id = GRun('write-tree').output_one_line()
575 set_head = True
576
577 # the commit
578 env = {}
579 if author_name:
580 env['GIT_AUTHOR_NAME'] = author_name
581 if author_email:
582 env['GIT_AUTHOR_EMAIL'] = author_email
583 if author_date:
584 env['GIT_AUTHOR_DATE'] = author_date
585 if committer_name:
586 env['GIT_COMMITTER_NAME'] = committer_name
587 if committer_email:
588 env['GIT_COMMITTER_EMAIL'] = committer_email
589 commit_id = GRun('commit-tree', tree_id,
590 *sum([['-p', p] for p in parents], [])
591 ).env(env).raw_input(message).output_one_line()
592 if set_head:
593 __set_head(commit_id)
594
595 return commit_id
596
597 def apply_diff(rev1, rev2, check_index = True, files = None):
598 """Apply the diff between rev1 and rev2 onto the current
599 index. This function doesn't need to raise an exception since it
600 is only used for fast-pushing a patch. If this operation fails,
601 the pushing would fall back to the three-way merge.
602 """
603 if check_index:
604 index_opt = ['--index']
605 else:
606 index_opt = []
607
608 if not files:
609 files = []
610
611 diff_str = diff(files, rev1, rev2)
612 if diff_str:
613 try:
614 GRun('apply', *index_opt).raw_input(
615 diff_str).discard_stderr().no_output()
616 except GitRunException:
617 return False
618
619 return True
620
621 stages_re = re.compile('^([0-7]+) ([0-9a-f]{40}) ([1-3])\t(.*)$', re.S)
622
623 def merge_recursive(base, head1, head2):
624 """Perform a 3-way merge between base, head1 and head2 into the
625 local tree
626 """
627 refresh_index()
628 p = GRun('merge-recursive', base, '--', head1, head2).env(
629 { 'GITHEAD_%s' % base: 'ancestor',
630 'GITHEAD_%s' % head1: 'current',
631 'GITHEAD_%s' % head2: 'patched'}).returns([0, 1])
632 output = p.output_lines()
633 if p.exitcode:
634 # There were conflicts
635 conflicts = [l.strip() for l in output if l.startswith('CONFLICT')]
636 out.info(*conflicts)
637
638 # try the interactive merge or stage checkout (if enabled)
639 for filename in get_conflicts():
640 if (gitmergeonefile.merge(filename)):
641 # interactive merge succeeded
642 resolved([filename])
643
644 # any conflicts left unsolved?
645 cn = len(get_conflicts())
646 if cn:
647 raise GitException, "%d conflict(s)" % cn
648
649 def diff(files = None, rev1 = 'HEAD', rev2 = None, diff_flags = [],
650 binary = True):
651 """Show the diff between rev1 and rev2
652 """
653 if not files:
654 files = []
655 if binary and '--binary' not in diff_flags:
656 diff_flags = diff_flags + ['--binary']
657
658 if rev1 and rev2:
659 return GRun('diff-tree', '-p',
660 *(diff_flags + [rev1, rev2, '--'] + files)).raw_output()
661 elif rev1 or rev2:
662 refresh_index()
663 if rev2:
664 return GRun('diff-index', '-p', '-R',
665 *(diff_flags + [rev2, '--'] + files)).raw_output()
666 else:
667 return GRun('diff-index', '-p',
668 *(diff_flags + [rev1, '--'] + files)).raw_output()
669 else:
670 return ''
671
672 def files(rev1, rev2, diff_flags = []):
673 """Return the files modified between rev1 and rev2
674 """
675
676 result = []
677 for line in GRun('diff-tree', *(diff_flags + ['-r', rev1, rev2])
678 ).output_lines():
679 result.append('%s %s' % tuple(line.split(' ', 4)[-1].split('\t', 1)))
680
681 return '\n'.join(result)
682
683 def barefiles(rev1, rev2):
684 """Return the files modified between rev1 and rev2, without status info
685 """
686
687 result = []
688 for line in GRun('diff-tree', '-r', rev1, rev2).output_lines():
689 result.append(line.split(' ', 4)[-1].split('\t', 1)[-1])
690
691 return '\n'.join(result)
692
693 def pretty_commit(commit_id = 'HEAD', flags = []):
694 """Return a given commit (log + diff)
695 """
696 return GRun('show', *(flags + [commit_id])).raw_output()
697
698 def checkout(files = None, tree_id = None, force = False):
699 """Check out the given or all files
700 """
701 if tree_id:
702 try:
703 GRun('read-tree', '--reset', tree_id).run()
704 except GitRunException:
705 raise GitException, 'Failed "git read-tree" --reset %s' % tree_id
706
707 cmd = ['checkout-index', '-q', '-u']
708 if force:
709 cmd.append('-f')
710 if files:
711 GRun(*(cmd + ['--'])).xargs(files)
712 else:
713 GRun(*(cmd + ['-a'])).run()
714
715 def switch(tree_id, keep = False):
716 """Switch the tree to the given id
717 """
718 if keep:
719 # only update the index while keeping the local changes
720 GRun('read-tree', tree_id).run()
721 else:
722 refresh_index()
723 try:
724 GRun('read-tree', '-u', '-m', get_head(), tree_id).run()
725 except GitRunException:
726 raise GitException, 'read-tree failed (local changes maybe?)'
727
728 __set_head(tree_id)
729
730 def reset(files = None, tree_id = None, check_out = True):
731 """Revert the tree changes relative to the given tree_id. It removes
732 any local changes
733 """
734 if not tree_id:
735 tree_id = get_head()
736
737 if check_out:
738 cache_files = tree_status(files, tree_id)
739 # files which were added but need to be removed
740 rm_files = [x[1] for x in cache_files if x[0] in ['A']]
741
742 checkout(files, tree_id, True)
743 # checkout doesn't remove files
744 map(os.remove, rm_files)
745
746 # if the reset refers to the whole tree, switch the HEAD as well
747 if not files:
748 __set_head(tree_id)
749
750 def resolved(filenames, reset = None):
751 if reset:
752 stage = {'ancestor': 1, 'current': 2, 'patched': 3}[reset]
753 GRun('checkout-index', '--no-create', '--stage=%d' % stage,
754 '--stdin', '-z').input_nulterm(filenames).no_output()
755 GRun('update-index', '--add', '--').xargs(filenames)
756 for filename in filenames:
757 gitmergeonefile.clean_up(filename)
758 # update the access and modificatied times
759 os.utime(filename, None)
760
761 def fetch(repository = 'origin', refspec = None):
762 """Fetches changes from the remote repository, using 'git fetch'
763 by default.
764 """
765 # we update the HEAD
766 __clear_head_cache()
767
768 args = [repository]
769 if refspec:
770 args.append(refspec)
771
772 command = config.get('branch.%s.stgit.fetchcmd' % get_head_file()) or \
773 config.get('stgit.fetchcmd')
774 Run(*(command.split() + args)).run()
775
776 def pull(repository = 'origin', refspec = None):
777 """Fetches changes from the remote repository, using 'git pull'
778 by default.
779 """
780 # we update the HEAD
781 __clear_head_cache()
782
783 args = [repository]
784 if refspec:
785 args.append(refspec)
786
787 command = config.get('branch.%s.stgit.pullcmd' % get_head_file()) or \
788 config.get('stgit.pullcmd')
789 Run(*(command.split() + args)).run()
790
791 def rebase(tree_id = None):
792 """Rebase the current tree to the give tree_id. The tree_id
793 argument may be something other than a GIT id if an external
794 command is invoked.
795 """
796 command = config.get('branch.%s.stgit.rebasecmd' % get_head_file()) \
797 or config.get('stgit.rebasecmd')
798 if tree_id:
799 args = [tree_id]
800 elif command:
801 args = []
802 else:
803 raise GitException, 'Default rebasing requires a commit id'
804 if command:
805 # clear the HEAD cache as the custom rebase command will update it
806 __clear_head_cache()
807 Run(*(command.split() + args)).run()
808 else:
809 # default rebasing
810 reset(tree_id = tree_id)
811
812 def repack():
813 """Repack all objects into a single pack
814 """
815 GRun('repack', '-a', '-d', '-f').run()
816
817 def apply_patch(filename = None, diff = None, base = None,
818 fail_dump = True):
819 """Apply a patch onto the current or given index. There must not
820 be any local changes in the tree, otherwise the command fails
821 """
822 if diff is None:
823 if filename:
824 f = file(filename)
825 else:
826 f = sys.stdin
827 diff = f.read()
828 if filename:
829 f.close()
830
831 if base:
832 orig_head = get_head()
833 switch(base)
834 else:
835 refresh_index()
836
837 try:
838 GRun('apply', '--index').raw_input(diff).no_output()
839 except GitRunException:
840 if base:
841 switch(orig_head)
842 if fail_dump:
843 # write the failed diff to a file
844 f = file('.stgit-failed.patch', 'w+')
845 f.write(diff)
846 f.close()
847 out.warn('Diff written to the .stgit-failed.patch file')
848
849 raise
850
851 if base:
852 top = commit(message = 'temporary commit used for applying a patch',
853 parents = [base])
854 switch(orig_head)
855 merge_recursive(base, orig_head, top)
856
857 def clone(repository, local_dir):
858 """Clone a remote repository. At the moment, just use the
859 'git clone' script
860 """
861 GRun('clone', repository, local_dir).run()
862
863 def modifying_revs(files, base_rev, head_rev):
864 """Return the revisions from the list modifying the given files."""
865 return GRun('rev-list', '%s..%s' % (base_rev, head_rev), '--', *files
866 ).output_lines()
867
868 def refspec_localpart(refspec):
869 m = re.match('^[^:]*:([^:]*)$', refspec)
870 if m:
871 return m.group(1)
872 else:
873 raise GitException, 'Cannot parse refspec "%s"' % line
874
875 def refspec_remotepart(refspec):
876 m = re.match('^([^:]*):[^:]*$', refspec)
877 if m:
878 return m.group(1)
879 else:
880 raise GitException, 'Cannot parse refspec "%s"' % line
881
882 def __remotes_from_config():
883 return config.sections_matching(r'remote\.(.*)\.url')
884
885 def __remotes_from_dir(dir):
886 d = os.path.join(basedir.get(), dir)
887 if os.path.exists(d):
888 return os.listdir(d)
889 else:
890 return []
891
892 def remotes_list():
893 """Return the list of remotes in the repository
894 """
895 return (set(__remotes_from_config())
896 | set(__remotes_from_dir('remotes'))
897 | set(__remotes_from_dir('branches')))
898
899 def remotes_local_branches(remote):
900 """Returns the list of local branches fetched from given remote
901 """
902
903 branches = []
904 if remote in __remotes_from_config():
905 for line in config.getall('remote.%s.fetch' % remote):
906 branches.append(refspec_localpart(line))
907 elif remote in __remotes_from_dir('remotes'):
908 stream = open(os.path.join(basedir.get(), 'remotes', remote), 'r')
909 for line in stream:
910 # Only consider Pull lines
911 m = re.match('^Pull: (.*)\n$', line)
912 if m:
913 branches.append(refspec_localpart(m.group(1)))
914 stream.close()
915 elif remote in __remotes_from_dir('branches'):
916 # old-style branches only declare one branch
917 branches.append('refs/heads/'+remote);
918 else:
919 raise GitException, 'Unknown remote "%s"' % remote
920
921 return branches
922
923 def identify_remote(branchname):
924 """Return the name for the remote to pull the given branchname
925 from, or None if we believe it is a local branch.
926 """
927
928 for remote in remotes_list():
929 if branchname in remotes_local_branches(remote):
930 return remote
931
932 # if we get here we've found nothing, the branch is a local one
933 return None
934
935 def fetch_head():
936 """Return the git id for the tip of the parent branch as left by
937 'git fetch'.
938 """
939
940 fetch_head=None
941 stream = open(os.path.join(basedir.get(), 'FETCH_HEAD'), "r")
942 for line in stream:
943 # Only consider lines not tagged not-for-merge
944 m = re.match('^([^\t]*)\t\t', line)
945 if m:
946 if fetch_head:
947 raise GitException, 'StGit does not support multiple FETCH_HEAD'
948 else:
949 fetch_head=m.group(1)
950 stream.close()
951
952 if not fetch_head:
953 out.warn('No for-merge remote head found in FETCH_HEAD')
954
955 # here we are sure to have a single fetch_head
956 return fetch_head
957
958 def all_refs():
959 """Return a list of all refs in the current repository.
960 """
961
962 return [line.split()[1] for line in GRun('show-ref').output_lines()]
GIT patch-maintenance porcelain (local modifications)