X-Git-Url: https://git.distorted.org.uk/~mdw/stgit/blobdiff_plain/860d288db5f555a00a27a05bffd9b19fda154ccb..7e301a7348d0b3006ffa7b2309aa6f40cc29a292:/stgit/commands/common.py?ds=sidebyside diff --git a/stgit/commands/common.py b/stgit/commands/common.py index 6843dcf..0fc157a 100644 --- a/stgit/commands/common.py +++ b/stgit/commands/common.py @@ -22,6 +22,7 @@ import sys, os, os.path, re from optparse import OptionParser, make_option from stgit.utils import * +from stgit.out import * from stgit import stack, git, basedir from stgit.config import config, file_extensions @@ -32,7 +33,6 @@ crt_series = None class CmdException(Exception): pass - # Utility functions class RevParseException(Exception): """Revision spec parse error.""" @@ -42,9 +42,7 @@ def parse_rev(rev): """Parse a revision specification into its patchname@branchname//patch_id parts. If no branch name has a slash in it, also accept / instead of //.""" - files, dirs = list_files_and_dirs(os.path.join(basedir.get(), - 'refs', 'heads')) - if len(dirs) != 0: + if '/' in ''.join(git.get_heads()): # We have branch names with / in them. branch_chars = r'[^@]' patch_id_mark = r'//' @@ -89,7 +87,8 @@ def git_id(rev): patch = series.get_current() if not patch: raise CmdException, 'No patches applied' - if patch in series.get_applied() or patch in series.get_unapplied(): + if patch in series.get_applied() or patch in series.get_unapplied() or \ + patch in series.get_hidden(): if patch_id in ['top', '', None]: return series.get_patch(patch).get_top() elif patch_id == 'bottom': @@ -98,8 +97,10 @@ def git_id(rev): return series.get_patch(patch).get_old_top() elif patch_id == 'bottom.old': return series.get_patch(patch).get_old_bottom() + elif patch_id == 'log': + return series.get_patch(patch).get_log() if patch == 'base' and patch_id == None: - return read_string(series.get_base_file()) + return series.get_base() except RevParseException: pass return git.rev_parse(rev + '^{commit}') @@ -107,18 +108,20 @@ def git_id(rev): def check_local_changes(): if git.local_changes(): raise CmdException, \ - 'local changes in the tree. Use "refresh" to commit them' + 'local changes in the tree. Use "refresh" or "status --reset"' def check_head_top_equal(): if not crt_series.head_top_equal(): - raise CmdException, \ - 'HEAD and top are not the same. You probably committed\n' \ - ' changes to the tree outside of StGIT. If you know what you\n' \ - ' are doing, use the "refresh -f" command' + raise CmdException( +"""HEAD and top are not the same. This can happen if you + modify a branch with git. The "assimilate" command can + fix this situation.""") def check_conflicts(): if os.path.exists(os.path.join(basedir.get(), 'conflicts')): - raise CmdException, 'Unsolved conflicts. Please resolve them first' + raise CmdException, \ + 'Unsolved conflicts. Please resolve them first or\n' \ + ' revert the changes with "status --reset"' def print_crt_patch(branch = None): if not branch: @@ -127,9 +130,9 @@ def print_crt_patch(branch = None): patch = stack.Series(branch).get_current() if patch: - print 'Now at patch "%s"' % patch + out.info('Now at patch "%s"' % patch) else: - print 'No patches applied' + out.info('No patches applied') def resolved(filename, reset = None): if reset: @@ -159,55 +162,115 @@ def push_patches(patches, check_merged = False): """ forwarded = crt_series.forward_patches(patches) if forwarded > 1: - print 'Fast-forwarded patches "%s" - "%s"' % (patches[0], - patches[forwarded - 1]) + out.info('Fast-forwarded patches "%s" - "%s"' + % (patches[0], patches[forwarded - 1])) elif forwarded == 1: - print 'Fast-forwarded patch "%s"' % patches[0] + out.info('Fast-forwarded patch "%s"' % patches[0]) names = patches[forwarded:] # check for patches merged upstream - if check_merged: - print 'Checking for patches merged upstream...', - sys.stdout.flush() + if names and check_merged: + out.start('Checking for patches merged upstream') merged = crt_series.merged_patches(names) - print 'done (%d found)' % len(merged) + out.done('%d found' % len(merged)) else: merged = [] for p in names: - print 'Pushing patch "%s"...' % p, - sys.stdout.flush() + out.start('Pushing patch "%s"' % p) if p in merged: - crt_series.push_patch(p, empty = True) - print 'done (merged upstream)' + crt_series.push_empty_patch(p) + out.done('merged upstream') else: modified = crt_series.push_patch(p) if crt_series.empty_patch(p): - print 'done (empty patch)' + out.done('empty patch') elif modified: - print 'done (modified)' + out.done('modified') else: - print 'done' + out.done() -def pop_patches(patches): +def pop_patches(patches, keep = False): """Pop the patches in the list from the stack. It is assumed that the patches are listed in the stack reverse order. """ - p = patches[-1] - if len(patches) == 1: - print 'Popping patch "%s"...' % p, + if len(patches) == 0: + out.info('Nothing to push/pop') else: - print 'Popping "%s" - "%s" patches...' % (patches[0], p), - sys.stdout.flush() + p = patches[-1] + if len(patches) == 1: + out.start('Popping patch "%s"' % p) + else: + out.start('Popping patches "%s" - "%s"' % (patches[0], p)) + crt_series.pop_patch(p, keep) + out.done() + +def parse_patches(patch_args, patch_list, boundary = 0, ordered = False): + """Parse patch_args list for patch names in patch_list and return + a list. The names can be individual patches and/or in the + patch1..patch2 format. + """ + patches = [] + + for name in patch_args: + pair = name.split('..') + for p in pair: + if p and not p in patch_list: + raise CmdException, 'Unknown patch name: %s' % p + + if len(pair) == 1: + # single patch name + pl = pair + elif len(pair) == 2: + # patch range [p1]..[p2] + # inclusive boundary + if pair[0]: + first = patch_list.index(pair[0]) + else: + first = -1 + # exclusive boundary + if pair[1]: + last = patch_list.index(pair[1]) + 1 + else: + last = -1 + + # only cross the boundary if explicitly asked + if not boundary: + boundary = len(patch_list) + if first < 0: + if last <= boundary: + first = 0 + else: + first = boundary + if last < 0: + if first < boundary: + last = boundary + else: + last = len(patch_list) + + if last > first: + pl = patch_list[first:last] + else: + pl = patch_list[(last - 1):(first + 1)] + pl.reverse() + else: + raise CmdException, 'Malformed patch name: %s' % name + + for p in pl: + if p in patches: + raise CmdException, 'Duplicate patch name: %s' % p - crt_series.pop_patch(p) + patches += pl - print 'done' + if ordered: + patches = [p for p in patch_list if p in patches] + + return patches def name_email(address): """Return a tuple consisting of the name and email parsed from a @@ -234,12 +297,192 @@ def name_email_date(address): return str_list[0] -def make_patch_name(msg): - """Return a string to be used as a patch name. This is generated - from the top line of the string passed as argument. +def address_or_alias(addr_str): + """Return the address if it contains an e-mail address or look up + the aliases in the config files. """ - if not msg: - return None + def __address_or_alias(addr): + if not addr: + return None + if addr.find('@') >= 0: + # it's an e-mail address + return addr + alias = config.get('mail.alias.'+addr) + if alias: + # it's an alias + return alias + raise CmdException, 'unknown e-mail alias: %s' % addr + + addr_list = [__address_or_alias(addr.strip()) + for addr in addr_str.split(',')] + return ', '.join([addr for addr in addr_list if addr]) + +def prepare_rebase(force=None): + if not force: + # Be sure we won't loose results of stg-(un)commit by error. + # Do not require an existing orig-base for compatibility with 0.12 and earlier. + origbase = crt_series._get_field('orig-base') + if origbase and crt_series.get_base() != origbase: + raise CmdException, 'Rebasing would possibly lose data' + + # pop all patches + applied = crt_series.get_applied() + if len(applied) > 0: + out.start('Popping all applied patches') + crt_series.pop_patch(applied[0]) + out.done() + return applied + +def rebase(target): + try: + tree_id = git_id(target) + except: + # it might be that we use a custom rebase command with its own + # target type + tree_id = target + if tree_id == git.get_head(): + out.info('Already at "%s", no need for rebasing.' % target) + return + if target: + out.start('Rebasing to "%s"' % target) + else: + out.start('Rebasing to the default target') + git.rebase(tree_id = tree_id) + out.done() + +def post_rebase(applied, nopush, merged): + # memorize that we rebased to here + crt_series._set_field('orig-base', git.get_head()) + # push the patches back + if not nopush: + push_patches(applied, merged) + +# +# Patch description/e-mail/diff parsing +# +def __end_descr(line): + return re.match('---\s*$', line) or re.match('diff -', line) or \ + re.match('Index: ', line) + +def __split_descr_diff(string): + """Return the description and the diff from the given string + """ + descr = diff = '' + top = True + + for line in string.split('\n'): + if top: + if not __end_descr(line): + descr += line + '\n' + continue + else: + top = False + diff += line + '\n' + + return (descr.rstrip(), diff) + +def __parse_description(descr): + """Parse the patch description and return the new description and + author information (if any). + """ + subject = body = '' + authname = authemail = authdate = None + + descr_lines = [line.rstrip() for line in descr.split('\n')] + if not descr_lines: + raise CmdException, "Empty patch description" + + lasthdr = 0 + end = len(descr_lines) + + # Parse the patch header + for pos in range(0, end): + if not descr_lines[pos]: + continue + # check for a "From|Author:" line + if re.match('\s*(?:from|author):\s+', descr_lines[pos], re.I): + auth = re.findall('^.*?:\s+(.*)$', descr_lines[pos])[0] + authname, authemail = name_email(auth) + lasthdr = pos + 1 + continue + # check for a "Date:" line + if re.match('\s*date:\s+', descr_lines[pos], re.I): + authdate = re.findall('^.*?:\s+(.*)$', descr_lines[pos])[0] + lasthdr = pos + 1 + continue + if subject: + break + # get the subject + subject = descr_lines[pos] + lasthdr = pos + 1 + + # get the body + if lasthdr < end: + body = reduce(lambda x, y: x + '\n' + y, descr_lines[lasthdr:], '') + + return (subject + body, authname, authemail, authdate) + +def parse_mail(msg): + """Parse the message object and return (description, authname, + authemail, authdate, diff) + """ + from email.Header import decode_header, make_header + + def __decode_header(header): + """Decode a qp-encoded e-mail header as per rfc2047""" + try: + words_enc = decode_header(header) + hobj = make_header(words_enc) + except Exception, ex: + raise CmdException, 'header decoding error: %s' % str(ex) + return unicode(hobj).encode('utf-8') + + # parse the headers + if msg.has_key('from'): + authname, authemail = name_email(__decode_header(msg['from'])) + else: + authname = authemail = None + + # '\n\t' can be found on multi-line headers + descr = __decode_header(msg['subject']).replace('\n\t', ' ') + authdate = msg['date'] + + # remove the '[*PATCH*]' expression in the subject + if descr: + descr = re.findall('^(\[.*?[Pp][Aa][Tt][Cc][Hh].*?\])?\s*(.*)$', + descr)[0][1] + else: + raise CmdException, 'Subject: line not found' + + # the rest of the message + msg_text = '' + for part in msg.walk(): + if part.get_content_type() == 'text/plain': + msg_text += part.get_payload(decode = True) + + rem_descr, diff = __split_descr_diff(msg_text) + if rem_descr: + descr += '\n\n' + rem_descr + + # parse the description for author information + descr, descr_authname, descr_authemail, descr_authdate = \ + __parse_description(descr) + if descr_authname: + authname = descr_authname + if descr_authemail: + authemail = descr_authemail + if descr_authdate: + authdate = descr_authdate + + return (descr, authname, authemail, authdate, diff) + +def parse_patch(fobj): + """Parse the input file and return (description, authname, + authemail, authdate, diff) + """ + descr, diff = __split_descr_diff(fobj.read()) + descr, authname, authemail, authdate = __parse_description(descr) - subject_line = msg.lstrip().split('\n', 1)[0].lower() - return re.sub('[\W]+', '-', subject_line).strip('-') + # we don't yet have an agreed place for the creation date. + # Just return None + return (descr, authname, authemail, authdate, diff)