def auto_edit_patch(repo, cd, msg, author, sign_str):
"""Edit the patch noninteractively in a couple of ways:
- If C{msg} is not C{None}, parse it to find a replacement
message, and possibly also replacement author and timestamp.
- C{author} is a function that takes the original
L{Person<stgit.lib.git.Person>} value as argument, and
return the new one.
- C{sign_str}, if not C{None}, is a sign string to append to
the message.
Return a pair: the new L{CommitData<stgit.lib.git.CommitData>};
and the diff text if it didn't apply, or C{None} otherwise."""
if msg is not None:
cd, failed_diff = update_patch_description(repo,
cd,
msg,
contains_diff=False)
assert not failed_diff
a = author(cd.author)
if a != cd.author:
cd = cd.set_author(a)
if sign_str is not None:
cd = cd.set_message(
utils.add_trailer(
cd.message_str,
sign_str,
Person.committer().name,
Person.committer().email,
))
return cd
def auto_edit_patch(repo, cd, msg, contains_diff, author, committer, sign_str):
"""Edit the patch noninteractively in a couple of ways:
- If C{msg} is not C{None}, parse it to find a replacement
message, and possibly also replacement author and
timestamp. If C{contains_diff} is true, also look for a
replacement diff.
- C{author} and C{committer} are two functions that take the
original L{Person<stgit.lib.git.Person>} value as argument,
and return the new one.
- C{sign_str}, if not C{None}, is a sign string to append to
the message.
Return a pair: the new L{CommitData<stgit.lib.git.CommitData>};
and the diff text if it didn't apply, or C{None} otherwise."""
if msg is None:
failed_diff = None
else:
cd, failed_diff = update_patch_description(repo, cd, msg,
contains_diff)
a, c = author(cd.author), committer(cd.committer)
if (a, c) != (cd.author, cd.committer):
cd = cd.set_author(a).set_committer(c)
if sign_str is not None:
cd = cd.set_message(
utils.add_sign_line(
cd.message,
sign_str,
Person.committer().name,
Person.committer().email,
))
return cd, failed_diff
def auto_edit_patch(repo, cd, msg, author, sign_str):
"""Edit the patch noninteractively in a couple of ways:
* If ``msg`` is not None, parse it to find a replacement message, and possibly also
replacement author and timestamp.
* ``author`` is a function that takes the original :class:`stgit.lib.git.Person`
value as argument, and returns the new one.
* ``sign_str, if not None, is a trailer string to append to the message.
:returns: tuple with the new :class:`stgit.lib.git.CommitData` and the diff text if
it did not apply, or None otherwise.
"""
if msg is not None:
cd, failed_diff = update_patch_description(repo,
cd,
msg,
contains_diff=False)
assert not failed_diff
a = author(cd.author)
if a != cd.author:
cd = cd.set_author(a)
if sign_str is not None:
cd = cd.set_message(
utils.add_trailer(
cd.message_str,
sign_str,
Person.committer().name,
Person.committer().email,
))
return cd
def auto_edit_patch(repo, cd, msg, author, trailers):
"""Edit the patch noninteractively in a couple of ways:
* If ``msg`` is not None, parse it to find a replacement message, and possibly also
replacement author and timestamp.
* ``author`` is a function that takes the original :class:`stgit.lib.git.Person`
value as argument, and returns the new one.
* ``trailers`` is a list of trailer strings to append to the message.
:returns: 3-tuple:
- the new :class:`commitdata<stgit.lib.git.commitdata>`
- the patch name if given or none otherwise
- the diff text if it did not apply or none otherwise
"""
if msg is not None:
cd, _, failed_diff = _update_patch_description(repo,
cd,
msg,
contains_diff=False)
assert not failed_diff
a = author(cd.author)
if a != cd.author:
cd = cd.set_author(a)
if trailers:
cd = cd.set_message(
utils.add_trailers(
cd.message_str,
trailers,
Person.committer().name,
Person.committer().email,
))
return cd
def func(parser, options, args):
"""Create a new patch."""
stack = directory.repository.current_stack
if stack.repository.default_index.conflicts():
raise CmdException(
'Cannot create a new patch -- resolve conflicts first')
# Choose a name for the new patch -- or None, which means make one
# up later when we've gotten hold of the commit message.
if len(args) == 0:
name = None
elif len(args) == 1:
name = args[0]
if not stack.patches.is_name_valid(name):
raise CmdException('Invalid patch name: "%s"' % name)
elif name in stack.patches:
raise CmdException('%s: patch already exists' % name)
else:
parser.error('incorrect number of arguments')
if options.verbose:
verbose = options.verbose
else:
verbose = config.getbool('stgit.new.verbose') or False
cd = CommitData(
tree=stack.head.data.tree,
parents=[stack.head],
message='',
author=Person.author(),
committer=Person.committer(),
)
cd = update_commit_data(
stack.repository,
cd,
message=options.message,
author=options.author(cd.author),
trailers=options.trailers,
edit=(not options.save_template and options.message is None),
verbose=verbose,
)
if options.save_template:
options.save_template(cd.message)
return utils.STGIT_SUCCESS
if not options.no_verify:
cd = run_commit_msg_hook(stack.repository, cd)
if name is None:
name = stack.patches.make_name(cd.message_str)
# Write the new patch.
check_head_top_equal(stack)
trans = StackTransaction(stack)
trans.patches[name] = stack.repository.commit(cd)
trans.applied.append(name)
return trans.execute('new: %s' % name)
def __create_commit(repository, tree, parents, options, message=''):
"""Return a new Commit object."""
cd = CommitData(
tree=tree,
parents=parents,
message=message,
author=Person.author(),
committer=Person.committer(),
)
cd = common.update_commit_data(cd, options)
return repository.commit(cd)
def func(parser, options, args):
"""Create a new patch."""
stack = directory.repository.current_stack
if stack.repository.default_index.conflicts():
raise CmdException(
'Cannot create a new patch -- resolve conflicts first')
# Choose a name for the new patch -- or None, which means make one
# up later when we've gotten hold of the commit message.
if len(args) == 0:
name = None
elif len(args) == 1:
name = args[0]
if stack.patches.exists(name):
raise CmdException('%s: patch already exists' % name)
elif not stack.patches.is_name_valid(name):
raise CmdException('Invalid patch name: "%s"' % name)
else:
parser.error('incorrect number of arguments')
cd = CommitData(
tree=stack.head.data.tree,
parents=[stack.head],
message='',
author=Person.author(),
committer=Person.committer(),
)
cd = update_commit_data(cd, options)
if options.save_template:
options.save_template(cd.message.encode('utf-8'))
return utils.STGIT_SUCCESS
if not options.no_verify:
cd = run_commit_msg_hook(stack.repository, cd)
if name is None:
name = utils.make_patch_name(cd.message, stack.patches.exists)
assert stack.patches.is_name_valid(name)
# Write the new patch.
stack.repository.default_iw
trans = StackTransaction(stack, 'new: %s' % name)
trans.patches[name] = stack.repository.commit(cd)
trans.applied.append(name)
return trans.run()
def __create_commit(repository, tree, parents, options, message=''):
"""Return a new Commit object."""
cd = CommitData(
tree=tree,
parents=parents,
message=message,
author=Person.author(),
committer=Person.committer(),
)
cd = update_commit_data(
cd,
message=options.message,
author=options.author(cd.author),
sign_str=options.sign_str,
edit=options.message is None,
)
return repository.commit(cd)