def author(cls):
if not hasattr(cls, '__author'):
cls.__author = cls(name=environ_get('GIT_AUTHOR_NAME', NoValue),
email=environ_get('GIT_AUTHOR_EMAIL', NoValue),
date=Date.maybe(
environ_get('GIT_AUTHOR_DATE', NoValue)),
defaults=cls.user())
return cls.__author
def committer(cls):
if not hasattr(cls, '__committer'):
cls.__committer = cls(
name=environ_get('GIT_COMMITTER_NAME', NoValue),
email=environ_get('GIT_COMMITTER_EMAIL', NoValue),
date=Date.maybe(environ_get('GIT_COMMITTER_DATE', NoValue)),
defaults=cls.user())
return cls.__committer
def committer(cls):
if not hasattr(cls, '_committer'):
user = cls.user()
cls._committer = cls(
environ_get('GIT_COMMITTER_NAME', user.name),
environ_get('GIT_COMMITTER_EMAIL', user.email),
Date.maybe(environ_get('GIT_COMMITTER_DATE')),
)
return cls._committer
def author(cls):
if not hasattr(cls, '_author'):
user = cls.user()
cls._author = cls(
environ_get('GIT_AUTHOR_NAME', user.name),
environ_get('GIT_AUTHOR_EMAIL', user.email),
Date.maybe(environ_get('GIT_AUTHOR_DATE')),
)
return cls._author
def get_editor():
for editor in [
environ_get('GIT_EDITOR'),
config.get('stgit.editor'), # legacy
config.get('core.editor'),
environ_get('VISUAL'),
environ_get('EDITOR'),
'vi',
]:
if editor:
return editor
def committer():
"""Return the author information.
"""
global __committer
if not __committer:
# the environment variables take priority over config
name = environ_get('GIT_COMMITTER_NAME')
email = environ_get('GIT_COMMITTER_EMAIL')
if name is None or email is None:
__committer = user()
else:
date = environ_get('GIT_COMMITTER_DATE', '')
__committer = Person(name, email, date)
return __committer
def default_index(self):
"""An L{Index} object representing the default index file for the
repository."""
if self.__default_index is None:
self.__default_index = Index(
self, (environ_get('GIT_INDEX_FILE', None)
or os.path.join(self.__git_dir, 'index')))
return self.__default_index
def default_worktree(self):
"""A L{Worktree} object representing the default work tree."""
if self._default_worktree is None:
path = environ_get('GIT_WORK_TREE', None)
if not path:
o = Run('git', 'rev-parse', '--show-cdup').output_lines()
o = o or ['.']
assert len(o) == 1
path = o[0]
self._default_worktree = Worktree(path)
return self._default_worktree
def __log_start(self):
if _log_mode == 'debug':
_logfile.start('Running subprocess %s' % self.__cmd)
if self.__cwd is not None:
_logfile.info('cwd: %s' % self.__cwd)
if self.__env is not None:
for k in sorted(self.__env):
v = environ_get(k)
if v is None or v != self.__env[k]:
_logfile.info('%s: %s' % (k, self.__env[k]))
elif _log_mode == 'profile':
_logfile.start('Running subprocess %s' % self.__cmd)
self.__starttime = datetime.datetime.now()
def get():
"""Return the .git directory location
"""
global __base_dir
if not __base_dir:
__base_dir = environ_get('GIT_DIR')
if __base_dir is None:
try:
__base_dir = Run('git', 'rev-parse',
'--git-dir').output_one_line()
except RunException:
__base_dir = ''
return __base_dir
if ':' not in spec:
spec += ':'
(log_mode, outfile) = spec.split(':', 1)
all_log_modes = ['debug', 'profile']
if log_mode and log_mode not in all_log_modes:
out.warn(('Unknown log mode "%s" specified in $STGIT_SUBPROCESS_LOG.'
% log_mode),
'Valid values are: %s' % ', '.join(all_log_modes))
if outfile:
f = MessagePrinter(io.open(outfile, 'a', encoding='utf-8'))
else:
f = out
return (log_mode, f)
_log_mode, _logfile = get_log_mode(environ_get('STGIT_SUBPROCESS_LOG', ''))
if _log_mode == 'profile':
_log_starttime = datetime.datetime.now()
_log_subproctime = 0.0
def duration(t1, t2):
d = t2 - t1
return (
86400 * d.days
+ d.seconds
+ 1e-6 * d.microseconds
)
def finish_logging():
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 default(cls, repository):
index_path = environ_get(
'GIT_INDEX_FILE',
os.path.join(repository.directory, 'index'),
)
return cls(repository, index_path)
def default(cls):
path = environ_get('GIT_WORK_TREE', None)
if not path:
path = Run('git', 'rev-parse', '--show-toplevel').output_one_line()
return cls(path)
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