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

thefuck/rules/apt_invalid_operation.py

@@ -0,0 +1,63 @@
+import subprocess
+from thefuck.specific.apt import apt_available
+from thefuck.specific.sudo import sudo_support
+from thefuck.utils import for_app, eager, replace_command
+
+enabled_by_default = apt_available
+
+
+@sudo_support
+@for_app('apt', 'apt-get', 'apt-cache')
+def match(command):
+    return 'E: Invalid operation' in command.output
+
+
+@eager
+def _parse_apt_operations(help_text_lines):
+    is_commands_list = False
+    for line in help_text_lines:
+        line = line.decode().strip()
+        if is_commands_list and line:
+            yield line.split()[0]
+        elif line.startswith('Basic commands:') \
+                or line.startswith('Most used commands:'):
+            is_commands_list = True
+
+
+@eager
+def _parse_apt_get_and_cache_operations(help_text_lines):
+    is_commands_list = False
+    for line in help_text_lines:
+        line = line.decode().strip()
+        if is_commands_list:
+            if not line:
+                return
+
+            yield line.split()[0]
+        elif line.startswith('Commands:') \
+                or line.startswith('Most used commands:'):
+            is_commands_list = True
+
+
+def _get_operations(app):
+    proc = subprocess.Popen([app, '--help'],
+                            stdout=subprocess.PIPE,
+                            stderr=subprocess.PIPE)
+    lines = proc.stdout.readlines()
+
+    if app == 'apt':
+        return _parse_apt_operations(lines)
+    else:
+        return _parse_apt_get_and_cache_operations(lines)
+
+
+@sudo_support
+def get_new_command(command):
+    invalid_operation = command.output.split()[-1]
+
+    if invalid_operation == 'uninstall':
+        return [command.script.replace('uninstall', 'remove')]
+
+    else:
+        operations = _get_operations(command.script_parts[0])
+        return replace_command(command, invalid_operation, operations)

thefuck/rules/apt_list_upgradable.py

@@ -0,0 +1,16 @@
+from thefuck.specific.apt import apt_available
+from thefuck.specific.sudo import sudo_support
+from thefuck.utils import for_app
+
+enabled_by_default = apt_available
+
+
+@sudo_support
+@for_app('apt')
+def match(command):
+    return 'apt list --upgradable' in command.output
+
+
+@sudo_support
+def get_new_command(command):
+    return 'apt list --upgradable'

thefuck/rules/apt_upgrade.py

@@ -0,0 +1,16 @@
+from thefuck.specific.apt import apt_available
+from thefuck.specific.sudo import sudo_support
+from thefuck.utils import for_app
+
+enabled_by_default = apt_available
+
+
+@sudo_support
+@for_app('apt')
+def match(command):
+    return command.script == "apt list --upgradable" and len(command.output.strip().split('\n')) > 1
+
+
+@sudo_support
+def get_new_command(command):
+    return 'apt upgrade'

thefuck/rules/aws_cli.py

@@ -0,0 +1,17 @@
+import re
+
+from thefuck.utils import for_app, replace_argument
+
+INVALID_CHOICE = "(?<=Invalid choice: ')(.*)(?=', maybe you meant:)"
+OPTIONS = "^\\s*\\*\\s(.*)"
+
+
+@for_app('aws')
+def match(command):
+    return "usage:" in command.output and "maybe you meant:" in command.output
+
+
+def get_new_command(command):
+    mistake = re.search(INVALID_CHOICE, command.output).group(0)
+    options = re.findall(OPTIONS, command.output, flags=re.MULTILINE)
+    return [replace_argument(command.script, mistake, o) for o in options]

thefuck/rules/az_cli.py

@@ -0,0 +1,17 @@
+import re
+
+from thefuck.utils import for_app, replace_argument
+
+INVALID_CHOICE = "(?=az)(?:.*): '(.*)' is not in the '.*' command group."
+OPTIONS = "^The most similar choice to '.*' is:\n\\s*(.*)$"
+
+
+@for_app('az')
+def match(command):
+    return "is not in the" in command.output and "command group" in command.output
+
+
+def get_new_command(command):
+    mistake = re.search(INVALID_CHOICE, command.output).group(1)
+    options = re.findall(OPTIONS, command.output, flags=re.MULTILINE)
+    return [replace_argument(command.script, mistake, o) for o in options]

thefuck/rules/brew_cask_dependency.py

@@ -0,0 +1,33 @@
+from thefuck.utils import for_app, eager
+from thefuck.shells import shell
+from thefuck.specific.brew import brew_available
+
+
+@for_app('brew')
+def match(command):
+    return (u'install' in command.script_parts
+            and u'brew cask install' in command.output)
+
+
+@eager
+def _get_cask_install_lines(output):
+    for line in output.split('\n'):
+        line = line.strip()
+        if line.startswith('brew cask install'):
+            yield line
+
+
+def _get_script_for_brew_cask(output):
+    cask_install_lines = _get_cask_install_lines(output)
+    if len(cask_install_lines) > 1:
+        return shell.and_(*cask_install_lines)
+    else:
+        return cask_install_lines[0]
+
+
+def get_new_command(command):
+    brew_cask_script = _get_script_for_brew_cask(command.output)
+    return shell.and_(brew_cask_script, command.script)
+
+
+enabled_by_default = brew_available

thefuck/rules/brew_install.py

@@ -0,0 +1,24 @@
+import re
+from thefuck.utils import for_app
+from thefuck.specific.brew import brew_available
+
+enabled_by_default = brew_available
+
+
+def _get_suggestions(str):
+    suggestions = str.replace(" or ", ", ").split(", ")
+    return suggestions
+
+
+@for_app('brew', at_least=2)
+def match(command):
+    is_proper_command = ('install' in command.script and
+                         'No available formula' in command.output and
+                         'Did you mean' in command.output)
+    return is_proper_command
+
+
+def get_new_command(command):
+    matcher = re.search('Warning: No available formula with the name "(?:[^"]+)". Did you mean (.+)\\?', command.output)
+    suggestions = _get_suggestions(matcher.group(1))
+    return ["brew install " + formula for formula in suggestions]

thefuck/rules/brew_link.py

@@ -0,0 +1,15 @@
+from thefuck.utils import for_app
+
+
+@for_app('brew', at_least=2)
+def match(command):
+    return (command.script_parts[1] in ['ln', 'link']
+            and "brew link --overwrite --dry-run" in command.output)
+
+
+def get_new_command(command):
+    command_parts = command.script_parts[:]
+    command_parts[1] = 'link'
+    command_parts.insert(2, '--overwrite')
+    command_parts.insert(3, '--dry-run')
+    return ' '.join(command_parts)

thefuck/rules/brew_reinstall.py

@@ -0,0 +1,19 @@
+import re
+from thefuck.utils import for_app
+
+
+warning_regex = re.compile(r'Warning: (?:.(?!is ))+ is already installed and '
+                           r'up-to-date')
+message_regex = re.compile(r'To reinstall (?:(?!, ).)+, run `brew reinstall '
+                           r'[^`]+`')
+
+
+@for_app('brew', at_least=2)
+def match(command):
+    return ('install' in command.script
+            and warning_regex.search(command.output)
+            and message_regex.search(command.output))
+
+
+def get_new_command(command):
+    return command.script.replace('install', 'reinstall')

thefuck/rules/brew_uninstall.py

@@ -0,0 +1,14 @@
+from thefuck.utils import for_app
+
+
+@for_app('brew', at_least=2)
+def match(command):
+    return (command.script_parts[1] in ['uninstall', 'rm', 'remove']
+            and "brew uninstall --force" in command.output)
+
+
+def get_new_command(command):
+    command_parts = command.script_parts[:]
+    command_parts[1] = 'uninstall'
+    command_parts.insert(2, '--force')
+    return ' '.join(command_parts)

thefuck/rules/brew_unknown_command.py

@@ -0,0 +1,82 @@
+import os
+import re
+from thefuck.utils import get_closest, replace_command
+from thefuck.specific.brew import get_brew_path_prefix, brew_available
+
+BREW_CMD_PATH = '/Homebrew/Library/Homebrew/cmd'
+TAP_PATH = '/Homebrew/Library/Taps'
+TAP_CMD_PATH = '/%s/%s/cmd'
+
+enabled_by_default = brew_available
+
+
+def _get_brew_commands(brew_path_prefix):
+    """To get brew default commands on local environment"""
+    brew_cmd_path = brew_path_prefix + BREW_CMD_PATH
+
+    return [name[:-3] for name in os.listdir(brew_cmd_path)
+            if name.endswith(('.rb', '.sh'))]
+
+
+def _get_brew_tap_specific_commands(brew_path_prefix):
+    """To get tap's specific commands
+    https://github.com/Homebrew/homebrew/blob/master/Library/brew.rb#L115"""
+    commands = []
+    brew_taps_path = brew_path_prefix + TAP_PATH
+
+    for user in _get_directory_names_only(brew_taps_path):
+        taps = _get_directory_names_only(brew_taps_path + '/%s' % user)
+
+        # Brew Taps's naming rule
+        # https://github.com/Homebrew/homebrew/blob/master/share/doc/homebrew/brew-tap.md#naming-conventions-and-limitations
+        taps = (tap for tap in taps if tap.startswith('homebrew-'))
+        for tap in taps:
+            tap_cmd_path = brew_taps_path + TAP_CMD_PATH % (user, tap)
+
+            if os.path.isdir(tap_cmd_path):
+                commands += (name.replace('brew-', '').replace('.rb', '')
+                             for name in os.listdir(tap_cmd_path)
+                             if _is_brew_tap_cmd_naming(name))
+
+    return commands
+
+
+def _is_brew_tap_cmd_naming(name):
+    return name.startswith('brew-') and name.endswith('.rb')
+
+
+def _get_directory_names_only(path):
+    return [d for d in os.listdir(path)
+            if os.path.isdir(os.path.join(path, d))]
+
+
+def _brew_commands():
+    brew_path_prefix = get_brew_path_prefix()
+    if brew_path_prefix:
+        try:
+            return (_get_brew_commands(brew_path_prefix)
+                    + _get_brew_tap_specific_commands(brew_path_prefix))
+        except OSError:
+            pass
+
+    # Failback commands for testing (Based on Homebrew 0.9.5)
+    return ['info', 'home', 'options', 'install', 'uninstall',
+            'search', 'list', 'update', 'upgrade', 'pin', 'unpin',
+            'doctor', 'create', 'edit', 'cask']
+
+
+def match(command):
+    is_proper_command = ('brew' in command.script and
+                         'Unknown command' in command.output)
+
+    if is_proper_command:
+        broken_cmd = re.findall(r'Error: Unknown command: ([a-z]+)',
+                                command.output)[0]
+        return bool(get_closest(broken_cmd, _brew_commands()))
+    return False
+
+
+def get_new_command(command):
+    broken_cmd = re.findall(r'Error: Unknown command: ([a-z]+)',
+                            command.output)[0]
+    return replace_command(command, broken_cmd, _brew_commands())

thefuck/rules/brew_update_formula.py

@@ -0,0 +1,12 @@
+from thefuck.utils import for_app
+
+
+@for_app('brew', at_least=2)
+def match(command):
+    return ('update' in command.script
+            and "Error: This command updates brew itself" in command.output
+            and "Use `brew upgrade" in command.output)
+
+
+def get_new_command(command):
+    return command.script.replace('update', 'upgrade')

thefuck/rules/cargo.py

@@ -0,0 +1,6 @@
+def match(command):
+    return command.script == 'cargo'
+
+
+def get_new_command(command):
+    return 'cargo build'

thefuck/rules/cargo_no_command.py

@@ -0,0 +1,15 @@
+import re
+from thefuck.utils import replace_argument, for_app
+
+
+@for_app('cargo', at_least=1)
+def match(command):
+    return ('no such subcommand' in command.output.lower()
+            and 'Did you mean' in command.output)
+
+
+def get_new_command(command):
+    broken = command.script_parts[1]
+    fix = re.findall(r'Did you mean `([^`]*)`', command.output)[0]
+
+    return replace_argument(command.script, broken, fix)

thefuck/rules/cat_dir.py

@@ -0,0 +1,14 @@
+import os
+from thefuck.utils import for_app
+
+
+@for_app('cat', at_least=1)
+def match(command):
+    return (
+        command.output.startswith('cat: ') and
+        os.path.isdir(command.script_parts[1])
+    )
+
+
+def get_new_command(command):
+    return command.script.replace('cat', 'ls', 1)

thefuck/rules/cd_correction.py

@@ -0,0 +1,61 @@
+"""Attempts to spellcheck and correct failed cd commands"""
+
+import os
+import six
+from thefuck.specific.sudo import sudo_support
+from thefuck.rules import cd_mkdir
+from thefuck.utils import for_app, get_close_matches
+
+__author__ = "mmussomele"
+
+MAX_ALLOWED_DIFF = 0.6
+
+
+def _get_sub_dirs(parent):
+    """Returns a list of the child directories of the given parent directory"""
+    return [child for child in os.listdir(parent) if os.path.isdir(os.path.join(parent, child))]
+
+
+@sudo_support
+@for_app('cd')
+def match(command):
+    """Match function copied from cd_mkdir.py"""
+    return (
+        command.script.startswith('cd ') and any((
+            'no such file or directory' in command.output.lower(),
+            'cd: can\'t cd to' in command.output.lower(),
+            'does not exist' in command.output.lower()
+        )))
+
+
+@sudo_support
+def get_new_command(command):
+    """
+    Attempt to rebuild the path string by spellchecking the directories.
+    If it fails (i.e. no directories are a close enough match), then it
+    defaults to the rules of cd_mkdir.
+    Change sensitivity by changing MAX_ALLOWED_DIFF. Default value is 0.6
+    """
+    dest = command.script_parts[1].split(os.sep)
+    if dest[-1] == '':
+        dest = dest[:-1]
+
+    if dest[0] == '':
+        cwd = os.sep
+        dest = dest[1:]
+    elif six.PY2:
+        cwd = os.getcwdu()
+    else:
+        cwd = os.getcwd()
+    for directory in dest:
+        if directory == ".":
+            continue
+        elif directory == "..":
+            cwd = os.path.split(cwd)[0]
+            continue
+        best_matches = get_close_matches(directory, _get_sub_dirs(cwd), cutoff=MAX_ALLOWED_DIFF)
+        if best_matches:
+            cwd = os.path.join(cwd, best_matches[0])
+        else:
+            return cd_mkdir.get_new_command(command)
+    return u'cd "{0}"'.format(cwd)

thefuck/rules/cd_cs.py

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+
+# Redirects cs to cd when there is a typo
+# Due to the proximity of the keys - d and s - this seems like a common typo
+# ~ > cs /etc/
+# cs: command not found
+# ~ > fuck
+# cd /etc/ [enter/↑/↓/ctrl+c]
+# /etc >
+
+
+def match(command):
+    if command.script_parts[0] == 'cs':
+        return True
+
+
+def get_new_command(command):
+    return 'cd' + ''.join(command.script[2:])
+
+
+priority = 900

thefuck/rules/cd_mkdir.py

@@ -0,0 +1,21 @@
+import re
+from thefuck.utils import for_app
+from thefuck.specific.sudo import sudo_support
+from thefuck.shells import shell
+
+
+@sudo_support
+@for_app('cd')
+def match(command):
+    return (
+        command.script.startswith('cd ') and any((
+            'no such file or directory' in command.output.lower(),
+            'cd: can\'t cd to' in command.output.lower(),
+            'does not exist' in command.output.lower()
+        )))
+
+
+@sudo_support
+def get_new_command(command):
+    repl = shell.and_('mkdir -p \\1', 'cd \\1')
+    return re.sub(r'^cd (.*)', repl, command.script)

thefuck/rules/cd_parent.py

@@ -0,0 +1,16 @@
+# Adds the missing space between the cd command and the target directory
+# when trying to cd to the parent directory.
+#
+# Does not really save chars, but is fun :D
+#
+# Example:
+# > cd..
+# cd..: command not found
+
+
+def match(command):
+    return command.script == 'cd..'
+
+
+def get_new_command(command):
+    return 'cd ..'

thefuck/rules/chmod_x.py

@@ -0,0 +1,15 @@
+import os
+from thefuck.shells import shell
+
+
+def match(command):
+    return (command.script.startswith('./')
+            and 'permission denied' in command.output.lower()
+            and os.path.exists(command.script_parts[0])
+            and not os.access(command.script_parts[0], os.X_OK))
+
+
+def get_new_command(command):
+    return shell.and_(
+        'chmod +x {}'.format(command.script_parts[0][2:]),
+        command.script)

thefuck/rules/choco_install.py

@@ -0,0 +1,25 @@
+from thefuck.utils import for_app, which
+
+
+@for_app("choco", "cinst")
+def match(command):
+    return ((command.script.startswith('choco install') or 'cinst' in command.script_parts)
+            and 'Installing the following packages' in command.output)
+
+
+def get_new_command(command):
+    # Find the argument that is the package name
+    for script_part in command.script_parts:
+        if (
+            script_part not in ["choco", "cinst", "install"]
+            # Need exact match (bc chocolatey is a package)
+            and not script_part.startswith('-')
+            # Leading hyphens are parameters; some packages contain them though
+            and '=' not in script_part and '/' not in script_part
+            # These are certainly parameters
+        ):
+            return command.script.replace(script_part, script_part + ".install")
+    return []
+
+
+enabled_by_default = bool(which("choco")) or bool(which("cinst"))

thefuck/rules/composer_not_command.py

@@ -0,0 +1,22 @@
+import re
+from thefuck.utils import replace_argument, for_app
+
+
+@for_app('composer')
+def match(command):
+    return (('did you mean this?' in command.output.lower()
+             or 'did you mean one of these?' in command.output.lower())) or (
+        "install" in command.script_parts and "composer require" in command.output.lower()
+    )
+
+
+def get_new_command(command):
+    if "install" in command.script_parts and "composer require" in command.output.lower():
+        broken_cmd, new_cmd = "install", "require"
+    else:
+        broken_cmd = re.findall(r"Command \"([^']*)\" is not defined", command.output)[0]
+        new_cmd = re.findall(r'Did you mean this\?[^\n]*\n\s*([^\n]*)', command.output)
+        if not new_cmd:
+            new_cmd = re.findall(r'Did you mean one of these\?[^\n]*\n\s*([^\n]*)', command.output)
+        new_cmd = new_cmd[0].strip()
+    return replace_argument(command.script, broken_cmd, new_cmd)

thefuck/rules/conda_mistype.py

@@ -0,0 +1,17 @@
+import re
+from thefuck.utils import replace_command, for_app
+
+
+@for_app("conda")
+def match(command):
+    """
+    Match a mistyped command
+    """
+    return "Did you mean 'conda" in command.output
+
+
+def get_new_command(command):
+    match = re.findall(r"'conda ([^']*)'", command.output)
+    broken_cmd = match[0]
+    correct_cmd = match[1]
+    return replace_command(command, broken_cmd, [correct_cmd])

thefuck/rules/cp_create_destination.py

@@ -0,0 +1,15 @@
+from thefuck.shells import shell
+from thefuck.utils import for_app
+
+
+@for_app("cp", "mv")
+def match(command):
+    return (
+        "No such file or directory" in command.output
+        or command.output.startswith("cp: directory")
+        and command.output.rstrip().endswith("does not exist")
+    )
+
+
+def get_new_command(command):
+    return shell.and_(u"mkdir -p {}".format(command.script_parts[-1]), command.script)

thefuck/rules/cp_omitting_directory.py

@@ -0,0 +1,15 @@
+import re
+from thefuck.specific.sudo import sudo_support
+from thefuck.utils import for_app
+
+
+@sudo_support
+@for_app('cp')
+def match(command):
+    output = command.output.lower()
+    return 'omitting directory' in output or 'is a directory' in output
+
+
+@sudo_support
+def get_new_command(command):
+    return re.sub(r'^cp', 'cp -a', command.script)

thefuck/rules/cpp11.py

@@ -0,0 +1,12 @@
+from thefuck.utils import for_app
+
+
+@for_app('g++', 'clang++')
+def match(command):
+    return ('This file requires compiler and library support for the '
+            'ISO C++ 2011 standard.' in command.output or
+            '-Wc++11-extensions' in command.output)
+
+
+def get_new_command(command):
+    return command.script + ' -std=c++11'