~mdw / stgit / blob
? search:


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