X-Git-Url: https://git.distorted.org.uk/~mdw/stgit/blobdiff_plain/48c930db6aaa1559f0d25030c0a9691170fe715c..9ab06b9858bbb0196867506724a8d74c8f39e113:/stgit/commands/common.py diff --git a/stgit/commands/common.py b/stgit/commands/common.py index 2994eb1..bc8266e 100644 --- a/stgit/commands/common.py +++ b/stgit/commands/common.py @@ -18,9 +18,7 @@ along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA """ -import sys, os, os.path, re -from optparse import OptionParser, make_option - +import sys, os, os.path, re, email.Utils from stgit.exception import * from stgit.utils import * from stgit.out import * @@ -29,113 +27,62 @@ from stgit import stack, git, basedir from stgit.config import config, file_extensions from stgit.lib import stack as libstack from stgit.lib import git as libgit +from stgit.lib import log # Command exception class class CmdException(StgException): pass # Utility functions -class RevParseException(StgException): - """Revision spec parse error.""" - pass - 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 //.""" - if '/' in ''.join(git.get_heads()): - # We have branch names with / in them. - branch_chars = r'[^@]' - patch_id_mark = r'//' - else: - # No / in branch names. - branch_chars = r'[^@/]' - patch_id_mark = r'(/|//)' - patch_re = r'(?P[^@/]+)' - branch_re = r'@(?P%s+)' % branch_chars - patch_id_re = r'%s(?P[a-z.]*)' % patch_id_mark - - # Try //patch_id. - m = re.match(r'^%s$' % patch_id_re, rev) - if m: - return None, None, m.group('patch_id') - - # Try path[@branch]//patch_id. - m = re.match(r'^%s(%s)?%s$' % (patch_re, branch_re, patch_id_re), rev) - if m: - return m.group('patch'), m.group('branch'), m.group('patch_id') - - # Try patch[@branch]. - m = re.match(r'^%s(%s)?$' % (patch_re, branch_re), rev) - if m: - return m.group('patch'), m.group('branch'), None - - # No, we can't parse that. - raise RevParseException - -def git_id(crt_series, rev): - """Return the GIT id + """Parse a revision specification into its branch:patch parts. """ - if not rev: - return None - - # try a GIT revision first try: - return git.rev_parse(rev + '^{commit}') - except git.GitException: - pass - - # try an StGIT patch name - try: - patch, branch, patch_id = parse_rev(rev) - if branch == None: - series = crt_series - else: - series = stack.Series(branch) - if patch == None: - patch = series.get_current() - if not patch: - raise CmdException, 'No patches applied' - 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': - return series.get_patch(patch).get_bottom() - elif patch_id == 'top.old': - 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 series.get_base() - except RevParseException: - pass - except stack.StackException: - pass + branch, patch = rev.split(':', 1) + except ValueError: + branch = None + patch = rev - raise CmdException, 'Unknown patch or revision: %s' % rev + return (branch, patch) -def git_commit(name, repository, branch = None): +def git_id(crt_series, rev): + """Return the GIT id + """ + # TODO: remove this function once all the occurrences were converted + # to git_commit() + repository = libstack.Repository.default() + return git_commit(rev, repository, crt_series.get_name()).sha1 + +def get_public_ref(branch_name): + """Return the public ref of the branch.""" + public_ref = config.get('branch.%s.public' % branch_name) + if not public_ref: + public_ref = 'refs/heads/%s.public' % branch_name + return public_ref + +def git_commit(name, repository, branch_name = None): """Return the a Commit object if 'name' is a patch name or Git commit. The patch names allowed are in the form ':' and can - be followed by standard symbols used by git-rev-parse. If - is '{base}', it represents the bottom of the stack. + be followed by standard symbols used by git rev-parse. If + is '{base}', it represents the bottom of the stack. If is + {public}, it represents the public branch corresponding to the stack as + described in the 'publish' command. """ # Try a [branch:]patch name first - try: - branch, patch = name.split(':', 1) - except ValueError: - patch = name + branch, patch = parse_rev(name) if not branch: - branch = repository.current_branch_name + branch = branch_name or repository.current_branch_name # The stack base if patch.startswith('{base}'): base_id = repository.get_stack(branch).base.sha1 return repository.rev_parse(base_id + strip_prefix('{base}', patch)) + elif patch.startswith('{public}'): + public_ref = get_public_ref(branch) + return repository.rev_parse(public_ref + + strip_prefix('{public}', patch), + discard_stderr = True) # Other combination of branch and patch try: @@ -150,6 +97,15 @@ def git_commit(name, repository, branch = None): except libgit.RepositoryException: raise CmdException('%s: Unknown patch or revision name' % name) +def color_diff_flags(): + """Return the git flags for coloured diff output if the configuration and + stdout allows.""" + stdout_is_tty = (sys.stdout.isatty() and 'true') or 'false' + if config.get_colorbool('color.diff', stdout_is_tty) == 'true': + return ['--color'] + else: + return [] + def check_local_changes(): if git.local_changes(): raise CmdException('local changes in the tree. Use "refresh" or' @@ -163,8 +119,9 @@ def check_head_top_equal(crt_series): def check_conflicts(): if git.get_conflicts(): - raise CmdException('Unsolved conflicts. Please resolve them first' - ' or revert the changes with "status --reset"') + raise CmdException('Unsolved conflicts. Please fix the conflicts' + ' then use "git add --update " or revert the' + ' changes with "status --reset".') def print_crt_patch(crt_series, branch = None): if not branch: @@ -300,8 +257,8 @@ def parse_patches(patch_args, patch_list, boundary = 0, ordered = False): return patches def name_email(address): - p = parse_name_email(address) - if p: + p = email.Utils.parseaddr(address) + if p[1]: return p else: raise CmdException('Incorrect "name "/"email (name)" string: %s' @@ -314,25 +271,19 @@ def name_email_date(address): else: raise CmdException('Incorrect "name date" string: %s' % address) -def address_or_alias(addr_str): - """Return the address if it contains an e-mail address or look up +def address_or_alias(addr_pair): + """Return a name-email tuple the e-mail address is valid or look up the aliases in the config files. """ - 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]) + addr = addr_pair[1] + if '@' in addr: + # it's an e-mail address + return addr_pair + alias = config.get('mail.alias.' + addr) + if alias: + # it's an alias + return name_email(alias) + raise CmdException, 'unknown e-mail alias: %s' % addr def prepare_rebase(crt_series): # pop all patches @@ -486,12 +437,15 @@ def parse_mail(msg): return (descr, authname, authemail, authdate, diff) -def parse_patch(text): +def parse_patch(text, contains_diff): """Parse the input text and return (description, authname, authemail, authdate, diff) """ - descr, diff = __split_descr_diff(text) - descr, authname, authemail, authdate = __parse_description(descr) + if contains_diff: + (text, diff) = __split_descr_diff(text) + else: + diff = None + (descr, authname, authemail, authdate) = __parse_description(text) # we don't yet have an agreed place for the creation date. # Just return None @@ -508,12 +462,39 @@ def readonly_constant_property(f): return getattr(self, n) return property(new_f) +def update_commit_data(cd, options, allow_edit = False): + """Return a new CommitData object updated according to the command line + options.""" + # Set the commit message from commandline. + if options.message != None: + cd = cd.set_message(options.message) + + # Modify author data. + cd = cd.set_author(options.author(cd.author)) + + # Add Signed-off-by: or similar. + if options.sign_str != None: + sign_str = options.sign_str + else: + sign_str = config.get("stgit.autosign") + if sign_str != None: + cd = cd.set_message( + add_sign_line(cd.message, sign_str, + cd.committer.name, cd.committer.email)) + + # Let user edit the commit message manually. + if allow_edit and not options.message: + cd = cd.set_message(edit_string(cd.message, '.stgit-new.txt')) + + return cd + class DirectoryException(StgException): pass class _Directory(object): - def __init__(self, needs_current_series = True): + def __init__(self, needs_current_series = True, log = True): self.needs_current_series = needs_current_series + self.log = log @readonly_constant_property def git_dir(self): try: @@ -546,6 +527,9 @@ class _Directory(object): ).output_one_line()] def cd_to_topdir(self): os.chdir(self.__topdir_path) + def write_log(self, msg): + if self.log: + log.compat_log_entry(msg) class DirectoryAnywhere(_Directory): def setup(self): @@ -554,6 +538,7 @@ class DirectoryAnywhere(_Directory): class DirectoryHasRepository(_Directory): def setup(self): self.git_dir # might throw an exception + log.compat_log_external_mods() class DirectoryInWorktree(DirectoryHasRepository): def setup(self): @@ -570,6 +555,7 @@ class DirectoryHasRepositoryLib(_Directory): """For commands that use the new infrastructure in stgit.lib.*.""" def __init__(self): self.needs_current_series = False + self.log = False # stgit.lib.transaction handles logging def setup(self): # This will throw an exception if we don't have a repository. self.repository = libstack.Repository.default()