thefuck-leeguoo 3.41__py2.py3-none-any.whl

thefuck/rules/no_command.py

@@ -0,0 +1,41 @@
+from thefuck.utils import get_all_executables, get_close_matches, \
+    get_valid_history_without_current, get_closest, which
+from thefuck.specific.sudo import sudo_support
+
+
+@sudo_support
+def match(command):
+    return (not which(command.script_parts[0])
+            and ('not found' in command.output
+                 or 'is not recognized as' in command.output)
+            and bool(get_close_matches(command.script_parts[0],
+                                       get_all_executables())))
+
+
+def _get_used_executables(command):
+    for script in get_valid_history_without_current(command):
+        yield script.split(' ')[0]
+
+
+@sudo_support
+def get_new_command(command):
+    old_command = command.script_parts[0]
+
+    # One from history:
+    already_used = get_closest(
+        old_command, _get_used_executables(command),
+        fallback_to_first=False)
+    if already_used:
+        new_cmds = [already_used]
+    else:
+        new_cmds = []
+
+    # Other from all executables:
+    new_cmds += [cmd for cmd in get_close_matches(old_command,
+                                                  get_all_executables())
+                 if cmd not in new_cmds]
+
+    return [command.script.replace(old_command, cmd, 1) for cmd in new_cmds]
+
+
+priority = 3000

thefuck/rules/no_such_file.py

@@ -0,0 +1,30 @@
+import re
+from thefuck.shells import shell
+
+
+patterns = (
+    r"mv: cannot move '[^']*' to '([^']*)': No such file or directory",
+    r"mv: cannot move '[^']*' to '([^']*)': Not a directory",
+    r"cp: cannot create regular file '([^']*)': No such file or directory",
+    r"cp: cannot create regular file '([^']*)': Not a directory",
+)
+
+
+def match(command):
+    for pattern in patterns:
+        if re.search(pattern, command.output):
+            return True
+
+    return False
+
+
+def get_new_command(command):
+    for pattern in patterns:
+        file = re.findall(pattern, command.output)
+
+        if file:
+            file = file[0]
+            dir = file[0:file.rfind('/')]
+
+            formatme = shell.and_('mkdir -p {}', '{}')
+            return formatme.format(dir, command.script)

thefuck/rules/npm_missing_script.py

@@ -0,0 +1,17 @@
+import re
+from thefuck.utils import for_app, replace_command
+from thefuck.specific.npm import get_scripts, npm_available
+
+enabled_by_default = npm_available
+
+
+@for_app('npm')
+def match(command):
+    return (any(part.startswith('ru') for part in command.script_parts)
+            and 'npm ERR! missing script: ' in command.output)
+
+
+def get_new_command(command):
+    misspelled_script = re.findall(
+        r'.*missing script: (.*)\n', command.output)[0]
+    return replace_command(command, misspelled_script, get_scripts())

thefuck/rules/npm_run_script.py

@@ -0,0 +1,17 @@
+from thefuck.specific.npm import npm_available, get_scripts
+from thefuck.utils import for_app
+
+enabled_by_default = npm_available
+
+
+@for_app('npm')
+def match(command):
+    return ('Usage: npm <command>' in command.output
+            and not any(part.startswith('ru') for part in command.script_parts)
+            and command.script_parts[1] in get_scripts())
+
+
+def get_new_command(command):
+    parts = command.script_parts[:]
+    parts.insert(1, 'run-script')
+    return ' '.join(parts)

thefuck/rules/npm_wrong_command.py

@@ -0,0 +1,42 @@
+from thefuck.specific.npm import npm_available
+from thefuck.utils import replace_argument, for_app, eager, get_closest
+from thefuck.specific.sudo import sudo_support
+
+enabled_by_default = npm_available
+
+
+def _get_wrong_command(script_parts):
+    commands = [part for part in script_parts[1:] if not part.startswith('-')]
+    if commands:
+        return commands[0]
+
+
+@sudo_support
+@for_app('npm')
+def match(command):
+    return (command.script_parts[0] == 'npm' and
+            'where <command> is one of:' in command.output and
+            _get_wrong_command(command.script_parts))
+
+
+@eager
+def _get_available_commands(stdout):
+    commands_listing = False
+    for line in stdout.split('\n'):
+        if line.startswith('where <command> is one of:'):
+            commands_listing = True
+        elif commands_listing:
+            if not line:
+                break
+
+            for command in line.split(', '):
+                stripped = command.strip()
+                if stripped:
+                    yield stripped
+
+
+def get_new_command(command):
+    npm_commands = _get_available_commands(command.output)
+    wrong_command = _get_wrong_command(command.script_parts)
+    fixed = get_closest(wrong_command, npm_commands)
+    return replace_argument(command.script, wrong_command, fixed)

thefuck/rules/omnienv_no_such_command.py

@@ -0,0 +1,35 @@
+import re
+from thefuck.utils import (cache, for_app, replace_argument, replace_command,
+                           which)
+from subprocess import PIPE, Popen
+
+
+supported_apps = 'goenv', 'nodenv', 'pyenv', 'rbenv'
+enabled_by_default = any(which(a) for a in supported_apps)
+
+
+COMMON_TYPOS = {
+    'list': ['versions', 'install --list'],
+    'remove': ['uninstall'],
+}
+
+
+@for_app(*supported_apps, at_least=1)
+def match(command):
+    return 'env: no such command ' in command.output
+
+
+def get_app_commands(app):
+    proc = Popen([app, 'commands'], stdout=PIPE)
+    return [line.decode('utf-8').strip() for line in proc.stdout.readlines()]
+
+
+def get_new_command(command):
+    broken = re.findall(r"env: no such command ['`]([^']*)'", command.output)[0]
+    matched = [replace_argument(command.script, broken, common_typo)
+               for common_typo in COMMON_TYPOS.get(broken, [])]
+
+    app = command.script_parts[0]
+    app_commands = cache(which(app))(get_app_commands)(app)
+    matched.extend(replace_command(command, broken, app_commands))
+    return matched

thefuck/rules/open.py

@@ -0,0 +1,40 @@
+# Opens URL's in the default web browser
+#
+# Example:
+# > open github.com
+# The file ~/github.com does not exist.
+# Perhaps you meant 'http://github.com'?
+#
+from thefuck.shells import shell
+from thefuck.utils import eager, for_app
+
+
+def is_arg_url(command):
+    return ('.com' in command.script or
+            '.edu' in command.script or
+            '.info' in command.script or
+            '.io' in command.script or
+            '.ly' in command.script or
+            '.me' in command.script or
+            '.net' in command.script or
+            '.org' in command.script or
+            '.se' in command.script or
+            'www.' in command.script)
+
+
+@for_app('open', 'xdg-open', 'gnome-open', 'kde-open')
+def match(command):
+    return (is_arg_url(command) or
+            command.output.strip().startswith('The file ') and
+            command.output.strip().endswith(' does not exist.'))
+
+
+@eager
+def get_new_command(command):
+    output = command.output.strip()
+    if is_arg_url(command):
+        yield command.script.replace('open ', 'open http://')
+    elif output.startswith('The file ') and output.endswith(' does not exist.'):
+        arg = command.script.split(' ', 1)[1]
+        for option in ['touch', 'mkdir']:
+            yield shell.and_(u'{} {}'.format(option, arg), command.script)

thefuck/rules/pacman.py

@@ -0,0 +1,17 @@
+from thefuck.specific.archlinux import get_pkgfile, archlinux_env
+from thefuck.shells import shell
+
+
+def match(command):
+    return 'not found' in command.output and get_pkgfile(command.script)
+
+
+def get_new_command(command):
+    packages = get_pkgfile(command.script)
+
+    formatme = shell.and_('{} -S {}', '{}')
+    return [formatme.format(pacman, package, command.script)
+            for package in packages]
+
+
+enabled_by_default, pacman = archlinux_env()

thefuck/rules/pacman_invalid_option.py

@@ -0,0 +1,20 @@
+from thefuck.specific.archlinux import archlinux_env
+from thefuck.specific.sudo import sudo_support
+from thefuck.utils import for_app
+import re
+
+
+@sudo_support
+@for_app("pacman")
+def match(command):
+    return command.output.startswith("error: invalid option '-") and any(
+        " -{}".format(option) in command.script for option in "surqfdvt"
+    )
+
+
+def get_new_command(command):
+    option = re.findall(r" -[dfqrstuv]", command.script)[0]
+    return re.sub(option, option.upper(), command.script)
+
+
+enabled_by_default = archlinux_env()

thefuck/rules/pacman_not_found.py

@@ -0,0 +1,26 @@
+""" Fixes wrong package names with pacman or yaourt.
+
+For example the `llc` program is in package `llvm` so this:
+    yay -S llc
+should be:
+    yay -S llvm
+"""
+
+from thefuck.utils import replace_command
+from thefuck.specific.archlinux import get_pkgfile, archlinux_env
+
+
+def match(command):
+    return (command.script_parts
+            and (command.script_parts[0] in ('pacman', 'yay', 'pikaur', 'yaourt')
+                 or command.script_parts[0:2] == ['sudo', 'pacman'])
+            and 'error: target not found:' in command.output)
+
+
+def get_new_command(command):
+    pgr = command.script_parts[-1]
+
+    return replace_command(command, pgr, get_pkgfile(pgr))
+
+
+enabled_by_default, _ = archlinux_env()

thefuck/rules/path_from_history.py

@@ -0,0 +1,53 @@
+from collections import Counter
+import re
+from thefuck.system import Path
+from thefuck.utils import (get_valid_history_without_current,
+                           memoize, replace_argument)
+from thefuck.shells import shell
+
+
+patterns = [r'no such file or directory: (.*)$',
+            r"cannot access '(.*)': No such file or directory",
+            r': (.*): No such file or directory',
+            r"can't cd to (.*)$"]
+
+
+@memoize
+def _get_destination(command):
+    for pattern in patterns:
+        found = re.findall(pattern, command.output)
+        if found:
+            if found[0] in command.script_parts:
+                return found[0]
+
+
+def match(command):
+    return bool(_get_destination(command))
+
+
+def _get_all_absolute_paths_from_history(command):
+    counter = Counter()
+
+    for line in get_valid_history_without_current(command):
+        splitted = shell.split_command(line)
+
+        for param in splitted[1:]:
+            if param.startswith('/') or param.startswith('~'):
+                if param.endswith('/'):
+                    param = param[:-1]
+
+                counter[param] += 1
+
+    return (path for path, _ in counter.most_common(None))
+
+
+def get_new_command(command):
+    destination = _get_destination(command)
+    paths = _get_all_absolute_paths_from_history(command)
+
+    return [replace_argument(command.script, destination, path)
+            for path in paths if path.endswith(destination)
+            and Path(path).expanduser().exists()]
+
+
+priority = 800

thefuck/rules/php_s.py

@@ -0,0 +1,11 @@
+from thefuck.utils import replace_argument, for_app
+
+
+@for_app('php', at_least=2)
+def match(command):
+    return ('-s' in command.script_parts
+            and command.script_parts[-1] != '-s')
+
+
+def get_new_command(command):
+    return replace_argument(command.script, "-s", "-S")

thefuck/rules/pip_install.py

@@ -0,0 +1,15 @@
+from thefuck.utils import for_app
+from thefuck.specific.sudo import sudo_support
+
+
+@sudo_support
+@for_app('pip')
+def match(command):
+    return ('pip install' in command.script and 'Permission denied' in command.output)
+
+
+def get_new_command(command):
+    if '--user' not in command.script:  # add --user (attempt 1)
+        return command.script.replace(' install ', ' install --user ')
+
+    return 'sudo {}'.format(command.script.replace(' --user', ''))  # since --user didn't fix things, let's try sudo (attempt 2)

thefuck/rules/pip_unknown_command.py

@@ -0,0 +1,19 @@
+import re
+from thefuck.utils import replace_argument, for_app
+from thefuck.specific.sudo import sudo_support
+
+
+@sudo_support
+@for_app('pip', 'pip2', 'pip3')
+def match(command):
+    return ('pip' in command.script and
+            'unknown command' in command.output and
+            'maybe you meant' in command.output)
+
+
+def get_new_command(command):
+    broken_cmd = re.findall(r'ERROR: unknown command "([^"]+)"',
+                            command.output)[0]
+    new_cmd = re.findall(r'maybe you meant "([^"]+)"', command.output)[0]
+
+    return replace_argument(command.script, broken_cmd, new_cmd)

thefuck/rules/port_already_in_use.py

@@ -0,0 +1,40 @@
+import re
+from subprocess import Popen, PIPE
+from thefuck.utils import memoize, which
+from thefuck.shells import shell
+
+enabled_by_default = bool(which('lsof'))
+
+patterns = [r"bind on address \('.*', (?P<port>\d+)\)",
+            r'Unable to bind [^ ]*:(?P<port>\d+)',
+            r"can't listen on port (?P<port>\d+)",
+            r'listen EADDRINUSE [^ ]*:(?P<port>\d+)']
+
+
+@memoize
+def _get_pid_by_port(port):
+    proc = Popen(['lsof', '-i', ':{}'.format(port)], stdout=PIPE)
+    lines = proc.stdout.read().decode().split('\n')
+    if len(lines) > 1:
+        return lines[1].split()[1]
+    else:
+        return None
+
+
+@memoize
+def _get_used_port(command):
+    for pattern in patterns:
+        matched = re.search(pattern, command.output)
+        if matched:
+            return matched.group('port')
+
+
+def match(command):
+    port = _get_used_port(command)
+    return port and _get_pid_by_port(port)
+
+
+def get_new_command(command):
+    port = _get_used_port(command)
+    pid = _get_pid_by_port(port)
+    return shell.and_(u'kill {}'.format(pid), command.script)

thefuck/rules/prove_recursively.py

@@ -0,0 +1,27 @@
+import os
+from thefuck.utils import for_app
+
+
+def _is_recursive(part):
+    if part == '--recurse':
+        return True
+    elif not part.startswith('--') and part.startswith('-') and 'r' in part:
+        return True
+
+
+def _isdir(part):
+    return not part.startswith('-') and os.path.isdir(part)
+
+
+@for_app('prove')
+def match(command):
+    return (
+        'NOTESTS' in command.output
+        and not any(_is_recursive(part) for part in command.script_parts[1:])
+        and any(_isdir(part) for part in command.script_parts[1:]))
+
+
+def get_new_command(command):
+    parts = command.script_parts[:]
+    parts.insert(1, '-r')
+    return u' '.join(parts)

thefuck/rules/python_command.py

@@ -0,0 +1,17 @@
+from thefuck.specific.sudo import sudo_support
+# add 'python' suffix to the command if
+#  1) The script does not have execute permission or
+#  2) is interpreted as shell script
+
+
+@sudo_support
+def match(command):
+    return (command.script_parts
+            and command.script_parts[0].endswith('.py')
+            and ('Permission denied' in command.output or
+                 'command not found' in command.output))
+
+
+@sudo_support
+def get_new_command(command):
+    return 'python ' + command.script

thefuck/rules/python_execute.py

@@ -0,0 +1,15 @@
+# Appends .py when executing python files
+#
+# Example:
+# > python foo
+# error: python: can't open file 'foo': [Errno 2] No such file or directory
+from thefuck.utils import for_app
+
+
+@for_app('python')
+def match(command):
+    return not command.script.endswith('.py')
+
+
+def get_new_command(command):
+    return command.script + '.py'

thefuck/rules/python_module_error.py

@@ -0,0 +1,13 @@
+import re
+from thefuck.shells import shell
+
+MISSING_MODULE = r"ModuleNotFoundError: No module named '([^']+)'"
+
+
+def match(command):
+    return "ModuleNotFoundError: No module named '" in command.output
+
+
+def get_new_command(command):
+    missing_module = re.findall(MISSING_MODULE, command.output)[0]
+    return shell.and_("pip install {}".format(missing_module), command.script)

thefuck/rules/quotation_marks.py

@@ -0,0 +1,12 @@
+# Fixes careless " and ' usage
+#
+# Example:
+# > git commit -m 'My Message"
+
+
+def match(command):
+    return '\'' in command.script and '\"' in command.script
+
+
+def get_new_command(command):
+    return command.script.replace('\'', '\"')

thefuck/rules/rails_migrations_pending.py

@@ -0,0 +1,14 @@
+import re
+from thefuck.shells import shell
+
+
+SUGGESTION_REGEX = r"To resolve this issue, run:\s+(.*?)\n"
+
+
+def match(command):
+    return "Migrations are pending. To resolve this issue, run:" in command.output
+
+
+def get_new_command(command):
+    migration_script = re.search(SUGGESTION_REGEX, command.output).group(1)
+    return shell.and_(migration_script, command.script)

thefuck/rules/react_native_command_unrecognized.py

@@ -0,0 +1,34 @@
+import re
+from subprocess import Popen, PIPE
+from thefuck.utils import for_app, replace_command, cache, eager
+
+
+@for_app('react-native')
+def match(command):
+    return re.findall(r"Unrecognized command '.*'", command.output)
+
+
+@cache('package.json')
+@eager
+def _get_commands():
+    proc = Popen(['react-native', '--help'], stdout=PIPE)
+    should_yield = False
+    for line in proc.stdout.readlines():
+        line = line.decode().strip()
+
+        if not line:
+            continue
+
+        if 'Commands:' in line:
+            should_yield = True
+            continue
+
+        if should_yield:
+            yield line.split(' ')[0]
+
+
+def get_new_command(command):
+    misspelled_command = re.findall(r"Unrecognized command '(.*)'",
+                                    command.output)[0]
+    commands = _get_commands()
+    return replace_command(command, misspelled_command, commands)

thefuck/rules/remove_shell_prompt_literal.py

@@ -0,0 +1,23 @@
+"""Fixes error for commands containing one or more occurrences of the shell
+prompt symbol '$'.
+
+This usually happens when commands are copied from documentations
+including them in their code blocks.
+
+Example:
+> $ git clone https://github.com/nvbn/thefuck.git
+bash: $: command not found...
+"""
+
+import re
+
+
+def match(command):
+    return (
+        "$: command not found" in command.output
+        and re.search(r"^[\s]*\$ [\S]+", command.script) is not None
+    )
+
+
+def get_new_command(command):
+    return command.script.lstrip("$ ")

thefuck/rules/remove_trailing_cedilla.py

@@ -0,0 +1,11 @@
+# -*- encoding: utf-8 -*-
+
+CEDILLA = u"ç"
+
+
+def match(command):
+    return command.script.endswith(CEDILLA)
+
+
+def get_new_command(command):
+    return command.script[:-1]

thefuck/rules/rm_dir.py

@@ -0,0 +1,16 @@
+import re
+from thefuck.specific.sudo import sudo_support
+
+
+@sudo_support
+def match(command):
+    return ('rm' in command.script
+            and 'is a directory' in command.output.lower())
+
+
+@sudo_support
+def get_new_command(command):
+    arguments = '-rf'
+    if 'hdfs' in command.script:
+        arguments = '-r'
+    return re.sub('\\brm (.*)', 'rm ' + arguments + ' \\1', command.script)

thefuck/rules/rm_root.py

@@ -0,0 +1,16 @@
+from thefuck.specific.sudo import sudo_support
+
+enabled_by_default = False
+
+
+@sudo_support
+def match(command):
+    return (command.script_parts
+            and {'rm', '/'}.issubset(command.script_parts)
+            and '--no-preserve-root' not in command.script
+            and '--no-preserve-root' in command.output)
+
+
+@sudo_support
+def get_new_command(command):
+    return u'{} --no-preserve-root'.format(command.script)