X-Git-Url: https://git.distorted.org.uk/~mdw/stgit/blobdiff_plain/ebfd01568102fd1a782eddb026f14fd611fad87e..760a7cfc29f0645056b04e4d6f7c63cb46b4d384:/stgit/commands/branch.py diff --git a/stgit/commands/branch.py b/stgit/commands/branch.py index 8420ec6..8748c0a 100644 --- a/stgit/commands/branch.py +++ b/stgit/commands/branch.py @@ -1,6 +1,3 @@ -"""Branch command -""" - __copyright__ = """ Copyright (C) 2005, Chuck Lever @@ -18,126 +15,220 @@ 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 -from optparse import OptionParser, make_option - +import sys, os, time, re +from stgit.argparse import opt from stgit.commands.common import * from stgit.utils import * -from stgit import stack, git - - -help = 'manage development branches' -usage = """%prog [options] branch-name [commit-id] - -Create, list, switch between, rename, or delete development branches -within a git repository. By default, a single branch called 'master' -is always created in a new repository. This subcommand allows you to -manage several patch series in the same repository. - -When displaying the branches, the names can be prefixed with -'s' (StGIT managed) or 'p' (protected).""" - -options = [make_option('-c', '--create', - help = 'create a new development branch', - action = 'store_true'), - make_option('--delete', - help = 'delete an existing development branch', - action = 'store_true'), - make_option('--force', - help = 'force a delete when the series is not empty', - action = 'store_true'), - make_option('-l', '--list', - help = 'list branches contained in this repository', - action = 'store_true'), - make_option('-p', '--protect', - help = 'prevent "stg pull" from modifying this branch', - action = 'store_true'), - make_option('-r', '--rename', - help = 'rename an existing development branch', - action = 'store_true'), - make_option('-u', '--unprotect', - help = 'allow "stg pull" to modify this branch', - action = 'store_true')] - - -def is_current_branch(branch_name): - return git.get_head_file() == branch_name - -def print_branch(branch_name): +from stgit.out import * +from stgit import argparse, stack, git, basedir +from stgit.lib import log + +help = 'Branch operations: switch, list, create, rename, delete, ...' +kind = 'stack' +usage = ['', + '', + '--list', + '--create []', + '--clone []', + '--rename ', + '--protect []', + '--unprotect []', + '--delete [--force] ', + '--description= []'] +description = """ +Create, clone, switch between, rename, or delete development branches +within a git repository. + +'stg branch':: + Display the name of the current branch. + +'stg branch' :: + Switch to the given branch.""" + +args = [argparse.all_branches] +options = [ + opt('-l', '--list', action = 'store_true', + short = 'List the branches contained in this repository', long = """ + List each branch in the current repository, followed by its + branch description (if any). The current branch is prefixed + with '>'. Branches that have been initialized for StGit (with + linkstg:init[]) are prefixed with 's'. Protected branches are + prefixed with 'p'."""), + opt('-c', '--create', action = 'store_true', + short = 'Create (and switch to) a new branch', long = """ + Create (and switch to) a new branch. The new branch is already + initialized as an StGit patch stack, so you do not have to run + linkstg:init[] manually. If you give a committish argument, + the new branch is based there; otherwise, it is based at the + current HEAD. + + StGit will try to detect the branch off of which the new + branch is forked, as well as the remote repository from which + that parent branch is taken (if any), so that running + linkstg:pull[] will automatically pull new commits from the + correct branch. It will warn if it cannot guess the parent + branch (e.g. if you do not specify a branch name as + committish)."""), + opt('--clone', action = 'store_true', + short = 'Clone the contents of the current branch', long = """ + Clone the current branch, under the name if + specified, or using the current branch's name plus a + timestamp. + + The description of the new branch is set to tell it is a clone + of the current branch. The parent information of the new + branch is copied from the current branch."""), + opt('-r', '--rename', action = 'store_true', + short = 'Rename an existing branch'), + opt('-p', '--protect', action = 'store_true', + short = 'Prevent StGit from modifying a branch', long = """ + Prevent StGit from modifying a branch -- either the current + one, or one named on the command line."""), + opt('-u', '--unprotect', action = 'store_true', + short = 'Allow StGit to modify a branch', long = """ + Allow StGit to modify a branch -- either the current one, or + one named on the command line. This undoes the effect of an + earlier 'stg branch --protect' command."""), + opt('--delete', action = 'store_true', + short = 'Delete a branch', long = """ + Delete the named branch. If there are any patches left in the + branch, StGit will refuse to delete it unless you give the + '--force' flag. + + A protected branch cannot be deleted; it must be unprotected + first (see '--unprotect' above). + + If you delete the current branch, you are switched to the + "master" branch, if it exists."""), + opt('-d', '--description', short = 'Set the branch description'), + opt('--force', action = 'store_true', + short = 'Force a delete when the series is not empty')] + +directory = DirectoryGotoToplevel(log = False) + +def __is_current_branch(branch_name): + return crt_series.get_name() == branch_name + +def __print_branch(branch_name, length): initialized = ' ' current = ' ' protected = ' ' branch = stack.Series(branch_name) - if os.path.isdir(os.path.join(git.base_dir, 'patches', branch_name)): + if branch.is_initialised(): initialized = 's' - if is_current_branch(branch_name): + if __is_current_branch(branch_name): current = '>' if branch.get_protected(): protected = 'p' - print '%s %s%s\t%s\t%s' % (current, initialized, protected, branch_name, \ - branch.get_description()) + out.stdout(current + ' ' + initialized + protected + '\t' + + branch_name.ljust(length) + ' | ' + branch.get_description()) -def delete_branch(doomed_name, force = False): +def __delete_branch(doomed_name, force = False): doomed = stack.Series(doomed_name) + if __is_current_branch(doomed_name): + raise CmdException('Cannot delete the current branch') if doomed.get_protected(): raise CmdException, 'This branch is protected. Delete is not permitted' - if is_current_branch(doomed_name) and doomed_name != 'master': - git.switch_branch('master') - + out.start('Deleting branch "%s"' % doomed_name) doomed.delete(force) + out.done() - if doomed_name != 'master': - git.delete_branch(doomed_name) - - print 'Branch "%s" has been deleted.' % doomed_name +def func(parser, options, args): -def rename_branch(from_name, to_name): - if from_name == 'master': - raise CmdException, 'Renaming the master branch is not allowed' + if options.create: - to_patchdir = os.path.join(git.base_dir, 'patches', to_name) - if os.path.isdir(to_patchdir): - raise CmdException, '"%s" already exists' % to_patchdir - to_base = os.path.join(git.base_dir, 'refs', 'bases', to_name) - if os.path.isfile(to_base): - raise CmdException, '"%s" already exists' % to_base + if len(args) == 0 or len(args) > 2: + parser.error('incorrect number of arguments') - git.rename_branch(from_name, to_name) + check_local_changes() + check_conflicts() + check_head_top_equal(crt_series) - from_patchdir = os.path.join(git.base_dir, 'patches', from_name) - if os.path.isdir(from_patchdir): - os.rename(from_patchdir, to_patchdir) - from_base = os.path.join(git.base_dir, 'refs', 'bases', from_name) - if os.path.isfile(from_base): - os.rename(from_base, to_base) + tree_id = None + if len(args) >= 2: + parentbranch = None + try: + branchpoint = git.rev_parse(args[1]) + + # parent branch? + head_re = re.compile('refs/(heads|remotes)/') + ref_re = re.compile(args[1] + '$') + for ref in git.all_refs(): + if head_re.match(ref) and ref_re.search(ref): + # args[1] is a valid ref from the branchpoint + # setting above + parentbranch = args[1] + break; + except git.GitException: + # should use a more specific exception to catch only + # non-git refs ? + out.info('Don\'t know how to determine parent branch' + ' from "%s"' % args[1]) + # exception in branch = rev_parse() leaves branchpoint unbound + branchpoint = None + + tree_id = git_id(crt_series, branchpoint or args[1]) + + if parentbranch: + out.info('Recording "%s" as parent branch' % parentbranch) + else: + out.info('Don\'t know how to determine parent branch' + ' from "%s"' % args[1]) + else: + # branch stack off current branch + parentbranch = git.get_head_file() + + if parentbranch: + parentremote = git.identify_remote(parentbranch) + if parentremote: + out.info('Using remote "%s" to pull parent from' + % parentremote) + else: + out.info('Recording as a local branch') + else: + # no known parent branch, can't guess the remote + parentremote = None - print 'Renamed branch "%s" as "%s".' % (from_name, to_name) + stack.Series(args[0]).init(create_at = tree_id, + parent_remote = parentremote, + parent_branch = parentbranch) -def func(parser, options, args): + out.info('Branch "%s" created' % args[0]) + log.compat_log_entry('branch --create') + return - if options.create: + elif options.clone: - if len(args) == 0 or len(args) > 2: + if len(args) == 0: + clone = crt_series.get_name() + \ + time.strftime('-%C%y%m%d-%H%M%S') + elif len(args) == 1: + clone = args[0] + else: parser.error('incorrect number of arguments') - tree_id = None - if len(args) == 2: - tree_id = args[1] - git.create_branch(args[0], tree_id) - stack.Series(args[0]).init() + check_local_changes() + check_conflicts() + check_head_top_equal(crt_series) + + out.start('Cloning current branch to "%s"' % clone) + crt_series.clone(clone) + out.done() - print 'Branch "%s" created.' % args[0] + log.copy_log(log.default_repo(), crt_series.get_name(), clone, + 'branch --clone') return elif options.delete: if len(args) != 1: parser.error('incorrect number of arguments') - delete_branch(args[0], options.force) + __delete_branch(args[0], options.force) + log.delete_log(log.default_repo(), args[0]) return elif options.list: @@ -145,31 +236,38 @@ def func(parser, options, args): if len(args) != 0: parser.error('incorrect number of arguments') - branches = os.listdir(os.path.join(git.base_dir, 'refs', 'heads')) - branches.sort() - - print 'Available branches:' - for i in branches: - print_branch(i) + branches = set(git.get_heads()) + for br in set(branches): + m = re.match(r'^(.*)\.stgit$', br) + if m and m.group(1) in branches: + branches.remove(br) + + if branches: + out.info('Available branches:') + max_len = max([len(i) for i in branches]) + for i in sorted(branches): + __print_branch(i, max_len) + else: + out.info('No branches') return elif options.protect: if len(args) == 0: - branch = git.get_head_file() + branch_name = crt_series.get_name() elif len(args) == 1: - branch = args[0] + branch_name = args[0] else: parser.error('incorrect number of arguments') + branch = stack.Series(branch_name) - base = os.path.join(git.base_dir, 'refs', 'bases', branch) - if not os.path.isfile(base): - raise CmdException, 'Branch "%s" is not controlled by StGit' % branch + if not branch.is_initialised(): + raise CmdException, 'Branch "%s" is not controlled by StGIT' \ + % branch_name - print 'Protecting branch "%s"...' % branch, - sys.stdout.flush() - stack.Series(branch).protect() - print 'done' + out.start('Protecting branch "%s"' % branch_name) + branch.protect() + out.done() return @@ -177,44 +275,71 @@ def func(parser, options, args): if len(args) != 2: parser.error('incorrect number of arguments') - rename_branch(args[0], args[1]) + + if __is_current_branch(args[0]): + raise CmdException, 'Renaming the current branch is not supported' + + stack.Series(args[0]).rename(args[1]) + + out.info('Renamed branch "%s" to "%s"' % (args[0], args[1])) + log.rename_log(log.default_repo(), args[0], args[1], 'branch --rename') return elif options.unprotect: if len(args) == 0: - branch = git.get_head_file() + branch_name = crt_series.get_name() + elif len(args) == 1: + branch_name = args[0] + else: + parser.error('incorrect number of arguments') + branch = stack.Series(branch_name) + + if not branch.is_initialised(): + raise CmdException, 'Branch "%s" is not controlled by StGIT' \ + % branch_name + + out.info('Unprotecting branch "%s"' % branch_name) + branch.unprotect() + out.done() + + return + + elif options.description is not None: + + if len(args) == 0: + branch_name = crt_series.get_name() elif len(args) == 1: - branch = args[0] + branch_name = args[0] else: parser.error('incorrect number of arguments') + branch = stack.Series(branch_name) - base = os.path.join(git.base_dir, 'refs', 'bases', branch) - if not os.path.isfile(base): - raise CmdException, 'Branch "%s" is not controlled by StGit' % branch + if not branch.is_initialised(): + raise CmdException, 'Branch "%s" is not controlled by StGIT' \ + % branch_name - print 'Unprotecting branch "%s"...' % branch, - sys.stdout.flush() - stack.Series(branch).unprotect() - print 'done' + branch.set_description(options.description) return elif len(args) == 1: - if args[0] == git.get_head_file(): - raise CmdException, 'Branch "%s" is already the current branch' % args[0] + if __is_current_branch(args[0]): + raise CmdException, 'Branch "%s" is already the current branch' \ + % args[0] - print 'Switching to branch "%s"...' % args[0], - sys.stdout.flush() + check_local_changes() + check_conflicts() + check_head_top_equal(crt_series) + out.start('Switching to branch "%s"' % args[0]) git.switch_branch(args[0]) - - print 'done' + out.done() return # default action: print the current branch if len(args) != 0: parser.error('incorrect number of arguments') - print git.get_head_file() + print crt_series.get_name()