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

thefuck/rules/dirty_untar.py

@@ -0,0 +1,53 @@
+import tarfile
+import os
+from thefuck.utils import for_app
+from thefuck.shells import shell
+
+
+tar_extensions = ('.tar', '.tar.Z', '.tar.bz2', '.tar.gz', '.tar.lz',
+                  '.tar.lzma', '.tar.xz', '.taz', '.tb2', '.tbz', '.tbz2',
+                  '.tgz', '.tlz', '.txz', '.tz')
+
+
+def _is_tar_extract(cmd):
+    if '--extract' in cmd:
+        return True
+
+    cmd = cmd.split()
+
+    return len(cmd) > 1 and 'x' in cmd[1]
+
+
+def _tar_file(cmd):
+    for c in cmd:
+        for ext in tar_extensions:
+            if c.endswith(ext):
+                return (c, c[0:len(c) - len(ext)])
+
+
+@for_app('tar')
+def match(command):
+    return ('-C' not in command.script
+            and _is_tar_extract(command.script)
+            and _tar_file(command.script_parts) is not None)
+
+
+def get_new_command(command):
+    dir = shell.quote(_tar_file(command.script_parts)[1])
+    return shell.and_('mkdir -p {dir}', '{cmd} -C {dir}') \
+        .format(dir=dir, cmd=command.script)
+
+
+def side_effect(old_cmd, command):
+    with tarfile.TarFile(_tar_file(old_cmd.script_parts)[0]) as archive:
+        for file in archive.getnames():
+            if not os.path.abspath(file).startswith(os.getcwd()):
+                # it's unsafe to overwrite files outside of the current directory
+                continue
+
+            try:
+                os.remove(file)
+            except OSError:
+                # does not try to remove directories as we cannot know if they
+                # already existed before
+                pass

thefuck/rules/dirty_unzip.py

@@ -0,0 +1,60 @@
+import os
+import zipfile
+from thefuck.utils import for_app
+from thefuck.shells import shell
+
+
+def _is_bad_zip(file):
+    try:
+        with zipfile.ZipFile(file, 'r') as archive:
+            return len(archive.namelist()) > 1
+    except Exception:
+        return False
+
+
+def _zip_file(command):
+    # unzip works that way:
+    # unzip [-flags] file[.zip] [file(s) ...] [-x file(s) ...]
+    #                ^          ^ files to unzip from the archive
+    #                archive to unzip
+    for c in command.script_parts[1:]:
+        if not c.startswith('-'):
+            if c.endswith('.zip'):
+                return c
+            else:
+                return u'{}.zip'.format(c)
+
+
+@for_app('unzip')
+def match(command):
+    if '-d' in command.script:
+        return False
+
+    zip_file = _zip_file(command)
+    if zip_file:
+        return _is_bad_zip(zip_file)
+    else:
+        return False
+
+
+def get_new_command(command):
+    return u'{} -d {}'.format(
+        command.script, shell.quote(_zip_file(command)[:-4]))
+
+
+def side_effect(old_cmd, command):
+    with zipfile.ZipFile(_zip_file(old_cmd), 'r') as archive:
+        for file in archive.namelist():
+            if not os.path.abspath(file).startswith(os.getcwd()):
+                # it's unsafe to overwrite files outside of the current directory
+                continue
+
+            try:
+                os.remove(file)
+            except OSError:
+                # does not try to remove directories as we cannot know if they
+                # already existed before
+                pass
+
+
+requires_output = False

thefuck/rules/django_south_ghost.py

@@ -0,0 +1,8 @@
+def match(command):
+    return 'manage.py' in command.script and \
+           'migrate' in command.script \
+           and 'or pass --delete-ghost-migrations' in command.output
+
+
+def get_new_command(command):
+    return u'{} --delete-ghost-migrations'.format(command.script)

thefuck/rules/django_south_merge.py

@@ -0,0 +1,8 @@
+def match(command):
+    return 'manage.py' in command.script and \
+           'migrate' in command.script \
+           and '--merge: will just attempt the migration' in command.output
+
+
+def get_new_command(command):
+    return u'{} --merge'.format(command.script)

thefuck/rules/dnf_no_such_command.py

@@ -0,0 +1,37 @@
+import subprocess
+import re
+from thefuck.specific.sudo import sudo_support
+from thefuck.utils import for_app, replace_command
+from thefuck.specific.dnf import dnf_available
+
+
+regex = re.compile(r'No such command: (.*)\.')
+
+
+@sudo_support
+@for_app('dnf')
+def match(command):
+    return 'no such command' in command.output.lower()
+
+
+def _parse_operations(help_text_lines):
+    operation_regex = re.compile(r'^([a-z-]+) +', re.MULTILINE)
+    return operation_regex.findall(help_text_lines)
+
+
+def _get_operations():
+    proc = subprocess.Popen(["dnf", '--help'],
+                            stdout=subprocess.PIPE,
+                            stderr=subprocess.PIPE)
+    lines = proc.stdout.read().decode("utf-8")
+
+    return _parse_operations(lines)
+
+
+@sudo_support
+def get_new_command(command):
+    misspelled_command = regex.findall(command.output)[0]
+    return replace_command(command, misspelled_command, _get_operations())
+
+
+enabled_by_default = dnf_available

thefuck/rules/docker_image_being_used_by_container.py

@@ -0,0 +1,20 @@
+from thefuck.utils import for_app
+from thefuck.shells import shell
+
+
+@for_app('docker')
+def match(command):
+    '''
+    Matches a command's output with docker's output
+    warning you that you need to remove a container before removing an image.
+    '''
+    return 'image is being used by running container' in command.output
+
+
+def get_new_command(command):
+    '''
+    Prepends docker container rm -f {container ID} to
+    the previous docker image rm {image ID} command
+    '''
+    container_id = command.output.strip().split(' ')
+    return shell.and_('docker container rm -f {}', '{}').format(container_id[-1], command.script)

thefuck/rules/docker_login.py

@@ -0,0 +1,13 @@
+from thefuck.utils import for_app
+from thefuck.shells import shell
+
+
+@for_app('docker')
+def match(command):
+    return ('docker' in command.script
+            and "access denied" in command.output
+            and "may require 'docker login'" in command.output)
+
+
+def get_new_command(command):
+    return shell.and_('docker login', command.script)

thefuck/rules/docker_not_command.py

@@ -0,0 +1,49 @@
+from itertools import dropwhile, takewhile, islice
+import re
+import subprocess
+from thefuck.utils import replace_command, for_app, which, cache
+from thefuck.specific.sudo import sudo_support
+
+
+@sudo_support
+@for_app('docker')
+def match(command):
+    return 'is not a docker command' in command.output or 'Usage:	docker' in command.output
+
+
+def _parse_commands(lines, starts_with):
+    lines = dropwhile(lambda line: not line.startswith(starts_with), lines)
+    lines = islice(lines, 1, None)
+    lines = list(takewhile(lambda line: line.strip(), lines))
+    return [line.strip().split(' ')[0] for line in lines]
+
+
+def get_docker_commands():
+    proc = subprocess.Popen('docker', stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+    # Old version docker returns its output to stdout, while newer version returns to stderr.
+    lines = proc.stdout.readlines() or proc.stderr.readlines()
+    lines = [line.decode('utf-8') for line in lines]
+
+    # Only newer versions of docker have management commands in the help text.
+    if 'Management Commands:\n' in lines:
+        management_commands = _parse_commands(lines, 'Management Commands:')
+    else:
+        management_commands = []
+    regular_commands = _parse_commands(lines, 'Commands:')
+    return management_commands + regular_commands
+
+
+if which('docker'):
+    get_docker_commands = cache(which('docker'))(get_docker_commands)
+
+
+@sudo_support
+def get_new_command(command):
+    if 'Usage:' in command.output and len(command.script_parts) > 1:
+        management_subcommands = _parse_commands(command.output.split('\n'), 'Commands:')
+        return replace_command(command, command.script_parts[2], management_subcommands)
+
+    wrong_command = re.findall(
+        r"docker: '(\w+)' is not a docker command.", command.output)[0]
+    return replace_command(command, wrong_command, get_docker_commands())

thefuck/rules/dry.py

@@ -0,0 +1,15 @@
+def match(command):
+    split_command = command.script_parts
+
+    return (split_command
+            and len(split_command) >= 2
+            and split_command[0] == split_command[1])
+
+
+def get_new_command(command):
+    return ' '.join(command.script_parts[1:])
+
+
+# it should be rare enough to actually have to type twice the same word, so
+# this rule can have a higher priority to come before things like "cd cd foo"
+priority = 900

thefuck/rules/fab_command_not_found.py

@@ -0,0 +1,38 @@
+from thefuck.utils import eager, get_closest, for_app
+
+
+@for_app('fab')
+def match(command):
+    return 'Warning: Command(s) not found:' in command.output
+
+
+# We need different behavior then in get_all_matched_commands.
+@eager
+def _get_between(content, start, end=None):
+    should_yield = False
+    for line in content.split('\n'):
+        if start in line:
+            should_yield = True
+            continue
+
+        if end and end in line:
+            return
+
+        if should_yield and line:
+            yield line.strip().split(' ')[0]
+
+
+def get_new_command(command):
+    not_found_commands = _get_between(
+        command.output, 'Warning: Command(s) not found:',
+        'Available commands:')
+    possible_commands = _get_between(
+        command.output, 'Available commands:')
+
+    script = command.script
+    for not_found in not_found_commands:
+        fix = get_closest(not_found, possible_commands)
+        script = script.replace(' {}'.format(not_found),
+                                ' {}'.format(fix))
+
+    return script

thefuck/rules/fix_alt_space.py

@@ -0,0 +1,15 @@
+# -*- encoding: utf-8 -*-
+
+import re
+from thefuck.specific.sudo import sudo_support
+
+
+@sudo_support
+def match(command):
+    return ('command not found' in command.output.lower()
+            and u' ' in command.script)
+
+
+@sudo_support
+def get_new_command(command):
+    return re.sub(u' ', ' ', command.script)

thefuck/rules/fix_file.py

@@ -0,0 +1,80 @@
+import re
+import os
+from thefuck.utils import memoize, default_settings
+from thefuck.conf import settings
+from thefuck.shells import shell
+
+
+# order is important: only the first match is considered
+patterns = (
+    # js, node:
+    '^    at {file}:{line}:{col}',
+    # cargo:
+    '^   {file}:{line}:{col}',
+    # python, thefuck:
+    '^  File "{file}", line {line}',
+    # awk:
+    '^awk: {file}:{line}:',
+    # git
+    '^fatal: bad config file line {line} in {file}',
+    # llc:
+    '^llc: {file}:{line}:{col}:',
+    # lua:
+    '^lua: {file}:{line}:',
+    # fish:
+    '^{file} \\(line {line}\\):',
+    # bash, sh, ssh:
+    '^{file}: line {line}: ',
+    # cargo, clang, gcc, go, pep8, rustc:
+    '^{file}:{line}:{col}',
+    # ghc, make, ruby, zsh:
+    '^{file}:{line}:',
+    # perl:
+    'at {file} line {line}',
+)
+
+
+# for the sake of readability do not use named groups above
+def _make_pattern(pattern):
+    pattern = pattern.replace('{file}', '(?P<file>[^:\n]+)') \
+                     .replace('{line}', '(?P<line>[0-9]+)') \
+                     .replace('{col}', '(?P<col>[0-9]+)')
+    return re.compile(pattern, re.MULTILINE)
+
+
+patterns = [_make_pattern(p).search for p in patterns]
+
+
+@memoize
+def _search(output):
+    for pattern in patterns:
+        m = pattern(output)
+        if m and os.path.isfile(m.group('file')):
+            return m
+
+
+def match(command):
+    if 'EDITOR' not in os.environ:
+        return False
+
+    return _search(command.output)
+
+
+@default_settings({'fixlinecmd': u'{editor} {file} +{line}',
+                   'fixcolcmd': None})
+def get_new_command(command):
+    m = _search(command.output)
+
+    # Note: there does not seem to be a standard for columns, so they are just
+    # ignored by default
+    if settings.fixcolcmd and 'col' in m.groupdict():
+        editor_call = settings.fixcolcmd.format(editor=os.environ['EDITOR'],
+                                                file=m.group('file'),
+                                                line=m.group('line'),
+                                                col=m.group('col'))
+    else:
+        editor_call = settings.fixlinecmd.format(editor=os.environ['EDITOR'],
+                                                 file=m.group('file'),
+                                                 line=m.group('line'))
+
+    return shell.and_(editor_call, command.script)

thefuck/rules/gem_unknown_command.py

@@ -0,0 +1,36 @@
+import re
+import subprocess
+from thefuck.utils import for_app, eager, replace_command, cache, which
+
+
+@for_app('gem')
+def match(command):
+    return ('ERROR:  While executing gem ... (Gem::CommandLineError)'
+            in command.output
+            and 'Unknown command' in command.output)
+
+
+def _get_unknown_command(command):
+    return re.findall(r'Unknown command (.*)$', command.output)[0]
+
+
+@eager
+def _get_all_commands():
+    proc = subprocess.Popen(['gem', 'help', 'commands'],
+                            stdout=subprocess.PIPE)
+
+    for line in proc.stdout.readlines():
+        line = line.decode()
+
+        if line.startswith('    '):
+            yield line.strip().split(' ')[0]
+
+
+if which('gem'):
+    _get_all_commands = cache(which('gem'))(_get_all_commands)
+
+
+def get_new_command(command):
+    unknown_command = _get_unknown_command(command)
+    all_commands = _get_all_commands()
+    return replace_command(command, unknown_command, all_commands)

thefuck/rules/git_add.py

@@ -0,0 +1,27 @@
+import re
+from thefuck.shells import shell
+from thefuck.specific.git import git_support
+from thefuck.system import Path
+from thefuck.utils import memoize
+
+
+@memoize
+def _get_missing_file(command):
+    pathspec = re.findall(
+        r"error: pathspec '([^']*)' "
+        r'did not match any file\(s\) known to git.', command.output)[0]
+    if Path(pathspec).exists():
+        return pathspec
+
+
+@git_support
+def match(command):
+    return ('did not match any file(s) known to git.' in command.output
+            and _get_missing_file(command))
+
+
+@git_support
+def get_new_command(command):
+    missing_file = _get_missing_file(command)
+    formatme = shell.and_('git add -- {}', '{}')
+    return formatme.format(missing_file, command.script)

thefuck/rules/git_add_force.py

@@ -0,0 +1,13 @@
+from thefuck.utils import replace_argument
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return ('add' in command.script_parts
+            and 'Use -f if you really want to add them.' in command.output)
+
+
+@git_support
+def get_new_command(command):
+    return replace_argument(command.script, 'add', 'add --force')

thefuck/rules/git_bisect_usage.py

@@ -0,0 +1,16 @@
+import re
+from thefuck.utils import replace_command
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return ('bisect' in command.script_parts and
+            'usage: git bisect' in command.output)
+
+
+@git_support
+def get_new_command(command):
+    broken = re.findall(r'git bisect ([^ $]*).*', command.script)[0]
+    usage = re.findall(r'usage: git bisect \[([^\]]+)\]', command.output)[0]
+    return replace_command(command, broken, usage.split('|'))

thefuck/rules/git_branch_0flag.py

@@ -0,0 +1,24 @@
+from thefuck.shells import shell
+from thefuck.specific.git import git_support
+from thefuck.utils import memoize
+
+
+@memoize
+def first_0flag(script_parts):
+    return next((p for p in script_parts if len(p) == 2 and p.startswith("0")), None)
+
+
+@git_support
+def match(command):
+    return command.script_parts[1] == "branch" and first_0flag(command.script_parts)
+
+
+@git_support
+def get_new_command(command):
+    branch_name = first_0flag(command.script_parts)
+    fixed_flag = branch_name.replace("0", "-")
+    fixed_script = command.script.replace(branch_name, fixed_flag)
+    if "A branch named '" in command.output and "' already exists." in command.output:
+        delete_branch = u"git branch -D {}".format(branch_name)
+        return shell.and_(delete_branch, fixed_script)
+    return fixed_script

thefuck/rules/git_branch_delete.py

@@ -0,0 +1,13 @@
+from thefuck.utils import replace_argument
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return ('branch -d' in command.script
+            and 'If you are sure you want to delete it' in command.output)
+
+
+@git_support
+def get_new_command(command):
+    return replace_argument(command.script, '-d', '-D')

thefuck/rules/git_branch_delete_checked_out.py

@@ -0,0 +1,19 @@
+from thefuck.shells import shell
+from thefuck.specific.git import git_support
+from thefuck.utils import replace_argument
+
+
+@git_support
+def match(command):
+    return (
+        ("branch -d" in command.script or "branch -D" in command.script)
+        and "error: Cannot delete branch '" in command.output
+        and "' checked out at '" in command.output
+    )
+
+
+@git_support
+def get_new_command(command):
+    return shell.and_("git checkout master", "{}").format(
+        replace_argument(command.script, "-d", "-D")
+    )

thefuck/rules/git_branch_exists.py

@@ -0,0 +1,25 @@
+import re
+from thefuck.shells import shell
+from thefuck.specific.git import git_support
+from thefuck.utils import eager
+
+
+@git_support
+def match(command):
+    return ("fatal: A branch named '" in command.output
+            and "' already exists." in command.output)
+
+
+@git_support
+@eager
+def get_new_command(command):
+    branch_name = re.findall(
+        r"fatal: A branch named '(.+)' already exists.", command.output)[0]
+    branch_name = branch_name.replace("'", r"\'")
+    new_command_templates = [['git branch -d {0}', 'git branch {0}'],
+                             ['git branch -d {0}', 'git checkout -b {0}'],
+                             ['git branch -D {0}', 'git branch {0}'],
+                             ['git branch -D {0}', 'git checkout -b {0}'],
+                             ['git checkout {0}']]
+    for new_command_template in new_command_templates:
+        yield shell.and_(*new_command_template).format(branch_name)

thefuck/rules/git_branch_list.py

@@ -0,0 +1,14 @@
+from thefuck.shells import shell
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    # catches "git branch list" in place of "git branch"
+    return (command.script_parts
+            and command.script_parts[1:] == 'branch list'.split())
+
+
+@git_support
+def get_new_command(command):
+    return shell.and_('git branch --delete list', 'git branch')

thefuck/rules/git_checkout.py

@@ -0,0 +1,49 @@
+import re
+import subprocess
+from thefuck import utils
+from thefuck.utils import replace_argument
+from thefuck.specific.git import git_support
+from thefuck.shells import shell
+
+
+@git_support
+def match(command):
+    return ('did not match any file(s) known to git' in command.output
+            and "Did you forget to 'git add'?" not in command.output)
+
+
+def get_branches():
+    proc = subprocess.Popen(
+        ['git', 'branch', '-a', '--no-color', '--no-column'],
+        stdout=subprocess.PIPE)
+    for line in proc.stdout.readlines():
+        line = line.decode('utf-8')
+        if '->' in line:    # Remote HEAD like b'  remotes/origin/HEAD -> origin/master'
+            continue
+        if line.startswith('*'):
+            line = line.split(' ')[1]
+        if line.strip().startswith('remotes/'):
+            line = '/'.join(line.split('/')[2:])
+        yield line.strip()
+
+
+@git_support
+def get_new_command(command):
+    missing_file = re.findall(
+        r"error: pathspec '([^']*)' "
+        r"did not match any file\(s\) known to git", command.output)[0]
+    closest_branch = utils.get_closest(missing_file, get_branches(),
+                                       fallback_to_first=False)
+
+    new_commands = []
+
+    if closest_branch:
+        new_commands.append(replace_argument(command.script, missing_file, closest_branch))
+    if command.script_parts[1] == 'checkout':
+        new_commands.append(replace_argument(command.script, 'checkout', 'checkout -b'))
+
+    if not new_commands:
+        new_commands.append(shell.and_('git branch {}', '{}').format(
+            missing_file, command.script))
+
+    return new_commands

thefuck/rules/git_clone_git_clone.py

@@ -0,0 +1,12 @@
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return (' git clone ' in command.script
+            and 'fatal: Too many arguments.' in command.output)
+
+
+@git_support
+def get_new_command(command):
+    return command.script.replace(' git clone ', ' ', 1)