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

thefuck/rules/go_run.py

@@ -0,0 +1,16 @@
+from thefuck.utils import for_app
+# Appends .go when compiling go files
+#
+# Example:
+# > go run foo
+# error: go run: no go files listed
+
+
+@for_app('go')
+def match(command):
+    return (command.script.startswith('go run ')
+            and not command.script.endswith('.go'))
+
+
+def get_new_command(command):
+    return command.script + '.go'

thefuck/rules/go_unknown_command.py

@@ -0,0 +1,28 @@
+from itertools import dropwhile, islice, takewhile
+import subprocess
+
+from thefuck.utils import get_closest, replace_argument, for_app, which, cache
+
+
+def get_golang_commands():
+    proc = subprocess.Popen('go', stderr=subprocess.PIPE)
+    lines = [line.decode('utf-8').strip() for line in proc.stderr.readlines()]
+    lines = dropwhile(lambda line: line != 'The commands are:', lines)
+    lines = islice(lines, 2, None)
+    lines = takewhile(lambda line: line, lines)
+    return [line.split(' ')[0] for line in lines]
+
+
+if which('go'):
+    get_golang_commands = cache(which('go'))(get_golang_commands)
+
+
+@for_app('go')
+def match(command):
+    return 'unknown command' in command.output
+
+
+def get_new_command(command):
+    closest_subcommand = get_closest(command.script_parts[1], get_golang_commands())
+    return replace_argument(command.script, command.script_parts[1],
+                            closest_subcommand)

thefuck/rules/gradle_no_task.py

@@ -0,0 +1,34 @@
+import re
+from subprocess import Popen, PIPE
+from thefuck.utils import for_app, eager, replace_command
+
+regex = re.compile(r"Task '(.*)' (is ambiguous|not found)")
+
+
+@for_app('gradle', 'gradlew')
+def match(command):
+    return regex.findall(command.output)
+
+
+@eager
+def _get_all_tasks(gradle):
+    proc = Popen([gradle, 'tasks'], stdout=PIPE)
+    should_yield = False
+    for line in proc.stdout.readlines():
+        line = line.decode().strip()
+        if line.startswith('----'):
+            should_yield = True
+            continue
+
+        if not line.strip():
+            should_yield = False
+            continue
+
+        if should_yield and not line.startswith('All tasks runnable from root project'):
+            yield line.split(' ')[0]
+
+
+def get_new_command(command):
+    wrong_task = regex.findall(command.output)[0][0]
+    all_tasks = _get_all_tasks(command.script_parts[0])
+    return replace_command(command, wrong_task, all_tasks)

thefuck/rules/gradle_wrapper.py

@@ -0,0 +1,13 @@
+import os
+from thefuck.utils import for_app, which
+
+
+@for_app('gradle')
+def match(command):
+    return (not which(command.script_parts[0])
+            and 'not found' in command.output
+            and os.path.isfile('gradlew'))
+
+
+def get_new_command(command):
+    return u'./gradlew {}'.format(' '.join(command.script_parts[1:]))

thefuck/rules/grep_arguments_order.py

@@ -0,0 +1,23 @@
+import os
+from thefuck.utils import for_app
+
+
+def _get_actual_file(parts):
+    for part in parts[1:]:
+        if os.path.isfile(part) or os.path.isdir(part):
+            return part
+
+
+@for_app('grep', 'egrep')
+def match(command):
+    return ': No such file or directory' in command.output \
+        and _get_actual_file(command.script_parts)
+
+
+def get_new_command(command):
+    actual_file = _get_actual_file(command.script_parts)
+    parts = command.script_parts[::]
+    # Moves file to the end of the script:
+    parts.remove(actual_file)
+    parts.append(actual_file)
+    return ' '.join(parts)

thefuck/rules/grep_recursive.py

@@ -0,0 +1,10 @@
+from thefuck.utils import for_app
+
+
+@for_app('grep')
+def match(command):
+    return 'is a directory' in command.output.lower()
+
+
+def get_new_command(command):
+    return u'grep -r {}'.format(command.script[5:])

thefuck/rules/grunt_task_not_found.py

@@ -0,0 +1,37 @@
+import re
+from subprocess import Popen, PIPE
+from thefuck.utils import for_app, eager, get_closest, cache
+
+regex = re.compile(r'Warning: Task "(.*)" not found.')
+
+
+@for_app('grunt')
+def match(command):
+    return regex.findall(command.output)
+
+
+@cache('Gruntfile.js')
+@eager
+def _get_all_tasks():
+    proc = Popen(['grunt', '--help'], stdout=PIPE)
+    should_yield = False
+    for line in proc.stdout.readlines():
+        line = line.decode().strip()
+
+        if 'Available tasks' in line:
+            should_yield = True
+            continue
+
+        if should_yield and not line:
+            return
+
+        if '  ' in line:
+            yield line.split(' ')[0]
+
+
+def get_new_command(command):
+    misspelled_task = regex.findall(command.output)[0].split(':')[0]
+    tasks = _get_all_tasks()
+    fixed = get_closest(misspelled_task, tasks)
+    return command.script.replace(' {}'.format(misspelled_task),
+                                  ' {}'.format(fixed))

thefuck/rules/gulp_not_task.py

@@ -0,0 +1,22 @@
+import re
+import subprocess
+from thefuck.utils import replace_command, for_app, cache
+
+
+@for_app('gulp')
+def match(command):
+    return 'is not in your gulpfile' in command.output
+
+
+@cache('gulpfile.js')
+def get_gulp_tasks():
+    proc = subprocess.Popen(['gulp', '--tasks-simple'],
+                            stdout=subprocess.PIPE)
+    return [line.decode('utf-8')[:-1]
+            for line in proc.stdout.readlines()]
+
+
+def get_new_command(command):
+    wrong_task = re.findall(r"Task '(\w+)' is not in your gulpfile",
+                            command.output)[0]
+    return replace_command(command, wrong_task, get_gulp_tasks())

thefuck/rules/has_exists_script.py

@@ -0,0 +1,13 @@
+import os
+from thefuck.specific.sudo import sudo_support
+
+
+@sudo_support
+def match(command):
+    return command.script_parts and os.path.exists(command.script_parts[0]) \
+        and 'command not found' in command.output
+
+
+@sudo_support
+def get_new_command(command):
+    return u'./{}'.format(command.script)

thefuck/rules/heroku_multiple_apps.py

@@ -0,0 +1,12 @@
+import re
+from thefuck.utils import for_app
+
+
+@for_app('heroku')
+def match(command):
+    return 'https://devcenter.heroku.com/articles/multiple-environments' in command.output
+
+
+def get_new_command(command):
+    apps = re.findall('([^ ]*) \\([^)]*\\)', command.output)
+    return [command.script + ' --app ' + app for app in apps]

thefuck/rules/heroku_not_command.py

@@ -0,0 +1,11 @@
+import re
+from thefuck.utils import for_app
+
+
+@for_app('heroku')
+def match(command):
+    return 'Run heroku _ to run' in command.output
+
+
+def get_new_command(command):
+    return re.findall('Run heroku _ to run ([^.]*)', command.output)[0]

thefuck/rules/history.py

@@ -0,0 +1,15 @@
+from thefuck.utils import get_close_matches, get_closest, \
+    get_valid_history_without_current
+
+
+def match(command):
+    return len(get_close_matches(command.script,
+                                 get_valid_history_without_current(command)))
+
+
+def get_new_command(command):
+    return get_closest(command.script,
+                       get_valid_history_without_current(command))
+
+
+priority = 9999

thefuck/rules/hostscli.py

@@ -0,0 +1,27 @@
+import re
+from thefuck.specific.sudo import sudo_support
+from thefuck.utils import replace_command, for_app
+
+no_command = "Error: No such command"
+no_website = "hostscli.errors.WebsiteImportError"
+
+
+@sudo_support
+@for_app('hostscli')
+def match(command):
+    errors = [no_command, no_website]
+    for error in errors:
+        if error in command.output:
+            return True
+    return False
+
+
+@sudo_support
+def get_new_command(command):
+    if no_website in command.output:
+        return ['hostscli websites']
+
+    misspelled_command = re.findall(
+        r'Error: No such command ".*"', command.output)[0]
+    commands = ['block', 'unblock', 'websites', 'block_all', 'unblock_all']
+    return replace_command(command, misspelled_command, commands)

thefuck/rules/ifconfig_device_not_found.py

@@ -0,0 +1,23 @@
+import subprocess
+from thefuck.utils import for_app, replace_command, eager
+
+
+@for_app('ifconfig')
+def match(command):
+    return 'error fetching interface information: Device not found' \
+           in command.output
+
+
+@eager
+def _get_possible_interfaces():
+    proc = subprocess.Popen(['ifconfig', '-a'], stdout=subprocess.PIPE)
+    for line in proc.stdout.readlines():
+        line = line.decode()
+        if line and line != '\n' and not line.startswith(' '):
+            yield line.split(' ')[0]
+
+
+def get_new_command(command):
+    interface = command.output.split(' ')[0][:-1]
+    possible_interfaces = _get_possible_interfaces()
+    return replace_command(command, interface, possible_interfaces)

thefuck/rules/java.py

@@ -0,0 +1,17 @@
+"""Fixes common java command mistake
+
+Example:
+> java foo.java
+Error: Could not find or load main class foo.java
+
+"""
+from thefuck.utils import for_app
+
+
+@for_app('java')
+def match(command):
+    return command.script.endswith('.java')
+
+
+def get_new_command(command):
+    return command.script[:-5]

thefuck/rules/javac.py

@@ -0,0 +1,18 @@
+"""Appends .java when compiling java files
+
+Example:
+ > javac foo
+ error: Class names, 'foo', are only accepted if annotation
+ processing is explicitly requested
+
+"""
+from thefuck.utils import for_app
+
+
+@for_app('javac')
+def match(command):
+    return not command.script.endswith('.java')
+
+
+def get_new_command(command):
+    return command.script + '.java'

thefuck/rules/lein_not_task.py

@@ -0,0 +1,19 @@
+import re
+from thefuck.utils import replace_command, get_all_matched_commands, for_app
+from thefuck.specific.sudo import sudo_support
+
+
+@sudo_support
+@for_app('lein')
+def match(command):
+    return (command.script.startswith('lein')
+            and "is not a task. See 'lein help'" in command.output
+            and 'Did you mean this?' in command.output)
+
+
+@sudo_support
+def get_new_command(command):
+    broken_cmd = re.findall(r"'([^']*)' is not a task",
+                            command.output)[0]
+    new_cmds = get_all_matched_commands(command.output, 'Did you mean this?')
+    return replace_command(command, broken_cmd, new_cmds)

thefuck/rules/ln_no_hard_link.py

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+"""Suggest creating symbolic link if hard link is not allowed.
+
+Example:
+> ln barDir barLink
+ln: ‘barDir’: hard link not allowed for directory
+
+--> ln -s barDir barLink
+"""
+
+import re
+from thefuck.specific.sudo import sudo_support
+
+
+@sudo_support
+def match(command):
+    return (command.output.endswith("hard link not allowed for directory") and
+            command.script_parts[0] == 'ln')
+
+
+@sudo_support
+def get_new_command(command):
+    return re.sub(r'^ln ', 'ln -s ', command.script)

thefuck/rules/ln_s_order.py

@@ -0,0 +1,26 @@
+import os
+from thefuck.specific.sudo import sudo_support
+
+
+def _get_destination(script_parts):
+    """When arguments order is wrong first argument will be destination."""
+    for part in script_parts:
+        if part not in {'ln', '-s', '--symbolic'} and os.path.exists(part):
+            return part
+
+
+@sudo_support
+def match(command):
+    return (command.script_parts[0] == 'ln'
+            and {'-s', '--symbolic'}.intersection(command.script_parts)
+            and 'File exists' in command.output
+            and _get_destination(command.script_parts))
+
+
+@sudo_support
+def get_new_command(command):
+    destination = _get_destination(command.script_parts)
+    parts = command.script_parts[:]
+    parts.remove(destination)
+    parts.append(destination)
+    return ' '.join(parts)

thefuck/rules/long_form_help.py

@@ -0,0 +1,27 @@
+from thefuck.utils import replace_argument
+import re
+
+# regex to match a suggested help command from the tool output
+help_regex = r"(?:Run|Try) '([^']+)'(?: or '[^']+')? for (?:details|more information)."
+
+
+def match(command):
+    if re.search(help_regex, command.output, re.I) is not None:
+        return True
+
+    if '--help' in command.output:
+        return True
+
+    return False
+
+
+def get_new_command(command):
+    if re.search(help_regex, command.output) is not None:
+        match_obj = re.search(help_regex, command.output, re.I)
+        return match_obj.group(1)
+
+    return replace_argument(command.script, '-h', '--help')
+
+
+enabled_by_default = True
+priority = 5000

thefuck/rules/ls_all.py

@@ -0,0 +1,10 @@
+from thefuck.utils import for_app
+
+
+@for_app('ls')
+def match(command):
+    return command.output.strip() == ''
+
+
+def get_new_command(command):
+    return ' '.join(['ls', '-A'] + command.script_parts[1:])

thefuck/rules/ls_lah.py

@@ -0,0 +1,12 @@
+from thefuck.utils import for_app
+
+
+@for_app('ls')
+def match(command):
+    return command.script_parts and 'ls -' not in command.script
+
+
+def get_new_command(command):
+    command = command.script_parts[:]
+    command[0] = 'ls -lah'
+    return ' '.join(command)

thefuck/rules/man.py

@@ -0,0 +1,33 @@
+from thefuck.utils import for_app
+
+
+@for_app('man', at_least=1)
+def match(command):
+    return True
+
+
+def get_new_command(command):
+    if '3' in command.script:
+        return command.script.replace("3", "2")
+    if '2' in command.script:
+        return command.script.replace("2", "3")
+
+    last_arg = command.script_parts[-1]
+    help_command = last_arg + ' --help'
+
+    # If there are no man pages for last_arg, suggest `last_arg --help` instead.
+    # Otherwise, suggest `--help` after suggesting other man page sections.
+    if command.output.strip() == 'No manual entry for ' + last_arg:
+        return [help_command]
+
+    split_cmd2 = command.script_parts
+    split_cmd3 = split_cmd2[:]
+
+    split_cmd2.insert(1, ' 2 ')
+    split_cmd3.insert(1, ' 3 ')
+
+    return [
+        "".join(split_cmd3),
+        "".join(split_cmd2),
+        help_command,
+    ]

thefuck/rules/man_no_space.py

@@ -0,0 +1,10 @@
+def match(command):
+    return (command.script.startswith(u'man')
+            and u'command not found' in command.output.lower())
+
+
+def get_new_command(command):
+    return u'man {}'.format(command.script[3:])
+
+
+priority = 2000

thefuck/rules/mercurial.py

@@ -0,0 +1,27 @@
+import re
+from thefuck.utils import get_closest, for_app
+
+
+def extract_possibilities(command):
+    possib = re.findall(r'\n\(did you mean one of ([^\?]+)\?\)', command.output)
+    if possib:
+        return possib[0].split(', ')
+    possib = re.findall(r'\n    ([^$]+)$', command.output)
+    if possib:
+        return possib[0].split(' ')
+    return possib
+
+
+@for_app('hg')
+def match(command):
+    return ('hg: unknown command' in command.output
+            and '(did you mean one of ' in command.output
+            or "hg: command '" in command.output
+            and "' is ambiguous:" in command.output)
+
+
+def get_new_command(command):
+    script = command.script_parts[:]
+    possibilities = extract_possibilities(command)
+    script[1] = get_closest(script[1], possibilities)
+    return ' '.join(script)

thefuck/rules/missing_space_before_subcommand.py

@@ -0,0 +1,21 @@
+from thefuck.utils import get_all_executables, memoize
+
+
+@memoize
+def _get_executable(script_part):
+    for executable in get_all_executables():
+        if len(executable) > 1 and script_part.startswith(executable):
+            return executable
+
+
+def match(command):
+    return (not command.script_parts[0] in get_all_executables()
+            and _get_executable(command.script_parts[0]))
+
+
+def get_new_command(command):
+    executable = _get_executable(command.script_parts[0])
+    return command.script.replace(executable, u'{} '.format(executable), 1)
+
+
+priority = 4000

thefuck/rules/mkdir_p.py

@@ -0,0 +1,13 @@
+import re
+from thefuck.specific.sudo import sudo_support
+
+
+@sudo_support
+def match(command):
+    return ('mkdir' in command.script
+            and 'No such file or directory' in command.output)
+
+
+@sudo_support
+def get_new_command(command):
+    return re.sub('\\bmkdir (.*)', 'mkdir -p \\1', command.script)

thefuck/rules/mvn_no_command.py

@@ -0,0 +1,11 @@
+from thefuck.utils import for_app
+
+
+@for_app('mvn')
+def match(command):
+    return 'No goals have been specified for this build' in command.output
+
+
+def get_new_command(command):
+    return [command.script + ' clean package',
+            command.script + ' clean install']

thefuck/rules/mvn_unknown_lifecycle_phase.py

@@ -0,0 +1,30 @@
+from thefuck.utils import for_app, get_close_matches, replace_command
+import re
+
+
+def _get_failed_lifecycle(command):
+    return re.search(r'\[ERROR\] Unknown lifecycle phase "(.+)"',
+                     command.output)
+
+
+def _getavailable_lifecycles(command):
+    return re.search(
+        r'Available lifecycle phases are: (.+) -> \[Help 1\]', command.output)
+
+
+@for_app('mvn')
+def match(command):
+    failed_lifecycle = _get_failed_lifecycle(command)
+    available_lifecycles = _getavailable_lifecycles(command)
+    return available_lifecycles and failed_lifecycle
+
+
+def get_new_command(command):
+    failed_lifecycle = _get_failed_lifecycle(command)
+    available_lifecycles = _getavailable_lifecycles(command)
+    if available_lifecycles and failed_lifecycle:
+        selected_lifecycle = get_close_matches(
+            failed_lifecycle.group(1), available_lifecycles.group(1).split(", "))
+        return replace_command(command, failed_lifecycle.group(1), selected_lifecycle)
+    else:
+        return []

thefuck/rules/nixos_cmd_not_found.py

@@ -0,0 +1,15 @@
+import re
+from thefuck.specific.nix import nix_available
+from thefuck.shells import shell
+
+regex = re.compile(r'nix-env -iA ([^\s]*)')
+enabled_by_default = nix_available
+
+
+def match(command):
+    return regex.findall(command.output)
+
+
+def get_new_command(command):
+    name = regex.findall(command.output)[0]
+    return shell.and_('nix-env -iA {}'.format(name), command.script)