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

thefuck/rules/yum_invalid_operation.py

@@ -0,0 +1,39 @@
+import subprocess
+from itertools import dropwhile, islice, takewhile
+
+from thefuck.specific.sudo import sudo_support
+from thefuck.specific.yum import yum_available
+from thefuck.utils import for_app, replace_command, which, cache
+
+enabled_by_default = yum_available
+
+
+@sudo_support
+@for_app('yum')
+def match(command):
+    return 'No such command: ' in command.output
+
+
+def _get_operations():
+    proc = subprocess.Popen('yum', stdout=subprocess.PIPE)
+
+    lines = proc.stdout.readlines()
+    lines = [line.decode('utf-8') for line in lines]
+    lines = dropwhile(lambda line: not line.startswith("List of Commands:"), lines)
+    lines = islice(lines, 2, None)
+    lines = list(takewhile(lambda line: line.strip(), lines))
+    return [line.strip().split(' ')[0] for line in lines]
+
+
+if which('yum'):
+    _get_operations = cache(which('yum'))(_get_operations)
+
+
+@sudo_support
+def get_new_command(command):
+    invalid_operation = command.script_parts[1]
+
+    if invalid_operation == 'uninstall':
+        return [command.script.replace('uninstall', 'remove')]
+
+    return replace_command(command, invalid_operation, _get_operations())

thefuck/shells/__init__.py

@@ -0,0 +1,52 @@
+"""Package with shell specific actions, each shell class should
+implement `from_shell`, `to_shell`, `app_alias`, `put_to_history` and
+`get_aliases` methods.
+"""
+import os
+from psutil import Process
+from .bash import Bash
+from .fish import Fish
+from .generic import Generic
+from .tcsh import Tcsh
+from .zsh import Zsh
+from .powershell import Powershell
+
+shells = {'bash': Bash,
+          'fish': Fish,
+          'zsh': Zsh,
+          'csh': Tcsh,
+          'tcsh': Tcsh,
+          'powershell': Powershell,
+          'pwsh': Powershell}
+
+
+def _get_shell_from_env():
+    name = os.environ.get('TF_SHELL')
+
+    if name in shells:
+        return shells[name]()
+
+
+def _get_shell_from_proc():
+    proc = Process(os.getpid())
+
+    while proc is not None and proc.pid > 0:
+        try:
+            name = proc.name()
+        except TypeError:
+            name = proc.name
+
+        name = os.path.splitext(name)[0]
+
+        if name in shells:
+            return shells[name]()
+
+        try:
+            proc = proc.parent()
+        except TypeError:
+            proc = proc.parent
+
+    return Generic()
+
+
+shell = _get_shell_from_env() or _get_shell_from_proc()

thefuck/shells/bash.py

@@ -0,0 +1,94 @@
+import os
+from subprocess import Popen, PIPE
+from tempfile import gettempdir
+from uuid import uuid4
+from ..conf import settings
+from ..const import ARGUMENT_PLACEHOLDER, USER_COMMAND_MARK
+from ..utils import DEVNULL, memoize
+from .generic import Generic
+
+
+class Bash(Generic):
+    friendly_name = 'Bash'
+
+    def app_alias(self, alias_name):
+        # It is VERY important to have the variables declared WITHIN the function
+        return '''
+            function {name} () {{
+                TF_PYTHONIOENCODING=$PYTHONIOENCODING;
+                export TF_SHELL=bash;
+                export TF_ALIAS={name};
+                export TF_SHELL_ALIASES=$(alias);
+                export TF_HISTORY=$(fc -ln -10);
+                export TF_PROMPT="$*";
+                export PYTHONIOENCODING=utf-8;
+                TF_CMD=$(
+                    thefuck {argument_placeholder} "$@"
+                ) && eval "$TF_CMD";
+                unset TF_HISTORY;
+                unset TF_PROMPT;
+                export PYTHONIOENCODING=$TF_PYTHONIOENCODING;
+                {alter_history}
+            }}
+        '''.format(
+            name=alias_name,
+            argument_placeholder=ARGUMENT_PLACEHOLDER,
+            alter_history=('history -s $TF_CMD;'
+                           if settings.alter_history else ''))
+
+    def instant_mode_alias(self, alias_name):
+        if os.environ.get('THEFUCK_INSTANT_MODE', '').lower() == 'true':
+            mark = USER_COMMAND_MARK + '\b' * len(USER_COMMAND_MARK)
+            return '''
+                export PS1="{user_command_mark}$PS1";
+                {app_alias}
+            '''.format(user_command_mark=mark,
+                       app_alias=self.app_alias(alias_name))
+        else:
+            log_path = os.path.join(
+                gettempdir(), 'thefuck-script-log-{}'.format(uuid4().hex))
+            return '''
+                export THEFUCK_INSTANT_MODE=True;
+                export THEFUCK_OUTPUT_LOG={log};
+                thefuck --shell-logger {log};
+                rm {log};
+                exit
+            '''.format(log=log_path)
+
+    def _parse_alias(self, alias):
+        name, value = alias.replace('alias ', '', 1).split('=', 1)
+        if value[0] == value[-1] == '"' or value[0] == value[-1] == "'":
+            value = value[1:-1]
+        return name, value
+
+    @memoize
+    def get_aliases(self):
+        raw_aliases = os.environ.get('TF_SHELL_ALIASES', '').split('\n')
+        return dict(self._parse_alias(alias)
+                    for alias in raw_aliases if alias and '=' in alias)
+
+    def _get_history_file_name(self):
+        return os.environ.get("HISTFILE",
+                              os.path.expanduser('~/.bash_history'))
+
+    def _get_history_line(self, command_script):
+        return u'{}\n'.format(command_script)
+
+    def how_to_configure(self):
+        if os.path.join(os.path.expanduser('~'), '.bashrc'):
+            config = '~/.bashrc'
+        elif os.path.join(os.path.expanduser('~'), '.bash_profile'):
+            config = '~/.bash_profile'
+        else:
+            config = 'bash config'
+
+        return self._create_shell_configuration(
+            content=u'eval "$(thefuck --alias)"',
+            path=config,
+            reload=u'source {}'.format(config))
+
+    def _get_version(self):
+        """Returns the version of the current shell"""
+        proc = Popen(['bash', '-c', 'echo $BASH_VERSION'],
+                     stdout=PIPE, stderr=DEVNULL)
+        return proc.stdout.read().decode('utf-8').strip()

thefuck/shells/fish.py

@@ -0,0 +1,131 @@
+from subprocess import Popen, PIPE
+from time import time
+import os
+import sys
+import six
+from .. import logs
+from ..conf import settings
+from ..const import ARGUMENT_PLACEHOLDER
+from ..utils import DEVNULL, cache
+from .generic import Generic
+
+
+@cache('~/.config/fish/config.fish', '~/.config/fish/functions')
+def _get_functions(overridden):
+    proc = Popen(['fish', '-ic', 'functions'], stdout=PIPE, stderr=DEVNULL)
+    functions = proc.stdout.read().decode('utf-8').strip().split('\n')
+    return {func: func for func in functions if func not in overridden}
+
+
+@cache('~/.config/fish/config.fish')
+def _get_aliases(overridden):
+    aliases = {}
+    proc = Popen(['fish', '-ic', 'alias'], stdout=PIPE, stderr=DEVNULL)
+    alias_out = proc.stdout.read().decode('utf-8').strip()
+    if not alias_out:
+        return aliases
+    for alias in alias_out.split('\n'):
+        for separator in (' ', '='):
+            split_alias = alias.replace('alias ', '', 1).split(separator, 1)
+            if len(split_alias) == 2:
+                name, value = split_alias
+                break
+        else:
+            continue
+        if name not in overridden:
+            aliases[name] = value
+    return aliases
+
+
+class Fish(Generic):
+    friendly_name = 'Fish Shell'
+
+    def _get_overridden_aliases(self):
+        overridden = os.environ.get('THEFUCK_OVERRIDDEN_ALIASES',
+                                    os.environ.get('TF_OVERRIDDEN_ALIASES', ''))
+        default = {'cd', 'grep', 'ls', 'man', 'open'}
+        for alias in overridden.split(','):
+            default.add(alias.strip())
+        return sorted(default)
+
+    def app_alias(self, alias_name):
+        if settings.alter_history:
+            alter_history = ('    builtin history delete --exact'
+                             ' --case-sensitive -- $fucked_up_command\n'
+                             '    builtin history merge\n')
+        else:
+            alter_history = ''
+        # It is VERY important to have the variables declared WITHIN the alias
+        return ('function {0} -d "Correct your previous console command"\n'
+                '  set -l fucked_up_command $history[1]\n'
+                '  set -l tf_prompt (string join " " -- $argv)\n'
+                '  env TF_SHELL=fish TF_ALIAS={0} PYTHONIOENCODING=utf-8'
+                ' TF_COMMAND="$fucked_up_command" TF_PROMPT="$tf_prompt"'
+                ' thefuck $fucked_up_command {2} $argv | read -l unfucked_command\n'
+                '  if [ "$unfucked_command" != "" ]\n'
+                '    eval $unfucked_command\n{1}'
+                '  end\n'
+                'end').format(alias_name, alter_history, ARGUMENT_PLACEHOLDER)
+
+    def get_aliases(self):
+        overridden = self._get_overridden_aliases()
+        functions = _get_functions(overridden)
+        raw_aliases = _get_aliases(overridden)
+        functions.update(raw_aliases)
+        return functions
+
+    def _expand_aliases(self, command_script):
+        aliases = self.get_aliases()
+        binary = command_script.split(' ')[0]
+        if binary in aliases and aliases[binary] != binary:
+            return command_script.replace(binary, aliases[binary], 1)
+        elif binary in aliases:
+            return u'fish -ic "{}"'.format(command_script.replace('"', r'\"'))
+        else:
+            return command_script
+
+    def _get_history_file_name(self):
+        return os.path.expanduser('~/.config/fish/fish_history')
+
+    def _get_history_line(self, command_script):
+        return u'- cmd: {}\n   when: {}\n'.format(command_script, int(time()))
+
+    def _script_from_history(self, line):
+        if '- cmd: ' in line:
+            return line.split('- cmd: ', 1)[1]
+        else:
+            return ''
+
+    def and_(self, *commands):
+        return u'; and '.join(commands)
+
+    def or_(self, *commands):
+        return u'; or '.join(commands)
+
+    def how_to_configure(self):
+        return self._create_shell_configuration(
+            content=u"thefuck --alias | source",
+            path='~/.config/fish/config.fish',
+            reload='fish')
+
+    def _get_version(self):
+        """Returns the version of the current shell"""
+        proc = Popen(['fish', '--version'], stdout=PIPE, stderr=DEVNULL)
+        return proc.stdout.read().decode('utf-8').split()[-1]
+
+    def put_to_history(self, command):
+        try:
+            return self._put_to_history(command)
+        except IOError:
+            logs.exception("Can't update history", sys.exc_info())
+
+    def _put_to_history(self, command_script):
+        """Puts command script to shell history."""
+        history_file_name = self._get_history_file_name()
+        if os.path.isfile(history_file_name):
+            with open(history_file_name, 'a') as history:
+                entry = self._get_history_line(command_script)
+                if six.PY2:
+                    history.write(entry.encode('utf-8'))
+                else:
+                    history.write(entry)

thefuck/shells/generic.py

@@ -0,0 +1,154 @@
+import io
+import os
+import shlex
+import six
+from collections import namedtuple
+from ..logs import warn
+from ..utils import memoize
+from ..conf import settings
+from ..system import Path
+
+
+ShellConfiguration = namedtuple('ShellConfiguration', (
+    'content', 'path', 'reload', 'can_configure_automatically'))
+
+
+class Generic(object):
+    friendly_name = 'Generic Shell'
+
+    def get_aliases(self):
+        return {}
+
+    def _expand_aliases(self, command_script):
+        aliases = self.get_aliases()
+        binary = command_script.split(' ')[0]
+        if binary in aliases:
+            return command_script.replace(binary, aliases[binary], 1)
+        else:
+            return command_script
+
+    def from_shell(self, command_script):
+        """Prepares command before running in app."""
+        return self._expand_aliases(command_script)
+
+    def to_shell(self, command_script):
+        """Prepares command for running in shell."""
+        return command_script
+
+    def app_alias(self, alias_name):
+        return """alias {0}='eval "$(TF_ALIAS={0} PYTHONIOENCODING=utf-8 """ \
+               """thefuck "$(fc -ln -1)")"'""".format(alias_name)
+
+    def instant_mode_alias(self, alias_name):
+        warn("Instant mode not supported by your shell")
+        return self.app_alias(alias_name)
+
+    def _get_history_file_name(self):
+        return ''
+
+    def _get_history_line(self, command_script):
+        return ''
+
+    @memoize
+    def get_history(self):
+        return list(self._get_history_lines())
+
+    def _get_history_lines(self):
+        """Returns list of history entries."""
+        history_file_name = self._get_history_file_name()
+        if os.path.isfile(history_file_name):
+            with io.open(history_file_name, 'r',
+                         encoding='utf-8', errors='ignore') as history_file:
+
+                lines = history_file.readlines()
+                if settings.history_limit:
+                    lines = lines[-settings.history_limit:]
+
+                for line in lines:
+                    prepared = self._script_from_history(line) \
+                        .strip()
+                    if prepared:
+                        yield prepared
+
+    def and_(self, *commands):
+        return u' && '.join(commands)
+
+    def or_(self, *commands):
+        return u' || '.join(commands)
+
+    def how_to_configure(self):
+        return
+
+    def split_command(self, command):
+        """Split the command using shell-like syntax."""
+        encoded = self.encode_utf8(command)
+
+        try:
+            splitted = [s.replace("??", "\\ ") for s in shlex.split(encoded.replace('\\ ', '??'))]
+        except ValueError:
+            splitted = encoded.split(' ')
+
+        return self.decode_utf8(splitted)
+
+    def encode_utf8(self, command):
+        if six.PY2:
+            return command.encode('utf8')
+        return command
+
+    def decode_utf8(self, command_parts):
+        if six.PY2:
+            return [s.decode('utf8') for s in command_parts]
+        return command_parts
+
+    def quote(self, s):
+        """Return a shell-escaped version of the string s."""
+
+        if six.PY2:
+            from pipes import quote
+        else:
+            from shlex import quote
+
+        return quote(s)
+
+    def _script_from_history(self, line):
+        return line
+
+    def put_to_history(self, command):
+        """Adds fixed command to shell history.
+
+        In most of shells we change history on shell-level, but not
+        all shells support it (Fish).
+
+        """
+
+    def get_builtin_commands(self):
+        """Returns shells builtin commands."""
+        return ['alias', 'bg', 'bind', 'break', 'builtin', 'case', 'cd',
+                'command', 'compgen', 'complete', 'continue', 'declare',
+                'dirs', 'disown', 'echo', 'enable', 'eval', 'exec', 'exit',
+                'export', 'fc', 'fg', 'getopts', 'hash', 'help', 'history',
+                'if', 'jobs', 'kill', 'let', 'local', 'logout', 'popd',
+                'printf', 'pushd', 'pwd', 'read', 'readonly', 'return', 'set',
+                'shift', 'shopt', 'source', 'suspend', 'test', 'times', 'trap',
+                'type', 'typeset', 'ulimit', 'umask', 'unalias', 'unset',
+                'until', 'wait', 'while']
+
+    def _get_version(self):
+        """Returns the version of the current shell"""
+        return ''
+
+    def info(self):
+        """Returns the name and version of the current shell"""
+        try:
+            version = self._get_version()
+        except Exception as e:
+            warn(u'Could not determine shell version: {}'.format(e))
+            version = ''
+        return u'{} {}'.format(self.friendly_name, version).rstrip()
+
+    def _create_shell_configuration(self, content, path, reload):
+        return ShellConfiguration(
+            content=content,
+            path=path,
+            reload=reload,
+            can_configure_automatically=Path(path).expanduser().exists())

thefuck/shells/powershell.py

@@ -0,0 +1,43 @@
+from subprocess import Popen, PIPE
+from ..utils import DEVNULL
+from .generic import Generic, ShellConfiguration
+
+
+class Powershell(Generic):
+    friendly_name = 'PowerShell'
+
+    def app_alias(self, alias_name):
+        return 'function ' + alias_name + ' {\n' \
+               '    $history = (Get-History -Count 1).CommandLine;\n' \
+               '    if (-not [string]::IsNullOrWhiteSpace($history)) {\n' \
+               '        $fuck = $(thefuck $args $history);\n' \
+               '        if (-not [string]::IsNullOrWhiteSpace($fuck)) {\n' \
+               '            if ($fuck.StartsWith("echo")) { $fuck = $fuck.Substring(5); }\n' \
+               '            else { iex "$fuck"; }\n' \
+               '        }\n' \
+               '    }\n' \
+               '    [Console]::ResetColor() \n' \
+               '}\n'
+
+    def and_(self, *commands):
+        return u' -and '.join('({0})'.format(c) for c in commands)
+
+    def how_to_configure(self):
+        return ShellConfiguration(
+            content=u'iex "$(thefuck --alias)"',
+            path='$profile',
+            reload='. $profile',
+            can_configure_automatically=False)
+
+    def _get_version(self):
+        """Returns the version of the current shell"""
+        try:
+            proc = Popen(
+                ['powershell.exe', '$PSVersionTable.PSVersion'],
+                stdout=PIPE,
+                stderr=DEVNULL)
+            version = proc.stdout.read().decode('utf-8').rstrip().split('\n')
+            return '.'.join(version[-1].split())
+        except IOError:
+            proc = Popen(['pwsh', '--version'], stdout=PIPE, stderr=DEVNULL)
+            return proc.stdout.read().decode('utf-8').split()[-1]

thefuck/shells/tcsh.py

@@ -0,0 +1,44 @@
+from subprocess import Popen, PIPE
+from time import time
+import os
+from ..utils import DEVNULL, memoize
+from .generic import Generic
+
+
+class Tcsh(Generic):
+    friendly_name = 'Tcsh'
+
+    def app_alias(self, alias_name):
+        return ("alias {0} 'setenv TF_SHELL tcsh && setenv TF_ALIAS {0} && "
+                "set fucked_cmd=`history -h 2 | head -n 1` && "
+                "eval `thefuck ${{fucked_cmd}}`'").format(alias_name)
+
+    def _parse_alias(self, alias):
+        name, value = alias.split("\t", 1)
+        return name, value
+
+    @memoize
+    def get_aliases(self):
+        proc = Popen(['tcsh', '-ic', 'alias'], stdout=PIPE, stderr=DEVNULL)
+        return dict(
+            self._parse_alias(alias)
+            for alias in proc.stdout.read().decode('utf-8').split('\n')
+            if alias and '\t' in alias)
+
+    def _get_history_file_name(self):
+        return os.environ.get("HISTFILE",
+                              os.path.expanduser('~/.history'))
+
+    def _get_history_line(self, command_script):
+        return u'#+{}\n{}\n'.format(int(time()), command_script)
+
+    def how_to_configure(self):
+        return self._create_shell_configuration(
+            content=u'eval `thefuck --alias`',
+            path='~/.tcshrc',
+            reload='tcsh')
+
+    def _get_version(self):
+        """Returns the version of the current shell"""
+        proc = Popen(['tcsh', '--version'], stdout=PIPE, stderr=DEVNULL)
+        return proc.stdout.read().decode('utf-8').split()[1]

thefuck/shells/zsh.py

@@ -0,0 +1,98 @@
+from time import time
+import os
+from subprocess import Popen, PIPE
+from tempfile import gettempdir
+from uuid import uuid4
+from ..conf import settings
+from ..const import ARGUMENT_PLACEHOLDER, USER_COMMAND_MARK
+from ..utils import DEVNULL, memoize
+from .generic import Generic
+
+
+class Zsh(Generic):
+    friendly_name = 'ZSH'
+
+    def app_alias(self, alias_name):
+        # It is VERY important to have the variables declared WITHIN the function
+        return '''
+            {name} () {{
+                TF_PYTHONIOENCODING=$PYTHONIOENCODING;
+                export TF_SHELL=zsh;
+                export TF_ALIAS={name};
+                TF_SHELL_ALIASES=$(alias);
+                export TF_SHELL_ALIASES;
+                TF_HISTORY="$(fc -ln -10)";
+                export TF_HISTORY;
+                export TF_PROMPT="$*";
+                export PYTHONIOENCODING=utf-8;
+                TF_CMD=$(
+                    thefuck {argument_placeholder} $@
+                ) && eval $TF_CMD;
+                unset TF_HISTORY;
+                unset TF_PROMPT;
+                export PYTHONIOENCODING=$TF_PYTHONIOENCODING;
+                {alter_history}
+            }}
+        '''.format(
+            name=alias_name,
+            argument_placeholder=ARGUMENT_PLACEHOLDER,
+            alter_history=('test -n "$TF_CMD" && print -s $TF_CMD'
+                           if settings.alter_history else ''))
+
+    def instant_mode_alias(self, alias_name):
+        if os.environ.get('THEFUCK_INSTANT_MODE', '').lower() == 'true':
+            mark = ('%{' +
+                    USER_COMMAND_MARK + '\b' * len(USER_COMMAND_MARK)
+                    + '%}')
+            return '''
+                export PS1="{user_command_mark}$PS1";
+                {app_alias}
+            '''.format(user_command_mark=mark,
+                       app_alias=self.app_alias(alias_name))
+        else:
+            log_path = os.path.join(
+                gettempdir(), 'thefuck-script-log-{}'.format(uuid4().hex))
+            return '''
+                export THEFUCK_INSTANT_MODE=True;
+                export THEFUCK_OUTPUT_LOG={log};
+                thefuck --shell-logger {log};
+                rm -f {log};
+                exit
+            '''.format(log=log_path)
+
+    def _parse_alias(self, alias):
+        name, value = alias.split('=', 1)
+        if value[0] == value[-1] == '"' or value[0] == value[-1] == "'":
+            value = value[1:-1]
+        return name, value
+
+    @memoize
+    def get_aliases(self):
+        raw_aliases = os.environ.get('TF_SHELL_ALIASES', '').split('\n')
+        return dict(self._parse_alias(alias)
+                    for alias in raw_aliases if alias and '=' in alias)
+
+    def _get_history_file_name(self):
+        return os.environ.get("HISTFILE",
+                              os.path.expanduser('~/.zsh_history'))
+
+    def _get_history_line(self, command_script):
+        return u': {}:0;{}\n'.format(int(time()), command_script)
+
+    def _script_from_history(self, line):
+        if ';' in line:
+            return line.split(';', 1)[1]
+        else:
+            return ''
+
+    def how_to_configure(self):
+        return self._create_shell_configuration(
+            content=u'eval $(thefuck --alias)',
+            path='~/.zshrc',
+            reload='source ~/.zshrc')
+
+    def _get_version(self):
+        """Returns the version of the current shell"""
+        proc = Popen(['zsh', '-c', 'echo $ZSH_VERSION'],
+                     stdout=PIPE, stderr=DEVNULL)
+        return proc.stdout.read().decode('utf-8').strip()

thefuck/specific/apt.py

@@ -0,0 +1,3 @@
+from thefuck.utils import which
+
+apt_available = bool(which('apt-get'))