From a0719f488e562327b245e664ff37351eeed3cc9d Mon Sep 17 00:00:00 2001 From: William Ting Date: Wed, 19 Jul 2017 23:17:11 -0700 Subject: [PATCH] (Running pre-commit) Use Yelp-style indentation. --- bin/autojump | 91 ++++++--- bin/autojump_argparse.py | 375 ++++++++++++++++++++++---------------- bin/autojump_data.py | 10 +- bin/autojump_match.py | 6 +- bin/autojump_utils.py | 7 +- install.py | 57 ++++-- tools/autojump_ipython.py | 3 +- uninstall.py | 49 +++-- 8 files changed, 372 insertions(+), 226 deletions(-) diff --git a/bin/autojump b/bin/autojump index 2339f0c..d047bcb 100755 --- a/bin/autojump +++ b/bin/autojump @@ -78,11 +78,13 @@ def set_defaults(): data_home = os.path.join( os.path.expanduser('~'), 'Library', - 'autojump') + 'autojump', + ) elif is_windows(): data_home = os.path.join( os.getenv('APPDATA'), - 'autojump') + 'autojump', + ) else: data_home = os.getenv( 'XDG_DATA_HOME', @@ -90,7 +92,9 @@ def set_defaults(): os.path.expanduser('~'), '.local', 'share', - 'autojump')) + 'autojump', + ), + ) config['data_path'] = os.path.join(data_home, 'autojump.txt') config['backup_path'] = os.path.join(data_home, 'autojump.txt.bak') @@ -101,33 +105,42 @@ def set_defaults(): def parse_arguments(): parser = ArgumentParser( description='Automatically jump to directory passed as an argument.', - epilog='Please see autojump(1) man pages for full documentation.') + epilog='Please see autojump(1) man pages for full documentation.', + ) parser.add_argument( 'directory', metavar='DIRECTORY', nargs='*', default='', - help='directory to jump to') + help='directory to jump to', + ) parser.add_argument( '-a', '--add', metavar='DIRECTORY', - help='add path') + help='add path', + ) parser.add_argument( '-i', '--increase', metavar='WEIGHT', nargs='?', type=int, const=10, default=False, - help='increase current directory weight') + help='increase current directory weight', + ) parser.add_argument( '-d', '--decrease', metavar='WEIGHT', nargs='?', type=int, const=15, default=False, - help='decrease current directory weight') + help='decrease current directory weight', + ) parser.add_argument( '--complete', action='store_true', default=False, - help='used for tab completion') + help='used for tab completion', + ) parser.add_argument( '--purge', action='store_true', default=False, - help='remove non-existent paths from database') + help='remove non-existent paths from database', + ) parser.add_argument( '-s', '--stat', action='store_true', default=False, - help='show database entries and their key weights') + help='show database entries and their key weights', + ) parser.add_argument( '-v', '--version', action='version', version='%(prog)s v' + - VERSION, help='show version information') + VERSION, help='show version information', + ) return parser.parse_args() @@ -187,14 +200,17 @@ def find_matches(entries, needles, check_entries=True): data = sorted( entries, key=attrgetter('weight', 'path'), - reverse=True) + reverse=True, + ) return ifilter( lambda entry: not is_cwd(entry) and path_exists(entry), chain( match_consecutive(needles, data, ignore_case), match_fuzzy(needles, data, ignore_case), - match_anywhere(needles, data, ignore_case))) + match_anywhere(needles, data, ignore_case), + ), + ) def handle_tab_completion(needle, entries): @@ -206,24 +222,33 @@ def handle_tab_completion(needle, entries): get_ith_path = lambda i, iterable: last(take(i, iterable)).path print_local(get_ith_path( tab_index, - find_matches(entries, [tab_needle], check_entries=False))) + find_matches(entries, [tab_needle], check_entries=False), + )) elif tab_needle: # found partial tab completion entry print_tab_menu( tab_needle, - take(TAB_ENTRIES_COUNT, find_matches( - entries, - [tab_needle], - check_entries=False)), - TAB_SEPARATOR) + take( + TAB_ENTRIES_COUNT, find_matches( + entries, + [tab_needle], + check_entries=False, + ), + ), + TAB_SEPARATOR, + ) else: print_tab_menu( needle, - take(TAB_ENTRIES_COUNT, find_matches( - entries, - [needle], - check_entries=False)), - TAB_SEPARATOR) + take( + TAB_ENTRIES_COUNT, find_matches( + entries, + [needle], + check_entries=False, + ), + ), + TAB_SEPARATOR, + ) def purge_missing_paths(entries): @@ -242,7 +267,8 @@ def print_stats(data, data_path): try: print_local( - '%.2f:\t current directory weight' % data.get(os.getcwdu(), 0)) + '%.2f:\t current directory weight' % data.get(os.getcwdu(), 0), + ) except OSError: # current directory no longer exists pass @@ -265,7 +291,8 @@ def main(args): # noqa elif args.complete: handle_tab_completion( needle=first(chain(sanitize(args.directory), [''])), - entries=entriefy(load(config))) + entries=entriefy(load(config)), + ) elif args.decrease: data, entry = decrease_path(load(config), get_pwd(), args.decrease) save(config, data) @@ -287,7 +314,8 @@ def main(args): # noqa print_local(first(chain( imap(attrgetter('path'), find_matches(entries, [''])), # always return a path to calling shell functions - ['.']))) + ['.'], + ))) else: entries = entriefy(load(config)) needles = sanitize(args.directory) @@ -306,12 +334,15 @@ def main(args): # noqa print_local( get_ith_path( tab_index, - find_matches(entries, [tab_needle]))) + find_matches(entries, [tab_needle]), + ), + ) else: print_local(first(chain( imap(attrgetter('path'), find_matches(entries, needles)), # always return a path to calling shell functions - ['.']))) + ['.'], + ))) return 0 diff --git a/bin/autojump_argparse.py b/bin/autojump_argparse.py index 920eed4..950db4d 100644 --- a/bin/autojump_argparse.py +++ b/bin/autojump_argparse.py @@ -175,11 +175,13 @@ class HelpFormatter(object): provided by the class are considered an implementation detail. """ - def __init__(self, - prog, - indent_increment=2, - max_help_position=24, - width=None): + def __init__( + self, + prog, + indent_increment=2, + max_help_position=24, + width=None, + ): # default setting for width if width is None: @@ -286,8 +288,10 @@ class HelpFormatter(object): # update the maximum item length invocation_length = max([len(s) for s in invocations]) action_length = invocation_length + self._current_indent - self._action_max_length = max(self._action_max_length, - action_length) + self._action_max_length = max( + self._action_max_length, + action_length, + ) # add the item to the list self._add_item(self._format_action, [action]) @@ -508,8 +512,10 @@ class HelpFormatter(object): def _format_action(self, action): # determine the required width and the entry label - help_position = min(self._action_max_length + 2, - self._max_help_position) + help_position = min( + self._action_max_length + 2, + self._max_help_position, + ) help_width = self._width - help_position action_width = help_position - self._current_indent - 2 action_header = self._format_action_invocation(action) @@ -641,8 +647,10 @@ class HelpFormatter(object): def _fill_text(self, text, width, indent): text = self._whitespace_matcher.sub(' ', text).strip() - return _textwrap.fill(text, width, initial_indent=indent, - subsequent_indent=indent) + return _textwrap.fill( + text, width, initial_indent=indent, + subsequent_indent=indent, + ) def _get_help_string(self, action): return action.help @@ -724,8 +732,10 @@ class ArgumentError(Exception): format = '%(message)s' else: format = 'argument %(argument_name)s: %(message)s' - return format % dict(message=self.message, - argument_name=self.argument_name) + return format % dict( + message=self.message, + argument_name=self.argument_name, + ) class ArgumentTypeError(Exception): @@ -790,17 +800,19 @@ class Action(_AttributeHolder): help string. If None, the 'dest' value will be used as the name. """ - def __init__(self, - option_strings, - dest, - nargs=None, - const=None, - default=None, - type=None, - choices=None, - required=False, - help=None, - metavar=None): + def __init__( + self, + option_strings, + dest, + nargs=None, + const=None, + default=None, + type=None, + choices=None, + required=False, + help=None, + metavar=None, + ): self.option_strings = option_strings self.dest = dest self.nargs = nargs @@ -832,21 +844,25 @@ class Action(_AttributeHolder): class _StoreAction(Action): - def __init__(self, - option_strings, - dest, - nargs=None, - const=None, - default=None, - type=None, - choices=None, - required=False, - help=None, - metavar=None): + def __init__( + self, + option_strings, + dest, + nargs=None, + const=None, + default=None, + type=None, + choices=None, + required=False, + help=None, + metavar=None, + ): if nargs == 0: - raise ValueError('nargs for store actions must be > 0; if you ' - 'have nothing to store, actions such as store ' - 'true or store const may be more appropriate') + raise ValueError( + 'nargs for store actions must be > 0; if you ' + 'have nothing to store, actions such as store ' + 'true or store const may be more appropriate', + ) if const is not None and nargs != OPTIONAL: raise ValueError('nargs must be %r to supply const' % OPTIONAL) super(_StoreAction, self).__init__( @@ -859,7 +875,8 @@ class _StoreAction(Action): choices=choices, required=required, help=help, - metavar=metavar) + metavar=metavar, + ) def __call__(self, parser, namespace, values, option_string=None): setattr(namespace, self.dest, values) @@ -867,14 +884,16 @@ class _StoreAction(Action): class _StoreConstAction(Action): - def __init__(self, - option_strings, - dest, - const, - default=None, - required=False, - help=None, - metavar=None): + def __init__( + self, + option_strings, + dest, + const, + default=None, + required=False, + help=None, + metavar=None, + ): super(_StoreConstAction, self).__init__( option_strings=option_strings, dest=dest, @@ -882,7 +901,8 @@ class _StoreConstAction(Action): const=const, default=default, required=required, - help=help) + help=help, + ) def __call__(self, parser, namespace, values, option_string=None): setattr(namespace, self.dest, self.const) @@ -890,55 +910,65 @@ class _StoreConstAction(Action): class _StoreTrueAction(_StoreConstAction): - def __init__(self, - option_strings, - dest, - default=False, - required=False, - help=None): + def __init__( + self, + option_strings, + dest, + default=False, + required=False, + help=None, + ): super(_StoreTrueAction, self).__init__( option_strings=option_strings, dest=dest, const=True, default=default, required=required, - help=help) + help=help, + ) class _StoreFalseAction(_StoreConstAction): - def __init__(self, - option_strings, - dest, - default=True, - required=False, - help=None): + def __init__( + self, + option_strings, + dest, + default=True, + required=False, + help=None, + ): super(_StoreFalseAction, self).__init__( option_strings=option_strings, dest=dest, const=False, default=default, required=required, - help=help) + help=help, + ) class _AppendAction(Action): - def __init__(self, - option_strings, - dest, - nargs=None, - const=None, - default=None, - type=None, - choices=None, - required=False, - help=None, - metavar=None): + def __init__( + self, + option_strings, + dest, + nargs=None, + const=None, + default=None, + type=None, + choices=None, + required=False, + help=None, + metavar=None, + ): if nargs == 0: - raise ValueError('nargs for append actions must be > 0; if arg ' - 'strings are not supplying the value to append, ' - 'the append const action may be more appropriate') + raise ValueError( + 'nargs for append actions must be > 0; if arg ' + 'strings are not supplying the value to append, ' + 'the append const action may be more appropriate', + ) if const is not None and nargs != OPTIONAL: raise ValueError('nargs must be %r to supply const' % OPTIONAL) super(_AppendAction, self).__init__( @@ -951,7 +981,8 @@ class _AppendAction(Action): choices=choices, required=required, help=help, - metavar=metavar) + metavar=metavar, + ) def __call__(self, parser, namespace, values, option_string=None): items = _copy.copy(_ensure_value(namespace, self.dest, [])) @@ -961,14 +992,16 @@ class _AppendAction(Action): class _AppendConstAction(Action): - def __init__(self, - option_strings, - dest, - const, - default=None, - required=False, - help=None, - metavar=None): + def __init__( + self, + option_strings, + dest, + const, + default=None, + required=False, + help=None, + metavar=None, + ): super(_AppendConstAction, self).__init__( option_strings=option_strings, dest=dest, @@ -977,7 +1010,8 @@ class _AppendConstAction(Action): default=default, required=required, help=help, - metavar=metavar) + metavar=metavar, + ) def __call__(self, parser, namespace, values, option_string=None): items = _copy.copy(_ensure_value(namespace, self.dest, [])) @@ -987,19 +1021,22 @@ class _AppendConstAction(Action): class _CountAction(Action): - def __init__(self, - option_strings, - dest, - default=None, - required=False, - help=None): + def __init__( + self, + option_strings, + dest, + default=None, + required=False, + help=None, + ): super(_CountAction, self).__init__( option_strings=option_strings, dest=dest, nargs=0, default=default, required=required, - help=help) + help=help, + ) def __call__(self, parser, namespace, values, option_string=None): new_count = _ensure_value(namespace, self.dest, 0) + 1 @@ -1008,17 +1045,20 @@ class _CountAction(Action): class _HelpAction(Action): - def __init__(self, - option_strings, - dest=SUPPRESS, - default=SUPPRESS, - help=None): + def __init__( + self, + option_strings, + dest=SUPPRESS, + default=SUPPRESS, + help=None, + ): super(_HelpAction, self).__init__( option_strings=option_strings, dest=dest, default=default, nargs=0, - help=help) + help=help, + ) def __call__(self, parser, namespace, values, option_string=None): parser.print_help() @@ -1027,18 +1067,21 @@ class _HelpAction(Action): class _VersionAction(Action): - def __init__(self, - option_strings, - version=None, - dest=SUPPRESS, - default=SUPPRESS, - help="show program's version number and exit"): + def __init__( + self, + option_strings, + version=None, + dest=SUPPRESS, + default=SUPPRESS, + help="show program's version number and exit", + ): super(_VersionAction, self).__init__( option_strings=option_strings, dest=dest, default=default, nargs=0, - help=help) + help=help, + ) self.version = version def __call__(self, parser, namespace, values, option_string=None): @@ -1058,13 +1101,15 @@ class _SubParsersAction(Action): sup = super(_SubParsersAction._ChoicesPseudoAction, self) sup.__init__(option_strings=[], dest=name, help=help) - def __init__(self, - option_strings, - prog, - parser_class, - dest=SUPPRESS, - help=None, - metavar=None): + def __init__( + self, + option_strings, + prog, + parser_class, + dest=SUPPRESS, + help=None, + metavar=None, + ): self._prog_prefix = prog self._parser_class = parser_class @@ -1077,7 +1122,8 @@ class _SubParsersAction(Action): nargs=PARSER, choices=self._name_parser_map, help=help, - metavar=metavar) + metavar=metavar, + ) def add_parser(self, name, **kwargs): # set prog from the existing prefix @@ -1118,7 +1164,8 @@ class _SubParsersAction(Action): # store any unrecognized options on the object, so that the top # level parser can decide what to do with them namespace, arg_strings = parser.parse_known_args( - arg_strings, namespace) + arg_strings, namespace, + ) if arg_strings: vars(namespace).setdefault(_UNRECOGNIZED_ARGS_ATTR, []) getattr(namespace, _UNRECOGNIZED_ARGS_ATTR).extend(arg_strings) @@ -1199,11 +1246,13 @@ class Namespace(_AttributeHolder): class _ActionsContainer(object): - def __init__(self, - description, - prefix_chars, - argument_default, - conflict_handler): + def __init__( + self, + description, + prefix_chars, + argument_default, + conflict_handler, + ): super(_ActionsContainer, self).__init__() self.description = description @@ -1372,7 +1421,8 @@ class _ActionsContainer(object): title_group_map[group.title] = self.add_argument_group( title=group.title, description=group.description, - conflict_handler=group.conflict_handler) + conflict_handler=group.conflict_handler, + ) # map the actions to their new group for action in group._group_actions: @@ -1383,7 +1433,8 @@ class _ActionsContainer(object): # description= then this code will need to be expanded as above for group in container._mutually_exclusive_groups: mutex_group = self.add_mutually_exclusive_group( - required=group.required) + required=group.required, + ) # map the actions to their new mutex group for action in group._group_actions: @@ -1416,8 +1467,10 @@ class _ActionsContainer(object): for option_string in args: # error on strings that don't start with an appropriate prefix if not option_string[0] in self.prefix_chars: - msg = _('invalid option string %r: ' - 'must start with a character %r') + msg = _( + 'invalid option string %r: ' + 'must start with a character %r', + ) tup = option_string, self.prefix_chars raise ValueError(msg % tup) @@ -1565,19 +1618,21 @@ class ArgumentParser(_AttributeHolder, _ActionsContainer): - add_help -- Add a -h/-help option """ - def __init__(self, - prog=None, - usage=None, - description=None, - epilog=None, - version=None, - parents=[], - formatter_class=HelpFormatter, - prefix_chars='-', - fromfile_prefix_chars=None, - argument_default=None, - conflict_handler='error', - add_help=True): + def __init__( + self, + prog=None, + usage=None, + description=None, + epilog=None, + version=None, + parents=[], + formatter_class=HelpFormatter, + prefix_chars='-', + fromfile_prefix_chars=None, + argument_default=None, + conflict_handler='error', + add_help=True, + ): if version is not None: import warnings @@ -1585,13 +1640,16 @@ class ArgumentParser(_AttributeHolder, _ActionsContainer): """The "version" argument to ArgumentParser is deprecated. """ """Please use """ """"add_argument(..., action='version', version="N", ...)" """ - """instead""", DeprecationWarning) + """instead""", DeprecationWarning, + ) superinit = super(ArgumentParser, self).__init__ - superinit(description=description, - prefix_chars=prefix_chars, - argument_default=argument_default, - conflict_handler=conflict_handler) + superinit( + description=description, + prefix_chars=prefix_chars, + argument_default=argument_default, + conflict_handler=conflict_handler, + ) # default setting for prog if prog is None: @@ -1625,13 +1683,15 @@ class ArgumentParser(_AttributeHolder, _ActionsContainer): self.add_argument( default_prefix + 'h', default_prefix * 2 + 'help', action='help', default=SUPPRESS, - help=_('show this help message and exit')) + help=_('show this help message and exit'), + ) if self.version: self.add_argument( default_prefix + 'v', default_prefix * 2 + 'version', action='version', default=SUPPRESS, version=self.version, - help=_("show program's version number and exit")) + help=_("show program's version number and exit"), + ) # add parent arguments and defaults for parent in parents: @@ -2088,7 +2148,8 @@ class ArgumentParser(_AttributeHolder, _ActionsContainer): # if multiple actions match, the option string was ambiguous if len(option_tuples) > 1: options = ', '.join( - [option_string for action, option_string, explicit_arg in option_tuples]) + [option_string for action, option_string, explicit_arg in option_tuples], + ) tup = arg_string, options self.error(_('ambiguous option: %s could match %s') % tup) @@ -2218,8 +2279,10 @@ class ArgumentParser(_AttributeHolder, _ActionsContainer): # when nargs='*' on a positional, if there were no command-line # args, use the default if it is anything other than None - elif (not arg_strings and action.nargs == ZERO_OR_MORE and - not action.option_strings): + elif ( + not arg_strings and action.nargs == ZERO_OR_MORE and + not action.option_strings + ): if action.default is not None: value = action.default else: @@ -2287,16 +2350,20 @@ class ArgumentParser(_AttributeHolder, _ActionsContainer): # ======================= def format_usage(self): formatter = self._get_formatter() - formatter.add_usage(self.usage, self._actions, - self._mutually_exclusive_groups) + formatter.add_usage( + self.usage, self._actions, + self._mutually_exclusive_groups, + ) return formatter.format_help() def format_help(self): formatter = self._get_formatter() # usage - formatter.add_usage(self.usage, self._actions, - self._mutually_exclusive_groups) + formatter.add_usage( + self.usage, self._actions, + self._mutually_exclusive_groups, + ) # description formatter.add_text(self.description) @@ -2319,7 +2386,8 @@ class ArgumentParser(_AttributeHolder, _ActionsContainer): warnings.warn( 'The format_version method is deprecated -- the "version" ' 'argument to ArgumentParser is no longer supported.', - DeprecationWarning) + DeprecationWarning, + ) formatter = self._get_formatter() formatter.add_text(self.version) return formatter.format_help() @@ -2345,7 +2413,8 @@ class ArgumentParser(_AttributeHolder, _ActionsContainer): warnings.warn( 'The print_version method is deprecated -- the "version" ' 'argument to ArgumentParser is no longer supported.', - DeprecationWarning) + DeprecationWarning, + ) self._print_message(self.format_version(), file) def _print_message(self, message, file=None): diff --git a/bin/autojump_data.py b/bin/autojump_data.py index 37878ea..2ba7fbb 100644 --- a/bin/autojump_data.py +++ b/bin/autojump_data.py @@ -55,7 +55,8 @@ def load(config): os.path.expanduser('~'), '.local', 'share', - 'autojump') + 'autojump', + ) if is_osx() and os.path.exists(xdg_aj_home): migrate_osx_xdg_data(config) @@ -75,11 +76,14 @@ def load(config): with open( config['data_path'], 'r', encoding='utf-8', - errors='replace') as f: + errors='replace', + ) as f: return dict( imap( tupleize, - ifilter(correct_length, imap(parse, f)))) + ifilter(correct_length, imap(parse, f)), + ), + ) except (IOError, EOFError): return load_backup(config) diff --git a/bin/autojump_match.py b/bin/autojump_match.py index 75f9aca..8747b90 100644 --- a/bin/autojump_match.py +++ b/bin/autojump_match.py @@ -117,11 +117,13 @@ def match_fuzzy(needles, haystack, ignore_case=False, threshold=0.6): needle = last(needles).lower() match_percent = lambda entry: SequenceMatcher( a=needle, - b=end_dir(entry.path.lower())).ratio() + b=end_dir(entry.path.lower()), + ).ratio() else: needle = last(needles) match_percent = lambda entry: SequenceMatcher( a=needle, - b=end_dir(entry.path)).ratio() + b=end_dir(entry.path), + ).ratio() meets_threshold = lambda entry: match_percent(entry) >= threshold return ifilter(meets_threshold, haystack) diff --git a/bin/autojump_utils.py b/bin/autojump_utils.py index 5d40519..d1c48ab 100644 --- a/bin/autojump_utils.py +++ b/bin/autojump_utils.py @@ -56,7 +56,8 @@ def get_tab_entry_info(entry, separator): match_index = re.search(separator + r'([0-9]{1})', entry) match_path = re.search( separator + r'[0-9]{1}' + separator + r'(.*)', - entry) + entry, + ) if match_needle: needle = match_needle.group(1) @@ -163,7 +164,9 @@ def print_tab_menu(needle, tab_entries, separator): separator, i + 1, separator, - entry.path)) + entry.path, + ), + ) def sanitize(directories): diff --git a/install.py b/install.py index 4cc42ac..a44fecc 100755 --- a/install.py +++ b/install.py @@ -45,7 +45,8 @@ def modify_autojump_lua(clink_dir, bin_dir, dryrun=False): """Prepend custom AUTOJUMP_BIN_DIR definition to autojump.lua""" custom_install = "local AUTOJUMP_BIN_DIR = \"%s\"\n" % bin_dir.replace( '\\', - '\\\\') + '\\\\', + ) clink_file = os.path.join(clink_dir, 'autojump.lua') with open(clink_file, 'r') as f: original = f.read() @@ -57,11 +58,13 @@ def parse_arguments(): # noqa if platform.system() == 'Windows': default_user_destdir = os.path.join( os.getenv('LOCALAPPDATA', ''), - 'autojump') + 'autojump', + ) else: default_user_destdir = os.path.join( os.path.expanduser('~'), - '.autojump') + '.autojump', + ) default_user_prefix = '' default_user_zshshare = 'functions' default_system_destdir = '/' @@ -71,28 +74,36 @@ def parse_arguments(): # noqa parser = ArgumentParser( description='Installs autojump globally for root users, otherwise \ - installs in current user\'s home directory.') + installs in current user\'s home directory.' + ) parser.add_argument( '-n', '--dryrun', action='store_true', default=False, - help='simulate installation') + help='simulate installation', + ) parser.add_argument( '-f', '--force', action='store_true', default=False, - help='skip root user, shell type, Python version checks') + help='skip root user, shell type, Python version checks', + ) parser.add_argument( '-d', '--destdir', metavar='DIR', default=default_user_destdir, - help='set destination to DIR') + help='set destination to DIR', + ) parser.add_argument( '-p', '--prefix', metavar='DIR', default=default_user_prefix, - help='set prefix to DIR') + help='set prefix to DIR', + ) parser.add_argument( '-z', '--zshshare', metavar='DIR', default=default_user_zshshare, - help='set zsh share destination to DIR') + help='set zsh share destination to DIR', + ) parser.add_argument( '-c', '--clinkdir', metavar='DIR', default=default_clink_dir, - help='set clink directory location to DIR (Windows only)') + help='set clink directory location to DIR (Windows only)', + ) parser.add_argument( '-s', '--system', action='store_true', default=False, - help='install system wide for all users') + help='install system wide for all users', + ) args = parser.parse_args() @@ -102,18 +113,24 @@ def parse_arguments(): # noqa sys.exit(1) if args.system: if platform.system() == 'Windows': - print('System-wide installation is not supported on Windows.', - file=sys.stderr) + print( + 'System-wide installation is not supported on Windows.', + file=sys.stderr, + ) sys.exit(1) elif os.geteuid() != 0: - print('Please rerun as root for system-wide installation.', - file=sys.stderr) + print( + 'Please rerun as root for system-wide installation.', + file=sys.stderr, + ) sys.exit(1) if platform.system() != 'Windows' \ and get_shell() not in SUPPORTED_SHELLS: - print('Unsupported shell: %s' % os.getenv('SHELL'), - file=sys.stderr) + print( + 'Unsupported shell: %s' % os.getenv('SHELL'), + file=sys.stderr, + ) sys.exit(1) if args.destdir != default_user_destdir \ @@ -125,8 +142,10 @@ def parse_arguments(): # noqa if args.system: if args.custom_install: - print('Custom paths incompatible with --system option.', - file=sys.stderr) + print( + 'Custom paths incompatible with --system option.', + file=sys.stderr, + ) sys.exit(1) args.destdir = default_system_destdir diff --git a/tools/autojump_ipython.py b/tools/autojump_ipython.py index a8b41bc..6030c25 100644 --- a/tools/autojump_ipython.py +++ b/tools/autojump_ipython.py @@ -28,7 +28,8 @@ def j(path): newpath = Popen( cmd, stdout=PIPE, - shell=False).communicate()[0].strip() + shell=False, + ).communicate()[0].strip() if newpath: ip.magic('cd %s' % newpath.decode('utf-8')) diff --git a/uninstall.py b/uninstall.py index 9e9417b..3627245 100755 --- a/uninstall.py +++ b/uninstall.py @@ -25,24 +25,31 @@ def parse_arguments(): default_clink_dir = os.path.join(os.getenv('LOCALAPPDATA', ''), 'clink') parser = ArgumentParser( - description='Uninstalls autojump.') + description='Uninstalls autojump.', + ) parser.add_argument( '-n', '--dryrun', action='store_true', default=False, - help='simulate installation') + help='simulate installation', + ) parser.add_argument( '-u', '--userdata', action='store_true', default=False, - help='delete user data') + help='delete user data', + ) parser.add_argument( '-d', '--destdir', metavar='DIR', - help='custom destdir') + help='custom destdir', + ) parser.add_argument( '-p', '--prefix', metavar='DIR', default='', - help='custom prefix') + help='custom prefix', + ) parser.add_argument( '-z', '--zshshare', metavar='DIR', default='functions', - help='custom zshshare') + help='custom zshshare', + ) parser.add_argument( - '-c', '--clinkdir', metavar='DIR', default=default_clink_dir) + '-c', '--clinkdir', metavar='DIR', default=default_clink_dir, + ) return parser.parse_args() @@ -98,13 +105,15 @@ def remove_system_installation(dryrun=False): default_prefix, 'share', 'man', - 'man1') + 'man1', + ) etc_dir = os.path.join(default_destdir, 'etc', 'profile.d') share_dir = os.path.join( default_destdir, default_prefix, 'share', - 'autojump') + 'autojump', + ) zshshare_dir = os.path.join(default_destdir, default_zshshare) if not os.path.exists(share_dir): @@ -113,8 +122,10 @@ def remove_system_installation(dryrun=False): print('\nFound system installation...') if os.geteuid() != 0: - print('Please rerun as root for system-wide uninstall, skipping...', - file=sys.stderr) + print( + 'Please rerun as root for system-wide uninstall, skipping...', + file=sys.stderr, + ) return rm(os.path.join(bin_dir, 'autojump'), dryrun) @@ -135,11 +146,13 @@ def remove_user_data(dryrun=False): data_home = os.path.join( os.path.expanduser('~'), 'Library', - 'autojump') + 'autojump', + ) elif platform.system() == 'Windows': data_home = os.path.join( os.getenv('APPDATA'), - 'autojump') + 'autojump', + ) else: data_home = os.getenv( 'XDG_DATA_HOME', @@ -147,7 +160,9 @@ def remove_user_data(dryrun=False): os.path.expanduser('~'), '.local', 'share', - 'autojump')) + 'autojump', + ), + ) if os.path.exists(data_home): print('\nFound user data...') @@ -156,8 +171,10 @@ def remove_user_data(dryrun=False): def remove_user_installation(dryrun=False): if platform.system() == 'Windows': - default_destdir = os.path.join(os.getenv('LOCALAPPDATA', ''), - 'autojump') + default_destdir = os.path.join( + os.getenv('LOCALAPPDATA', ''), + 'autojump', + ) clink_dir = os.path.join(os.getenv('LOCALAPPDATA', ''), 'clink') else: default_destdir = os.path.join(os.path.expanduser('~'), '.autojump')