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

thefuck/specific/archlinux.py

@@ -0,0 +1,48 @@
+""" This file provide some utility functions for Arch Linux specific rules."""
+import subprocess
+from .. import utils
+
+
+@utils.memoize
+def get_pkgfile(command):
+    """ Gets the packages that provide the given command using `pkgfile`.
+
+    If the command is of the form `sudo foo`, searches for the `foo` command
+    instead.
+    """
+    try:
+        command = command.strip()
+
+        if command.startswith('sudo '):
+            command = command[5:]
+
+        command = command.split(" ")[0]
+
+        packages = subprocess.check_output(
+            ['pkgfile', '-b', '-v', command],
+            universal_newlines=True, stderr=utils.DEVNULL
+        ).splitlines()
+
+        return [package.split()[0] for package in packages]
+    except subprocess.CalledProcessError as err:
+        if err.returncode == 1 and err.output == "":
+            return []
+        else:
+            raise err
+
+
+def archlinux_env():
+    if utils.which('yay'):
+        pacman = 'yay'
+    elif utils.which('pikaur'):
+        pacman = 'pikaur'
+    elif utils.which('yaourt'):
+        pacman = 'yaourt'
+    elif utils.which('pacman'):
+        pacman = 'sudo pacman'
+    else:
+        return False, None
+
+    enabled_by_default = utils.which('pkgfile')
+
+    return enabled_by_default, pacman

thefuck/specific/brew.py

@@ -0,0 +1,15 @@
+import subprocess
+from ..utils import memoize, which
+
+
+brew_available = bool(which('brew'))
+
+
+@memoize
+def get_brew_path_prefix():
+    """To get brew path"""
+    try:
+        return subprocess.check_output(['brew', '--prefix'],
+                                       universal_newlines=True).strip()
+    except Exception:
+        return None

thefuck/specific/dnf.py

@@ -0,0 +1,3 @@
+from thefuck.utils import which
+
+dnf_available = bool(which('dnf'))

thefuck/specific/git.py

@@ -0,0 +1,32 @@
+import re
+from decorator import decorator
+from ..utils import is_app
+from ..shells import shell
+
+
+@decorator
+def git_support(fn, command):
+    """Resolves git aliases and supports testing for both git and hub."""
+    # supports GitHub's `hub` command
+    # which is recommended to be used with `alias git=hub`
+    # but at this point, shell aliases have already been resolved
+    if not is_app(command, 'git', 'hub'):
+        return False
+
+    # perform git aliases expansion
+    if command.output and 'trace: alias expansion:' in command.output:
+        search = re.search("trace: alias expansion: ([^ ]*) => ([^\n]*)",
+                           command.output)
+        alias = search.group(1)
+
+        # by default git quotes everything, for example:
+        #     'commit' '--amend'
+        # which is surprising and does not allow to easily test for
+        # eg. 'git commit'
+        expansion = ' '.join(shell.quote(part)
+                             for part in shell.split_command(search.group(2)))
+        new_script = re.sub(r"\b{}\b".format(alias), expansion, command.script)
+
+        command = command.update(script=new_script)
+
+    return fn(command)

thefuck/specific/nix.py

@@ -0,0 +1,3 @@
+from thefuck.utils import which
+
+nix_available = bool(which('nix'))

thefuck/specific/npm.py

@@ -0,0 +1,21 @@
+import re
+from subprocess import Popen, PIPE
+from thefuck.utils import memoize, eager, which
+
+npm_available = bool(which('npm'))
+
+
+@memoize
+@eager
+def get_scripts():
+    """Get custom npm scripts."""
+    proc = Popen(['npm', 'run-script'], stdout=PIPE)
+    should_yeild = False
+    for line in proc.stdout.readlines():
+        line = line.decode()
+        if 'available via `npm run-script`:' in line:
+            should_yeild = True
+            continue
+
+        if should_yeild and re.match(r'^  [^ ]+', line):
+            yield line.strip().split(' ')[0]

thefuck/specific/sudo.py

@@ -0,0 +1,18 @@
+import six
+from decorator import decorator
+
+
+@decorator
+def sudo_support(fn, command):
+    """Removes sudo before calling fn and adds it after."""
+    if not command.script.startswith('sudo '):
+        return fn(command)
+
+    result = fn(command.update(script=command.script[5:]))
+
+    if result and isinstance(result, six.string_types):
+        return u'sudo {}'.format(result)
+    elif isinstance(result, list):
+        return [u'sudo {}'.format(x) for x in result]
+    else:
+        return result

thefuck/specific/yum.py

@@ -0,0 +1,3 @@
+from thefuck.utils import which
+
+yum_available = bool(which('yum'))

thefuck/system/__init__.py

@@ -0,0 +1,7 @@
+import sys
+
+
+if sys.platform == 'win32':
+    from .win32 import *  # noqa: F401,F403
+else:
+    from .unix import *  # noqa: F401,F403

thefuck/system/unix.py

@@ -0,0 +1,57 @@
+import os
+import sys
+import tty
+import termios
+import colorama
+from distutils.spawn import find_executable
+from .. import const
+
+init_output = colorama.init
+
+
+def getch():
+    fd = sys.stdin.fileno()
+    old = termios.tcgetattr(fd)
+    try:
+        tty.setraw(fd)
+        return sys.stdin.read(1)
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old)
+
+
+def get_key():
+    ch = getch()
+
+    if ch in const.KEY_MAPPING:
+        return const.KEY_MAPPING[ch]
+    elif ch == '\x1b':
+        next_ch = getch()
+        if next_ch == '[':
+            last_ch = getch()
+
+            if last_ch == 'A':
+                return const.KEY_UP
+            elif last_ch == 'B':
+                return const.KEY_DOWN
+
+    return ch
+
+
+def open_command(arg):
+    if find_executable('xdg-open'):
+        return 'xdg-open ' + arg
+    return 'open ' + arg
+
+
+try:
+    from pathlib import Path
+except ImportError:
+    from pathlib2 import Path
+
+
+def _expanduser(self):
+    return self.__class__(os.path.expanduser(str(self)))
+
+
+if not hasattr(Path, 'expanduser'):
+    Path.expanduser = _expanduser

thefuck/system/win32.py

@@ -0,0 +1,43 @@
+import os
+import msvcrt
+import win_unicode_console
+from .. import const
+
+
+def init_output():
+    import colorama
+    win_unicode_console.enable()
+    colorama.init()
+
+
+def get_key():
+    ch = msvcrt.getwch()
+    if ch in ('\x00', '\xe0'):  # arrow or function key prefix?
+        ch = msvcrt.getwch()  # second call returns the actual key code
+
+    if ch in const.KEY_MAPPING:
+        return const.KEY_MAPPING[ch]
+    if ch == 'H':
+        return const.KEY_UP
+    if ch == 'P':
+        return const.KEY_DOWN
+
+    return ch
+
+
+def open_command(arg):
+    return 'cmd /c start ' + arg
+
+
+try:
+    from pathlib import Path
+except ImportError:
+    from pathlib2 import Path
+
+
+def _expanduser(self):
+    return self.__class__(os.path.expanduser(str(self)))
+
+
+# pathlib's expanduser fails on windows, see http://bugs.python.org/issue19776
+Path.expanduser = _expanduser

thefuck/types.py

@@ -0,0 +1,261 @@
+import os
+import sys
+from . import logs
+from .shells import shell
+from .conf import settings, load_source
+from .const import DEFAULT_PRIORITY, ALL_ENABLED
+from .exceptions import EmptyCommand
+from .utils import get_alias, format_raw_script
+from .output_readers import get_output
+
+
+class Command(object):
+    """Command that should be fixed."""
+
+    def __init__(self, script, output):
+        """Initializes command with given values.
+
+        :type script: basestring
+        :type output: basestring
+
+        """
+        self.script = script
+        self.output = output
+
+    @property
+    def stdout(self):
+        logs.warn('`stdout` is deprecated, please use `output` instead')
+        return self.output
+
+    @property
+    def stderr(self):
+        logs.warn('`stderr` is deprecated, please use `output` instead')
+        return self.output
+
+    @property
+    def script_parts(self):
+        if not hasattr(self, '_script_parts'):
+            try:
+                self._script_parts = shell.split_command(self.script)
+            except Exception:
+                logs.debug(u"Can't split command script {} because:\n {}".format(
+                    self, sys.exc_info()))
+                self._script_parts = []
+
+        return self._script_parts
+
+    def __eq__(self, other):
+        if isinstance(other, Command):
+            return (self.script, self.output) == (other.script, other.output)
+        else:
+            return False
+
+    def __repr__(self):
+        return u'Command(script={}, output={})'.format(
+            self.script, self.output)
+
+    def update(self, **kwargs):
+        """Returns new command with replaced fields.
+
+        :rtype: Command
+
+        """
+        kwargs.setdefault('script', self.script)
+        kwargs.setdefault('output', self.output)
+        return Command(**kwargs)
+
+    @classmethod
+    def from_raw_script(cls, raw_script):
+        """Creates instance of `Command` from a list of script parts.
+
+        :type raw_script: [basestring]
+        :rtype: Command
+        :raises: EmptyCommand
+
+        """
+        script = format_raw_script(raw_script)
+        if not script:
+            raise EmptyCommand
+
+        expanded = shell.from_shell(script)
+        output = get_output(script, expanded)
+        return cls(expanded, output)
+
+
+class Rule(object):
+    """Rule for fixing commands."""
+
+    def __init__(self, name, match, get_new_command,
+                 enabled_by_default, side_effect,
+                 priority, requires_output):
+        """Initializes rule with given fields.
+
+        :type name: basestring
+        :type match: (Command) -> bool
+        :type get_new_command: (Command) -> (basestring | [basestring])
+        :type enabled_by_default: boolean
+        :type side_effect: (Command, basestring) -> None
+        :type priority: int
+        :type requires_output: bool
+
+        """
+        self.name = name
+        self.match = match
+        self.get_new_command = get_new_command
+        self.enabled_by_default = enabled_by_default
+        self.side_effect = side_effect
+        self.priority = priority
+        self.requires_output = requires_output
+
+    def __eq__(self, other):
+        if isinstance(other, Rule):
+            return ((self.name, self.match, self.get_new_command,
+                     self.enabled_by_default, self.side_effect,
+                     self.priority, self.requires_output)
+                    == (other.name, other.match, other.get_new_command,
+                        other.enabled_by_default, other.side_effect,
+                        other.priority, other.requires_output))
+        else:
+            return False
+
+    def __repr__(self):
+        return 'Rule(name={}, match={}, get_new_command={}, ' \
+               'enabled_by_default={}, side_effect={}, ' \
+               'priority={}, requires_output={})'.format(
+                   self.name, self.match, self.get_new_command,
+                   self.enabled_by_default, self.side_effect,
+                   self.priority, self.requires_output)
+
+    @classmethod
+    def from_path(cls, path):
+        """Creates rule instance from path.
+
+        :type path: pathlib.Path
+        :rtype: Rule
+
+        """
+        name = path.name[:-3]
+        if name in settings.exclude_rules:
+            logs.debug(u'Ignoring excluded rule: {}'.format(name))
+            return
+        with logs.debug_time(u'Importing rule: {};'.format(name)):
+            try:
+                rule_module = load_source(name, str(path))
+            except Exception:
+                logs.exception(u"Rule {} failed to load".format(name), sys.exc_info())
+                return
+        priority = getattr(rule_module, 'priority', DEFAULT_PRIORITY)
+        return cls(name, rule_module.match,
+                   rule_module.get_new_command,
+                   getattr(rule_module, 'enabled_by_default', True),
+                   getattr(rule_module, 'side_effect', None),
+                   settings.priority.get(name, priority),
+                   getattr(rule_module, 'requires_output', True))
+
+    @property
+    def is_enabled(self):
+        """Returns `True` when rule enabled.
+
+        :rtype: bool
+
+        """
+        return (
+            self.name in settings.rules
+            or self.enabled_by_default
+            and ALL_ENABLED in settings.rules
+        )
+
+    def is_match(self, command):
+        """Returns `True` if rule matches the command.
+
+        :type command: Command
+        :rtype: bool
+
+        """
+        if command.output is None and self.requires_output:
+            return False
+
+        try:
+            with logs.debug_time(u'Trying rule: {};'.format(self.name)):
+                if self.match(command):
+                    return True
+        except Exception:
+            logs.rule_failed(self, sys.exc_info())
+
+    def get_corrected_commands(self, command):
+        """Returns generator with corrected commands.
+
+        :type command: Command
+        :rtype: Iterable[CorrectedCommand]
+
+        """
+        new_commands = self.get_new_command(command)
+        if not isinstance(new_commands, list):
+            new_commands = (new_commands,)
+        for n, new_command in enumerate(new_commands):
+            yield CorrectedCommand(script=new_command,
+                                   side_effect=self.side_effect,
+                                   priority=(n + 1) * self.priority)
+
+
+class CorrectedCommand(object):
+    """Corrected by rule command."""
+
+    def __init__(self, script, side_effect, priority):
+        """Initializes instance with given fields.
+
+        :type script: basestring
+        :type side_effect: (Command, basestring) -> None
+        :type priority: int
+
+        """
+        self.script = script
+        self.side_effect = side_effect
+        self.priority = priority
+
+    def __eq__(self, other):
+        """Ignores `priority` field."""
+        if isinstance(other, CorrectedCommand):
+            return (other.script, other.side_effect) == \
+                   (self.script, self.side_effect)
+        else:
+            return False
+
+    def __hash__(self):
+        return (self.script, self.side_effect).__hash__()
+
+    def __repr__(self):
+        return u'CorrectedCommand(script={}, side_effect={}, priority={})'.format(
+            self.script, self.side_effect, self.priority)
+
+    def _get_script(self):
+        """Returns fixed commands script.
+
+        If `settings.repeat` is `True`, appends command with second attempt
+        of running fuck in case fixed command fails again.
+
+        """
+        if settings.repeat:
+            repeat_fuck = '{} --repeat {}--force-command {}'.format(
+                get_alias(),
+                '--debug ' if settings.debug else '',
+                shell.quote(self.script))
+            return shell.or_(self.script, repeat_fuck)
+        else:
+            return self.script
+
+    def run(self, old_cmd):
+        """Runs command from rule for passed command.
+
+        :type old_cmd: Command
+
+        """
+        if self.side_effect:
+            self.side_effect(old_cmd, self.script)
+        if settings.alter_history:
+            shell.put_to_history(self.script)
+        # This depends on correct setting of PYTHONIOENCODING by the alias:
+        logs.debug(u'PYTHONIOENCODING: {}'.format(
+            os.environ.get('PYTHONIOENCODING', '!!not-set!!')))
+
+        sys.stdout.write(self._get_script())

thefuck/ui.py

@@ -0,0 +1,116 @@
+# -*- encoding: utf-8 -*-
+
+import sys
+from .conf import settings
+from .exceptions import NoRuleMatched
+from .system import get_key
+from .utils import get_alias
+from . import logs, const
+
+
+def read_actions():
+    """Yields actions for pressed keys."""
+    while True:
+        key = get_key()
+
+        # Handle arrows, j/k (qwerty), and n/e (colemak)
+        if key in (const.KEY_UP, const.KEY_CTRL_N, 'k', 'e'):
+            yield const.ACTION_PREVIOUS
+        elif key in (const.KEY_DOWN, const.KEY_CTRL_P, 'j', 'n',
+                     const.KEY_TAB):
+            yield const.ACTION_NEXT
+        elif key in (const.KEY_CTRL_C, 'q'):
+            yield const.ACTION_ABORT
+        elif key in ('\n', '\r'):
+            yield const.ACTION_SELECT
+
+
+class CommandSelector(object):
+    """Helper for selecting rule from rules list."""
+
+    def __init__(self, commands):
+        """:type commands: Iterable[thefuck.types.CorrectedCommand]"""
+        self._commands_gen = commands
+        try:
+            self._commands = [next(self._commands_gen)]
+        except StopIteration:
+            raise NoRuleMatched
+        self._realised = False
+        self._index = 0
+
+    def _realise(self):
+        if not self._realised:
+            self._commands += list(self._commands_gen)
+            self._realised = True
+
+    def next(self):
+        self._realise()
+        self._index = (self._index + 1) % len(self._commands)
+
+    def previous(self):
+        self._realise()
+        self._index = (self._index - 1) % len(self._commands)
+
+    @property
+    def value(self):
+        """:rtype thefuck.types.CorrectedCommand"""
+        return self._commands[self._index]
+
+    @property
+    def all_ai(self):
+        self._realise()
+        return all(getattr(cmd, '_tf_source', None) == 'ai'
+                   for cmd in self._commands)
+
+
+def select_command(corrected_commands):
+    """Returns:
+
+     - the first command when confirmation disabled;
+     - None when ctrl+c pressed;
+     - selected command.
+
+    :type corrected_commands: Iterable[thefuck.types.CorrectedCommand]
+    :rtype: thefuck.types.CorrectedCommand | None
+
+    """
+    try:
+        selector = CommandSelector(corrected_commands)
+    except NoRuleMatched:
+        logs.failed('No fucks given' if get_alias() == 'fuck'
+                    else 'Nothing found')
+        return
+
+    if not settings.require_confirmation:
+        logs.show_corrected_command(selector.value)
+        return selector.value
+
+    logs.reset_confirm_text()
+    ai_mode = selector.all_ai
+    if ai_mode:
+        logs.ai_choose_header()
+        logs.confirm_choice(selector.value)
+    else:
+        logs.confirm_text(selector.value)
+
+    for action in read_actions():
+        if action == const.ACTION_SELECT:
+            sys.stderr.write('\n')
+            logs.reset_confirm_text()
+            return selector.value
+        elif action == const.ACTION_ABORT:
+            logs.failed('\nAborted')
+            logs.reset_confirm_text()
+            return
+        elif action == const.ACTION_PREVIOUS:
+            selector.previous()
+            if ai_mode:
+                logs.confirm_choice(selector.value)
+            else:
+                logs.confirm_text(selector.value)
+        elif action == const.ACTION_NEXT:
+            selector.next()
+            if ai_mode:
+                logs.confirm_choice(selector.value)
+            else:
+                logs.confirm_text(selector.value)