def func(parser, options, args):
"""Show commit log and diff
"""
if options.applied:
patches = crt_series.get_applied()
elif options.unapplied:
patches = crt_series.get_unapplied()
elif len(args) == 0:
patches = ['HEAD']
elif '..' in ' '.join(args):
# patch ranges
applied = crt_series.get_applied()
unapplied = crt_series.get_unapplied()
patches = parse_patches(args, applied + unapplied + \
crt_series.get_hidden(), len(applied))
else:
# individual patches or commit ids
patches = args
if not options.stat:
options.diff_flags.extend(color_diff_flags())
commit_ids = [git_id(crt_series, patch) for patch in patches]
commit_bytes = b'\n'.join(
(Run('git', 'show', *(options.diff_flags +
[commit_id])).decoding(None).raw_output())
for commit_id in commit_ids)
if options.stat:
commit_bytes = git.diffstat(commit_bytes).encode('utf-8')
if commit_bytes:
pager(commit_bytes)
def func(parser, options, args):
"""Show the patches modifying a file."""
repository = directory.repository
stack = repository.get_stack(options.branch)
if not stack.patchorder.applied:
raise CmdException('No patches applied')
iw = repository.default_iw
if not args:
files = iw.changed_files(stack.head.data.tree)
else:
files = iw.ls_files(stack.head.data.tree, args)
if not files:
raise CmdException('No files specified or no local changes')
directory.cd_to_topdir()
# Find set of revisions that modify the selected files.
revs = set(
repository.run(
['git', 'rev-list', '--stdin', stack.base.sha1 + '..' + stack.top.sha1]
)
.raw_input('--\n' + '\n'.join(files))
.output_lines()
)
diff_lines = []
for pn in stack.patchorder.applied:
commit = stack.patches[pn]
if commit.sha1 not in revs:
continue
if options.diff:
diff_lines.extend(
[
b'-' * 79,
pn.encode('utf-8'),
b'-' * 79,
commit.data.message,
b'---',
b'',
repository.diff_tree(
commit.data.parent.data.tree,
commit.data.tree,
pathlimits=files,
diff_opts=options.diff_flags + color_diff_flags(),
),
]
)
else:
out.stdout(pn)
if options.diff:
pager(b'\n'.join(diff_lines))
def func(parser, options, args):
"""Show commit log and diff"""
if args and (options.applied or options.unapplied):
parser.error('patches may not be given with --applied or --unapplied')
elif options.applied and options.unapplied:
parser.error('cannot use both --applied and --unapplied')
repository = directory.repository
stack = repository.get_stack(options.branch)
patchorder = stack.patchorder
if options.applied:
commits = [stack.patches.get(pn).commit for pn in patchorder.applied]
elif options.unapplied:
commits = [stack.patches.get(pn).commit for pn in patchorder.unapplied]
elif not args:
commits = [stack.top]
elif '..' in ' '.join(args):
# patch ranges
patch_names = parse_patches(
args,
patchorder.all,
len(patchorder.applied),
)
commits = [stack.patches.get(pn).commit for pn in patch_names]
else:
commits = []
for name in args:
if stack.patches.exists(name):
commits.append(stack.patches.get(name).commit)
else:
try:
commits.append(
repository.rev_parse(
name, object_type='commit', discard_stderr=True
)
)
except RepositoryException:
raise RepositoryException(
'%s: Unknown patch or revision name' % name
)
cmd = ['git', 'show']
if options.stat:
cmd.extend(['--stat', '--summary'])
else:
cmd.append('--patch')
cmd.extend(options.diff_flags)
cmd.extend(color_diff_flags())
cmd.extend(commit.sha1 for commit in commits)
pager(Run(*cmd).decoding(None).raw_output())
def func(parser, options, args):
"""Show the tree diff"""
repository = directory.repository
if options.revs:
rev_list = options.revs.split('..')
if len(rev_list) not in [1, 2] or not rev_list[0]:
parser.error('incorrect parameters to -r')
elif len(rev_list) == 1:
rev1 = git_commit(rev_list[0], repository)
rev2 = None
else:
rev1 = git_commit(rev_list[0], repository)
if rev_list[1]:
rev2 = git_commit(rev_list[1], repository)
else:
rev2 = None
else:
rev1 = repository.rev_parse('HEAD')
rev2 = None
iw = repository.default_iw
files = iw.ls_files(rev1.data.tree, args)
diff_opts = color_diff_flags()
diff_opts.extend(options.diff_flags)
if rev1 and rev2:
diff = repository.diff_tree(
rev1.data.tree,
rev2.data.tree,
diff_opts=diff_opts,
pathlimits=files,
stat=options.stat,
binary=False,
)
else:
diff = iw.diff(
rev1.data.tree,
diff_opts=diff_opts,
pathlimits=files,
stat=options.stat,
binary=False,
)
pager(diff)
def func(parser, options, args):
"""Show the patches modifying a file
"""
if not args:
files = [path for (stat, path) in git.tree_status(verbose=True)]
# git.tree_status returns absolute paths
else:
files = git.ls_files(args)
directory.cd_to_topdir()
if not files:
raise CmdException('No files specified or no local changes')
applied = crt_series.get_applied()
if not applied:
raise CmdException('No patches applied')
revs = git.modifying_revs(files, crt_series.get_base(),
crt_series.get_head())
revs.reverse()
# build the patch/revision mapping
rev_patch = dict()
for name in applied:
patch = crt_series.get_patch(name)
rev_patch[patch.get_top()] = patch
# print the patch names
diff_lines = []
for rev in revs:
patch = rev_patch[rev]
if options.diff:
diff_lines.extend([
b'-' * 79,
patch.get_name().encode('utf-8'),
b'-' * 79,
patch.get_description().encode('utf-8'),
b'---',
b'',
git.diff(files, patch.get_bottom(), patch.get_top()),
])
else:
out.stdout(patch.get_name())
if options.diff:
pager(b'\n'.join(diff_lines))
def func(parser, options, args):
"""Show the tree diff
"""
args = git.ls_files(args)
directory.cd_to_topdir()
if options.revs:
rev_list = options.revs.split('..')
if len(rev_list) not in [1, 2] or not rev_list[0]:
parser.error('incorrect parameters to -r')
if len(rev_list) == 1:
rev1 = rev_list[0]
rev2 = None
else:
rev1 = rev_list[0]
if rev_list[1]:
rev2 = rev_list[1]
else:
rev2 = None
else:
rev1 = 'HEAD'
rev2 = None
if not options.stat:
options.diff_flags.extend(color_diff_flags())
diff = git.diff(
args,
rev1 and git_id(crt_series, rev1),
rev2 and git_id(crt_series, rev2),
diff_flags=options.diff_flags,
binary=False,
)
if options.stat:
out.stdout_raw(gitlib.diffstat(diff) + '\n')
elif diff:
pager(diff)
def _main():
"""The main function
"""
global prog
sys.argv = list(map(fsdecode_utf8, sys.argv))
prog = os.path.basename(sys.argv[0])
if len(sys.argv) < 2:
print('usage: %s <command>' % prog, file=sys.stderr)
print(' Try "%s --help" for a list of supported commands' % prog,
file=sys.stderr)
sys.exit(utils.STGIT_GENERAL_ERROR)
cmd = sys.argv[1]
if cmd in ['-h', '--help']:
if len(sys.argv) >= 3:
cmd = commands.canonical_cmd(sys.argv[2])
sys.argv[2] = '--help'
else:
print_help()
sys.exit(utils.STGIT_SUCCESS)
if cmd == 'help':
if len(sys.argv) == 3 and not sys.argv[2] in ['-h', '--help']:
cmd = commands.canonical_cmd(sys.argv[2])
sys.argv[0] += ' %s' % cmd
command = commands[cmd]
parser = argparse.make_option_parser(command)
if is_cmd_alias(command):
parser.remove_option('-h')
pager(parser.format_help().encode())
else:
print_help()
sys.exit(utils.STGIT_SUCCESS)
if cmd in ['-v', '--version', 'version']:
from stgit.version import get_version
print('Stacked GIT %s' % get_version())
os.system('git --version')
print('Python version %s' % sys.version)
sys.exit(utils.STGIT_SUCCESS)
if cmd in ['copyright']:
print(__copyright__)
sys.exit(utils.STGIT_SUCCESS)
# re-build the command line arguments
cmd = commands.canonical_cmd(cmd)
sys.argv[0] += ' %s' % cmd
del sys.argv[1]
command = commands[cmd]
if is_cmd_alias(command):
sys.exit(command.func(sys.argv[1:]))
parser = argparse.make_option_parser(command)
directory = command.directory
# These modules are only used from this point onwards and do not
# need to be imported earlier
try:
from configparser import ParsingError, NoSectionError
except ImportError:
from ConfigParser import ParsingError, NoSectionError
from stgit.exception import StgException
from stgit.config import config_setup
from stgit.stack import Series
try:
debug_level = int(environ_get('STGIT_DEBUG_LEVEL', 0))
except ValueError:
out.error('Invalid STGIT_DEBUG_LEVEL environment variable')
sys.exit(utils.STGIT_GENERAL_ERROR)
try:
(options, args) = parser.parse_args()
directory.setup()
config_setup()
# Some commands don't (always) need an initialized series.
if directory.needs_current_series:
if hasattr(options, 'branch') and options.branch:
command.crt_series = Series(options.branch)
else:
command.crt_series = Series()
ret = command.func(parser, options, args)
except (StgException, IOError, ParsingError, NoSectionError) as err:
directory.write_log(cmd)
if debug_level > 0:
traceback.print_exc(file=sys.stderr)
out.error(str(err), title='%s %s' % (prog, cmd))
sys.exit(utils.STGIT_COMMAND_ERROR)
except SystemExit:
# Triggered by the option parser when it finds bad commandline
# parameters.
sys.exit(utils.STGIT_COMMAND_ERROR)
except KeyboardInterrupt:
sys.exit(utils.STGIT_GENERAL_ERROR)
except BaseException:
out.error('Unhandled exception:')
traceback.print_exc(file=sys.stderr)
sys.exit(utils.STGIT_BUG_ERROR)
directory.write_log(cmd)
sys.exit(ret or utils.STGIT_SUCCESS)
def _main(argv):
prog = argv[0] = 'stg'
if len(argv) < 2:
print('usage: %s <command>' % prog, file=sys.stderr)
print(' Try "%s --help" for a list of supported commands' % prog,
file=sys.stderr)
return utils.STGIT_GENERAL_ERROR
cmd = argv[1]
if cmd in ['-h', '--help']:
if len(argv) >= 3:
try:
cmd = commands.canonical_cmd(argv[2])
except KeyError:
return utils.STGIT_GENERAL_ERROR
argv[2] = '--help'
else:
print_help(prog)
return utils.STGIT_SUCCESS
if cmd == 'help':
if len(argv) == 3 and not argv[2] in ['-h', '--help']:
try:
cmd = commands.canonical_cmd(argv[2])
except KeyError:
return utils.STGIT_GENERAL_ERROR
argv[0] += ' %s' % cmd
command = commands[cmd]
parser = argparse.make_option_parser(command)
if is_cmd_alias(command):
parser.remove_option('-h')
pager(parser.format_help().encode())
else:
print_help(prog)
return utils.STGIT_SUCCESS
if cmd in ['-v', '--version', 'version']:
print('Stacked Git %s' % get_version())
os.system('git --version')
os.system('%s --version' % sys.executable)
return utils.STGIT_SUCCESS
if cmd in ['copyright']:
print(__copyright__)
return utils.STGIT_SUCCESS
# re-build the command line arguments
try:
cmd = commands.canonical_cmd(cmd)
except KeyError:
return utils.STGIT_GENERAL_ERROR
argv[0] += ' %s' % cmd
del argv[1]
command = commands[cmd]
if is_cmd_alias(command):
return command.func(argv[1:])
parser = argparse.make_option_parser(command)
# These modules are only used from this point onwards and do not
# need to be imported earlier
from configparser import NoSectionError, ParsingError
from stgit.config import config_setup
from stgit.exception import StgException
from stgit.lib.git import MergeConflictException
try:
debug_level = int(environ_get('STGIT_DEBUG_LEVEL', 0))
except ValueError:
out.error('Invalid STGIT_DEBUG_LEVEL environment variable')
return utils.STGIT_GENERAL_ERROR
try:
(options, args) = parser.parse_args(argv[1:])
command.directory.setup()
config_setup()
return command.func(parser, options, args)
except MergeConflictException as err:
if debug_level > 1:
traceback.print_exc(file=sys.stderr)
for conflict in err.conflicts:
out.err(conflict)
return utils.STGIT_CONFLICT
except (StgException, IOError, ParsingError, NoSectionError) as err:
if debug_level > 0:
traceback.print_exc(file=sys.stderr)
out.error(str(err), title='%s %s' % (prog, cmd))
return utils.STGIT_COMMAND_ERROR
except SystemExit:
# Triggered by the option parser when it finds bad commandline
# parameters.
return utils.STGIT_COMMAND_ERROR
except KeyboardInterrupt:
return utils.STGIT_GENERAL_ERROR
except BaseException:
out.error('Unhandled exception:')
traceback.print_exc(file=sys.stderr)
return utils.STGIT_BUG_ERROR
