def post_rebase(stack, applied, cmd_name, check_merged):
iw = stack.repository.default_iw
trans = StackTransaction(stack, '%s (reapply)' % cmd_name)
try:
if check_merged:
merged = set(trans.check_merged(applied))
else:
merged = set()
for pn in applied:
trans.push_patch(
pn, iw, allow_interactive=True, already_merged=pn in merged
)
except TransactionHalted:
pass
return trans.run(iw)
def hide_patches(stack, iw, patches):
def allow_conflicts(trans):
# Allow conflicts if the topmost patch stays the same.
if stack.patchorder.applied:
return trans.applied and trans.applied[
-1] == stack.patchorder.applied[-1]
else:
return not trans.applied
trans = StackTransaction(stack, 'hide', allow_conflicts=allow_conflicts)
try:
to_push = trans.hide_patches(lambda pn: pn in patches)
for pn in to_push:
trans.push_patch(pn, iw)
except TransactionHalted:
pass
return trans.execute('hide', iw)
def _squash(stack, iw, name, msg, save_template, patches, no_verify=False):
# If a name was supplied on the command line, make sure it's OK.
def bad_name(pn):
return pn not in patches and stack.patches.exists(pn)
def get_name(cd):
return name or utils.make_patch_name(cd.message, bad_name)
if name and bad_name(name):
raise CmdException('Patch name "%s" already taken' % name)
def make_squashed_patch(trans, new_commit_data):
name = get_name(new_commit_data)
trans.patches[name] = stack.repository.commit(new_commit_data)
trans.unapplied.insert(0, name)
trans = StackTransaction(stack, 'squash', allow_conflicts=True)
push_new_patch = bool(set(patches) & set(trans.applied))
try:
new_commit_data = _squash_patches(trans, patches, msg, save_template,
no_verify)
if new_commit_data:
# We were able to construct the squashed commit
# automatically. So just delete its constituent patches.
to_push = trans.delete_patches(lambda pn: pn in patches)
else:
# Automatic construction failed. So push the patches
# consecutively, so that a second construction attempt is
# guaranteed to work.
to_push = trans.pop_patches(lambda pn: pn in patches)
for pn in patches:
trans.push_patch(pn, iw)
new_commit_data = _squash_patches(
trans, patches, msg, save_template, no_verify
)
popped_extra = trans.delete_patches(lambda pn: pn in patches)
assert not popped_extra
make_squashed_patch(trans, new_commit_data)
# Push the new patch if necessary, and any unrelated patches we've
# had to pop out of the way.
if push_new_patch:
trans.push_patch(get_name(new_commit_data), iw)
for pn in to_push:
trans.push_patch(pn, iw)
except SaveTemplateDone:
trans.abort(iw)
return
except TransactionHalted:
pass
return trans.run(iw)
def __pick_commit(stack, ref_stack, iw, commit, patchname, options):
"""Pick a commit."""
repository = stack.repository
if options.name:
patchname = options.name
elif patchname and options.revert:
patchname = 'revert-' + patchname
if patchname:
patchname = find_patch_name(patchname, stack.patches.exists)
else:
patchname = make_patch_name(commit.data.message_str,
stack.patches.exists)
if options.parent:
parent = git_commit(options.parent, repository, ref_stack.name)
else:
parent = commit.data.parent
if not options.revert:
bottom = parent
top = commit
else:
bottom = commit
top = parent
if options.fold:
out.start('Folding commit %s' % commit.sha1)
diff = repository.diff_tree(bottom.data.tree,
top.data.tree,
pathlimits=options.file)
if diff:
try:
# try a direct git apply first
iw.apply(diff, quiet=True)
except MergeException:
if options.file:
out.done('conflict(s)')
out.error('%s does not apply cleanly' % patchname)
return STGIT_CONFLICT
else:
try:
iw.merge(
bottom.data.tree,
stack.head.data.tree,
top.data.tree,
)
except MergeConflictException as e:
out.done('%s conflicts' % len(e.conflicts))
out.error('%s does not apply cleanly' % patchname,
*e.conflicts)
return STGIT_CONFLICT
out.done()
else:
out.done('no changes')
return STGIT_SUCCESS
elif options.update:
files = [
fn1 for _, _, _, _, _, fn1, fn2 in repository.diff_tree_files(
stack.top.data.parent.data.tree, stack.top.data.tree)
]
diff = repository.diff_tree(bottom.data.tree,
top.data.tree,
pathlimits=files)
out.start('Updating with commit %s' % commit.sha1)
try:
iw.apply(diff, quiet=True)
except MergeException:
out.done('conflict(s)')
out.error('%s does not apply cleanly' % patchname)
return STGIT_CONFLICT
else:
out.done()
return STGIT_SUCCESS
else:
author = commit.data.author
message = commit.data.message_str
if options.revert:
author = Person.author()
if message:
lines = message.splitlines()
subject = lines[0]
body = '\n'.join(lines[2:])
else:
subject = commit.sha1
body = ''
message = 'Revert "%s"\n\nThis reverts commit %s.\n\n%s\n' % (
subject,
commit.sha1,
body,
)
elif options.expose:
fmt = config.get('stgit.pick.expose-format')
message = Run('git', 'show', '--no-patch', '--pretty=' + fmt,
commit.sha1).raw_output()
message = message.rstrip() + '\n'
out.start('Importing commit %s' % commit.sha1)
new_commit = repository.commit(
CommitData(
tree=top.data.tree,
parents=[bottom],
message=message,
author=author,
))
trans = StackTransaction(
stack, 'pick %s from %s' % (patchname, ref_stack.name))
trans.patches[patchname] = new_commit
trans.unapplied.append(patchname)
if not options.unapplied:
try:
trans.push_patch(patchname, iw, allow_interactive=True)
except TransactionHalted:
pass
retval = trans.run(iw, print_current_patch=False)
if retval == STGIT_CONFLICT:
out.done('conflict(s)')
elif stack.patches.get(patchname).is_empty():
out.done('empty patch')
else:
out.done()
return retval
def func(parser, options, args):
repository = directory.repository
if options.create:
if len(args) == 0 or len(args) > 2:
parser.error('incorrect number of arguments')
branch_name = args[0]
committish = None if len(args) < 2 else args[1]
if committish:
check_local_changes(repository)
check_conflicts(repository.default_iw)
try:
stack = repository.get_stack()
except (DetachedHeadException, StackException):
pass
else:
check_head_top_equal(stack)
stack = __create_branch(branch_name, committish)
out.info('Branch "%s" created' % branch_name)
log.log_entry(stack, 'branch --create %s' % stack.name)
return
elif options.clone:
cur_branch = Branch(repository, repository.current_branch_name)
if len(args) == 0:
clone_name = cur_branch.name + time.strftime('-%C%y%m%d-%H%M%S')
elif len(args) == 1:
clone_name = args[0]
else:
parser.error('incorrect number of arguments')
check_local_changes(repository)
check_conflicts(repository.default_iw)
try:
stack = repository.current_stack
except StackException:
stack = None
base = repository.refs.get(repository.head_ref)
else:
check_head_top_equal(stack)
base = stack.base
out.start('Cloning current branch to "%s"' % clone_name)
clone = Stack.create(
repository,
name=clone_name,
create_at=base,
parent_remote=cur_branch.parent_remote,
parent_branch=cur_branch.name,
)
if stack:
for pn in stack.patchorder.all_visible:
patch = stack.patches.get(pn)
clone.patches.new(pn, patch.commit, 'clone %s' % stack.name)
clone.patchorder.set_order(applied=[],
unapplied=stack.patchorder.all_visible,
hidden=[])
trans = StackTransaction(clone, 'clone')
try:
for pn in stack.patchorder.applied:
trans.push_patch(pn)
except TransactionHalted:
pass
trans.run()
prefix = 'branch.%s.' % cur_branch.name
new_prefix = 'branch.%s.' % clone.name
for n, v in list(config.getstartswith(prefix)):
config.set(n.replace(prefix, new_prefix, 1), v)
clone.set_description('clone of "%s"' % cur_branch.name)
clone.switch_to()
out.done()
log.copy_log(log.default_repo(), cur_branch.name, clone.name,
'branch --clone')
return
elif options.delete:
if len(args) != 1:
parser.error('incorrect number of arguments')
__delete_branch(args[0], options.force)
log.delete_log(log.default_repo(), args[0])
return
elif options.cleanup:
if not args:
name = repository.current_branch_name
elif len(args) == 1:
name = args[0]
else:
parser.error('incorrect number of arguments')
__cleanup_branch(name, options.force)
log.delete_log(log.default_repo(), name)
return
elif options.list:
if len(args) != 0:
parser.error('incorrect number of arguments')
branch_names = sorted(
ref.replace('refs/heads/', '', 1) for ref in repository.refs
if ref.startswith('refs/heads/') and not ref.endswith('.stgit'))
if branch_names:
out.info('Available branches:')
max_len = max(len(name) for name in branch_names)
for branch_name in branch_names:
__print_branch(branch_name, max_len)
else:
out.info('No branches')
return
elif options.protect:
if len(args) == 0:
branch_name = repository.current_branch_name
elif len(args) == 1:
branch_name = args[0]
else:
parser.error('incorrect number of arguments')
try:
stack = repository.get_stack(branch_name)
except StackException:
raise CmdException('Branch "%s" is not controlled by StGIT' %
branch_name)
out.start('Protecting branch "%s"' % branch_name)
stack.protected = True
out.done()
return
elif options.rename:
if len(args) == 1:
stack = repository.current_stack
new_name = args[0]
elif len(args) == 2:
stack = repository.get_stack(args[0])
new_name = args[1]
else:
parser.error('incorrect number of arguments')
old_name = stack.name
stack.rename(new_name)
out.info('Renamed branch "%s" to "%s"' % (old_name, new_name))
log.rename_log(repository, old_name, new_name, 'branch --rename')
return
elif options.unprotect:
if len(args) == 0:
branch_name = repository.current_branch_name
elif len(args) == 1:
branch_name = args[0]
else:
parser.error('incorrect number of arguments')
try:
stack = repository.get_stack(branch_name)
except StackException:
raise CmdException('Branch "%s" is not controlled by StGIT' %
branch_name)
out.info('Unprotecting branch "%s"' % branch_name)
stack.protected = False
out.done()
return
elif options.description is not None:
if len(args) == 0:
branch_name = repository.current_branch_name
elif len(args) == 1:
branch_name = args[0]
else:
parser.error('incorrect number of arguments')
Branch(repository, branch_name).set_description(options.description)
return
elif len(args) == 1:
branch_name = args[0]
if branch_name == repository.current_branch_name:
raise CmdException('Branch "%s" is already the current branch' %
branch_name)
if not options.merge:
check_local_changes(repository)
check_conflicts(repository.default_iw)
try:
stack = repository.get_stack()
except StackException:
pass
else:
check_head_top_equal(stack)
out.start('Switching to branch "%s"' % branch_name)
Branch(repository, branch_name).switch_to()
out.done()
return
# default action: print the current branch
if len(args) != 0:
parser.error('incorrect number of arguments')
out.stdout(directory.repository.current_branch_name)
def func(parser, options, args):
"""Synchronise a range of patches
"""
repository = directory.repository
stack = repository.get_stack()
if options.ref_branch:
remote_stack = repository.get_stack(options.ref_branch)
if remote_stack.name == stack.name:
raise CmdException('Cannot synchronise with the current branch')
remote_patches = remote_stack.patchorder.applied
def merge_patch(commit, pname):
return __branch_merge_patch(remote_stack, stack, commit, pname)
elif options.series:
patchdir = os.path.dirname(options.series)
remote_patches = []
with open(options.series) as f:
for line in f:
pn = re.sub('#.*$', '', line).strip()
if not pn:
continue
remote_patches.append(pn)
def merge_patch(commit, pname):
return __series_merge_patch(patchdir, stack, commit, pname)
else:
raise CmdException('No remote branch or series specified')
applied = list(stack.patchorder.applied)
unapplied = list(stack.patchorder.unapplied)
if options.all:
patches = applied
elif len(args) != 0:
patches = parse_patches(args,
applied + unapplied,
len(applied),
ordered=True)
elif applied:
patches = [applied[-1]]
else:
parser.error('no patches applied')
assert patches
# only keep the patches to be synchronised
sync_patches = [p for p in patches if p in remote_patches]
if not sync_patches:
raise CmdException('No common patches to be synchronised')
iw = repository.default_iw
# pop to the one before the first patch to be synchronised
first_patch = sync_patches[0]
if first_patch in applied:
to_pop = applied[applied.index(first_patch) + 1:]
if to_pop:
trans = StackTransaction(stack, 'sync (pop)', check_clean_iw=iw)
popped_extra = trans.pop_patches(lambda pn: pn in to_pop)
assert not popped_extra
retval = trans.run(iw)
assert not retval
pushed = [first_patch]
else:
to_pop = []
pushed = []
popped = to_pop + [p for p in patches if p in unapplied]
trans = StackTransaction(stack, 'sync', check_clean_iw=iw)
try:
for p in pushed + popped:
if p in popped:
trans.push_patch(p, iw=iw)
if p not in sync_patches:
# nothing to synchronise
continue
# the actual sync
out.start('Synchronising "%s"' % p)
commit = trans.patches[p]
# the actual merging (either from a branch or an external file)
tree = merge_patch(commit, p)
if tree:
trans.patches[p] = commit.data.set_tree(tree).commit(
repository)
out.done('updated')
else:
out.done()
except TransactionHalted:
pass
return trans.run(iw)
