Bump to 1.41

Add support to Fish shell

.travis.yml

@@ -6,4 +6,4 @@ python:
 install:
   - python setup.py develop
   - pip install -r requirements.txt
-script: py.test
+script: py.test -v

README.md

@@ -1,5 +1,7 @@
 # The Fuck [![Build Status](https://travis-ci.org/nvbn/thefuck.svg)](https://travis-ci.org/nvbn/thefuck)
 
+**Aliases changed in 1.34.**
+
 Magnificent app which corrects your previous console command,
 inspired by a [@liamosaur](https://twitter.com/liamosaur/)
 [tweet](https://twitter.com/liamosaur/status/506975850596536320).
@@ -71,7 +73,7 @@ REPL-y 0.3.1
 ...
 ```
 
-If you are scared to blindly run changed command, there's `require_confirmation`
+If you are scared to blindly run the changed command, there is a `require_confirmation`
 [settings](#settings) option:
 
 ```bash
@@ -102,14 +104,25 @@ sudo pip install thefuck
 
 [Or using an OS package manager (OS X, Ubuntu, Arch).](https://github.com/nvbn/thefuck/wiki/Installation)
 
-And add to `.bashrc` or `.zshrc` or `.bash_profile`(for OSX):
+And add to the `.bashrc` or `.bash_profile`(for OSX):
 
 ```bash
-alias fuck='eval $(thefuck $(fc -ln -1))'
+alias fuck='eval $(thefuck $(fc -ln -1)); history -r'
 # You can use whatever you want as an alias, like for Mondays:
 alias FUCK='fuck'
 ```
 
+Or in your `.zshrc`:
+
+```bash
+alias fuck='eval $(thefuck $(fc -ln -1 | tail -n 1)); fc -R'
+```
+
+If you are using `tcsh`:
+```tcsh
+alias fuck 'set fucked_cmd=`history -h 2 | head -n 1` && eval `thefuck ${fucked_cmd}`'
+```
+
 Alternatively, you can redirect the output of `thefuck-alias`:
 
 ```bash
@@ -129,20 +142,28 @@ sudo pip install thefuck --upgrade
 
 ## How it works
 
-The Fuck tries to match rule for the previous command, create new command
-using matched rule and run it. Rules enabled by default:
+The Fuck tries to match a rule for the previous command, creates a new command
+using the matched rule and runs it. Rules enabled by default are as follows:
 
 * `brew_unknown_command` – fixes wrong brew commands, for example `brew docto/brew doctor`;
+* `cpp11` – add missing `-std=c++11` to `g++` or `clang++`;
 * `cd_parent` – changes `cd..` to `cd ..`;
 * `cd_mkdir` – creates directories before cd'ing into them;
 * `cp_omitting_directory` – adds `-a` when you `cp` directory;
+* `dry` – fix repetitions like "git git push";
 * `fix_alt_space` – replaces Alt+Space with Space character;
+* `git_add` – fix *"Did you forget to 'git add'?"*;
+* `git_checkout` – creates the branch before checking-out;
 * `git_no_command` – fixes wrong git commands like `git brnch`;
 * `git_push` – adds `--set-upstream origin $branch` to previous failed `git push`;
+* `git_stash` – stashes you local modifications before rebasing or switching branch;
 * `has_exists_script` – prepends `./` when script/binary exists;
 * `lein_not_task` – fixes wrong `lein` tasks like `lein rpl`;
 * `mkdir_p` – adds `-p` when you trying to create directory without parent;
 * `no_command` – fixes wrong console commands, for example `vom/vim`;
+* `no_such_file` – creates missing directories with `mv` and `cp` commands;
+* `man_no_space` – fixes man commands without spaces, for example `mandiff`;
+* `pacman` – installs app with `pacman` or `yaourt` if it is not installed;
 * `pip_unknown_command` – fixes wrong pip commands, for example `pip instatl/pip install`;
 * `python_command` – prepends `python` when you trying to run not executable/without `./` python script;
 * `sl_ls` – changes `sl` to `ls`;
@@ -150,6 +171,7 @@ using matched rule and run it. Rules enabled by default:
 * `ssh_known_hosts` – removes host from `known_hosts` on warning;
 * `sudo` – prepends `sudo` to previous command if it failed because of permissions;
 * `switch_layout` – switches command from your local layout to en;
+* `whois` – fixes `whois` command;
 * `apt_get` – installs app from apt if it not installed;
 * `brew_install` – fixes formula name for `brew install`;
 * `composer_not_command` – fixes composer command name.
@@ -183,12 +205,14 @@ def match(command, settings):
 
 def get_new_command(command, settings):
     return 'sudo {}'.format(command.script)
-    
+
 # Optional:
 enabled_by_default = True
 
 def side_effect(command, settings):
     subprocess.call('chmod 777 .', shell=True)
+
+priority = 1000  # Lower first
 ```
 
 [More examples of rules](https://github.com/nvbn/thefuck/tree/master/thefuck/rules),
@@ -196,12 +220,13 @@ def side_effect(command, settings):
 
 ## Settings
 
-The Fuck has a few settings parameters, they can be changed in `~/.thefuck/settings.py`:
+The Fuck has a few settings parameters which can be changed in `~/.thefuck/settings.py`:
 
 * `rules` – list of enabled rules, by default `thefuck.conf.DEFAULT_RULES`;
-* `require_confirmation` – require confirmation before running new command, by default `False`;
+* `require_confirmation` – requires confirmation before running new command, by default `False`;
 * `wait_command` – max amount of time in seconds for getting previous command output;
-* `no_colors` – disable colored output.
+* `no_colors` – disable colored output;
+* `priority` – dict with rules priorities, rule with lower `priority` will be matched first.
 
 Example of `settings.py`:
 
@@ -210,6 +235,7 @@ rules = ['sudo', 'no_command']
 require_confirmation = True
 wait_command = 10
 no_colors = False
+priority = {'sudo': 100, 'no_command': 9999}
 ```
 
 Or via environment variables:
@@ -217,7 +243,9 @@ Or via environment variables:
 * `THEFUCK_RULES` – list of enabled rules, like `DEFAULT_RULES:rm_root` or `sudo:no_command`;
 * `THEFUCK_REQUIRE_CONFIRMATION` – require confirmation before running new command, `true/false`;
 * `THEFUCK_WAIT_COMMAND` – max amount of time in seconds for getting previous command output;
-* `THEFUCK_NO_COLORS` – disable colored output, `true/false`.
+* `THEFUCK_NO_COLORS` – disable colored output, `true/false`;
+* `THEFUCK_PRIORITY` – priority of the rules, like `no_command=9999:apt_get=100`,
+rule with lower `priority` will be matched first.
 
 For example:
 
@@ -226,6 +254,7 @@ export THEFUCK_RULES='sudo:no_command'
 export THEFUCK_REQUIRE_CONFIRMATION='true'
 export THEFUCK_WAIT_COMMAND=10
 export THEFUCK_NO_COLORS='false'
+export THEFUCK_PRIORITY='no_command=9999:apt_get=100'
 ```
 
 ## Developing

release.py

@@ -28,4 +28,4 @@ call('git commit -am "Bump to {}"'.format(version), shell=True)
 call('git tag {}'.format(version), shell=True)
 call('git push', shell=True)
 call('git push --tags', shell=True)
-call('python setup.py sdist upload', shell=True)
+call('python setup.py sdist bdist_wheel upload', shell=True)

requirements.txt

@@ -1,2 +1,4 @@
 pytest
 mock
+pytest-mock
+wheel

setup.cfg

@@ -0,0 +1,2 @@
+[bdist_wheel]
+universal = 1

setup.py

@@ -1,7 +1,7 @@
 from setuptools import setup, find_packages
 
 
-VERSION = '1.32'
+VERSION = '1.41'
 
 
 setup(name='thefuck',
@@ -17,4 +17,5 @@ setup(name='thefuck',
       zip_safe=False,
       install_requires=['pathlib', 'psutil', 'colorama', 'six'],
       entry_points={'console_scripts': [
-          'thefuck = thefuck.main:main', 'thefuck-alias = thefuck.main:alias']})
+          'thefuck = thefuck.main:main',
+          'thefuck-alias = thefuck.shells:app_alias']})

tests/rules/conftest.py

@@ -0,0 +1,6 @@
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def generic_shell(monkeypatch):
+    monkeypatch.setattr('thefuck.shells.and_', lambda *x: ' && '.join(x))

tests/rules/test_apt_get.py

@@ -0,0 +1,59 @@
+import pytest
+from mock import Mock, patch
+from thefuck.rules import apt_get
+from thefuck.rules.apt_get import match, get_new_command
+from tests.utils import Command
+
+
+# python-commandnotfound is available in ubuntu 14.04+
+@pytest.mark.skipif(not getattr(apt_get, 'enabled_by_default', True),
+                    reason='Skip if python-commandnotfound is not available')
+@pytest.mark.parametrize('command', [
+    Command(script='vim', stderr='vim: command not found')])
+def test_match(command):
+    assert match(command, None)
+
+
+@pytest.mark.parametrize('command, return_value', [
+    (Command(script='vim', stderr='vim: command not found'),
+     [('vim', 'main'), ('vim-tiny', 'main')])])
+@patch('thefuck.rules.apt_get.CommandNotFound', create=True)
+@patch.multiple(apt_get, create=True, apt_get='apt_get')
+def test_match_mocked(cmdnf_mock, command, return_value):
+    get_packages = Mock(return_value=return_value)
+    cmdnf_mock.CommandNotFound.return_value = Mock(getPackages=get_packages)
+    assert match(command, None)
+    assert cmdnf_mock.CommandNotFound.called
+    assert get_packages.called
+
+
+@pytest.mark.parametrize('command', [
+    Command(script='vim', stderr=''), Command()])
+def test_not_match(command):
+    assert not match(command, None)
+
+
+# python-commandnotfound is available in ubuntu 14.04+
+@pytest.mark.skipif(not getattr(apt_get, 'enabled_by_default', True),
+                    reason='Skip if python-commandnotfound is not available')
+@pytest.mark.parametrize('command, new_command', [
+    (Command('vim'), 'sudo apt-get install vim && vim'),
+    (Command('convert'), 'sudo apt-get install imagemagick && convert')])
+def test_get_new_command(command, new_command):
+    assert get_new_command(command, None) == new_command
+
+
+@pytest.mark.parametrize('command, new_command, return_value', [
+    (Command('vim'), 'sudo apt-get install vim && vim',
+     [('vim', 'main'), ('vim-tiny', 'main')]),
+    (Command('convert'), 'sudo apt-get install imagemagick && convert',
+     [('imagemagick', 'main'),
+      ('graphicsmagick-imagemagick-compat', 'universe')])])
+@patch('thefuck.rules.apt_get.CommandNotFound', create=True)
+@patch.multiple(apt_get, create=True, apt_get='apt_get')
+def test_get_new_command_mocked(cmdnf_mock, command, new_command, return_value):
+    get_packages = Mock(return_value=return_value)
+    cmdnf_mock.CommandNotFound.return_value = Mock(getPackages=get_packages)
+    assert get_new_command(command, None) == new_command
+    assert cmdnf_mock.CommandNotFound.called
+    assert get_packages.called

tests/rules/test_dry.py

@@ -0,0 +1,17 @@
+import pytest
+from thefuck.rules.dry import match, get_new_command
+from tests.utils import Command
+
+
+@pytest.mark.parametrize('command', [
+    Command(script='cd cd foo'),
+    Command(script='git git push origin/master')])
+def test_match(command):
+    assert match(command, None)
+
+
+@pytest.mark.parametrize('command, new_command', [
+    (Command('cd cd foo'), 'cd foo'),
+    (Command('git git push origin/master'), 'git push origin/master')])
+def test_get_new_command(command, new_command):
+    assert get_new_command(command, None) == new_command

tests/rules/test_git_add.py

@@ -0,0 +1,39 @@
+import pytest
+from thefuck.rules.git_add import match, get_new_command
+from tests.utils import Command
+
+
+@pytest.fixture
+def did_not_match(target, did_you_forget=True):
+    error = ("error: pathspec '{}' did not match any "
+             "file(s) known to git.".format(target))
+    if did_you_forget:
+        error = ("{}\nDid you forget to 'git add'?'".format(error))
+    return error
+
+
+@pytest.mark.parametrize('command', [
+    Command(script='git submodule update unknown',
+            stderr=did_not_match('unknown')),
+    Command(script='git commit unknown',
+            stderr=did_not_match('unknown'))])  # Older versions of Git
+def test_match(command):
+    assert match(command, None)
+
+
+@pytest.mark.parametrize('command', [
+    Command(script='git submodule update known', stderr=('')),
+    Command(script='git commit known', stderr=('')),
+    Command(script='git commit unknown',  # Newer versions of Git
+            stderr=did_not_match('unknown', False))])
+def test_not_match(command):
+    assert not match(command, None)
+
+
+@pytest.mark.parametrize('command, new_command', [
+    (Command('git submodule update unknown', stderr=did_not_match('unknown')),
+     'git add -- unknown && git submodule update unknown'),
+    (Command('git commit unknown', stderr=did_not_match('unknown')),  # Old Git
+     'git add -- unknown && git commit unknown')])
+def test_get_new_command(command, new_command):
+    assert get_new_command(command, None) == new_command

tests/rules/test_git_checkout.py

@@ -0,0 +1,37 @@
+import pytest
+from thefuck.rules.git_checkout import match, get_new_command
+from tests.utils import Command
+
+
+@pytest.fixture
+def did_not_match(target, did_you_forget=False):
+    error = ("error: pathspec '{}' did not match any "
+             "file(s) known to git.".format(target))
+    if did_you_forget:
+        error = ("{}\nDid you forget to 'git add'?'".format(error))
+    return error
+
+
+@pytest.mark.parametrize('command', [
+    Command(script='git checkout unknown', stderr=did_not_match('unknown')),
+    Command(script='git commit unknown', stderr=did_not_match('unknown'))])
+def test_match(command):
+    assert match(command, None)
+
+
+@pytest.mark.parametrize('command', [
+    Command(script='git submodule update unknown',
+            stderr=did_not_match('unknown', True)),
+    Command(script='git checkout known', stderr=('')),
+    Command(script='git commit known', stderr=(''))])
+def test_not_match(command):
+    assert not match(command, None)
+
+
+@pytest.mark.parametrize('command, new_command', [
+    (Command(script='git checkout unknown', stderr=did_not_match('unknown')),
+     'git branch unknown && git checkout unknown'),
+    (Command('git commit unknown', stderr=did_not_match('unknown')),
+     'git branch unknown && git commit unknown')])
+def test_get_new_command(command, new_command):
+    assert get_new_command(command, None) == new_command

tests/rules/test_git_stash.py

@@ -0,0 +1,39 @@
+import pytest
+from thefuck.rules.git_stash import match, get_new_command
+from tests.utils import Command
+
+
+@pytest.fixture
+def cherry_pick_error():
+    return ('error: Your local changes would be overwritten by cherry-pick.\n'
+            'hint: Commit your changes or stash them to proceed.\n'
+            'fatal: cherry-pick failed')
+
+
+@pytest.fixture
+def rebase_error():
+    return ('Cannot rebase: Your index contains uncommitted changes.\n'
+            'Please commit or stash them.')
+
+
+@pytest.mark.parametrize('command', [
+    Command(script='git cherry-pick a1b2c3d', stderr=cherry_pick_error()),
+    Command(script='git rebase -i HEAD~7', stderr=rebase_error())])
+def test_match(command):
+    assert match(command, None)
+
+
+@pytest.mark.parametrize('command', [
+    Command(script='git cherry-pick a1b2c3d', stderr=('')),
+    Command(script='git rebase -i HEAD~7', stderr=(''))])
+def test_not_match(command):
+    assert not match(command, None)
+
+
+@pytest.mark.parametrize('command, new_command', [
+    (Command(script='git cherry-pick a1b2c3d', stderr=cherry_pick_error),
+     'git stash && git cherry-pick a1b2c3d'),
+    (Command('git rebase -i HEAD~7', stderr=rebase_error),
+     'git stash && git rebase -i HEAD~7')])
+def test_get_new_command(command, new_command):
+    assert get_new_command(command, None) == new_command

tests/rules/test_grep_recursive.py

@@ -0,0 +1,12 @@
+from thefuck.rules.grep_recursive import match, get_new_command
+from tests.utils import Command
+
+
+def test_match():
+    assert match(Command('grep blah .', stderr='grep: .: Is a directory'), None)
+    assert not match(Command(), None)
+
+
+def test_get_new_command():
+    assert get_new_command(
+        Command('grep blah .'), None) == 'grep -r blah .'

tests/rules/test_man_no_space.py

@@ -0,0 +1,12 @@
+from thefuck.rules.man_no_space import match, get_new_command
+from tests.utils import Command
+
+
+def test_match():
+    assert match(Command('mandiff', stderr='mandiff: command not found'), None)
+    assert not match(Command(), None)
+
+
+def test_get_new_command():
+    assert get_new_command(
+        Command('mandiff'), None) == 'man diff'

tests/rules/test_no_such_file.py

@@ -0,0 +1,19 @@
+import pytest
+from thefuck.rules.no_such_file import match, get_new_command
+from tests.utils import Command
+
+
+@pytest.mark.parametrize('command', [
+    Command(script='mv foo bar/foo', stderr="mv: cannot move 'foo' to 'bar/foo': No such file or directory"),
+    Command(script='mv foo bar/', stderr="mv: cannot move 'foo' to 'bar/': No such file or directory"),
+    ])
+def test_match(command):
+    assert match(command, None)
+
+
+@pytest.mark.parametrize('command, new_command', [
+    (Command(script='mv foo bar/foo', stderr="mv: cannot move 'foo' to 'bar/foo': No such file or directory"), 'mkdir -p bar && mv foo bar/foo'),
+    (Command(script='mv foo bar/', stderr="mv: cannot move 'foo' to 'bar/': No such file or directory"), 'mkdir -p bar && mv foo bar/'),
+    ])
+def test_get_new_command(command, new_command):
+    assert get_new_command(command, None) == new_command

tests/rules/test_pacman.py

@@ -0,0 +1,66 @@
+import pytest
+from mock import patch
+from thefuck.rules import pacman
+from thefuck.rules.pacman import match, get_new_command
+from tests.utils import Command
+
+
+pacman_cmd = getattr(pacman, 'pacman', 'pacman')
+
+PKGFILE_OUTPUT_CONVERT = '''
+extra/imagemagick 6.9.1.0-1\t/usr/bin/convert
+'''
+
+PKGFILE_OUTPUT_VIM = '''
+extra/gvim 7.4.712-1        \t/usr/bin/vim
+extra/gvim-python3 7.4.712-1\t/usr/bin/vim
+extra/vim 7.4.712-1         \t/usr/bin/vim
+extra/vim-minimal 7.4.712-1 \t/usr/bin/vim
+extra/vim-python3 7.4.712-1 \t/usr/bin/vim
+'''
+
+
+@pytest.mark.skipif(not getattr(pacman, 'enabled_by_default', True),
+                    reason='Skip if pacman is not available')
+@pytest.mark.parametrize('command', [
+    Command(script='vim', stderr='vim: command not found')])
+def test_match(command):
+    assert match(command, None)
+
+
+@pytest.mark.parametrize('command, return_value', [
+    (Command(script='vim', stderr='vim: command not found'), PKGFILE_OUTPUT_VIM)])
+@patch('thefuck.rules.pacman.subprocess')
+@patch.multiple(pacman, create=True, pacman=pacman_cmd)
+def test_match_mocked(subp_mock, command, return_value):
+    subp_mock.check_output.return_value = return_value
+    assert match(command, None)
+    assert subp_mock.check_output.called
+
+
+@pytest.mark.parametrize('command', [
+    Command(script='vim', stderr=''), Command()])
+def test_not_match(command):
+    assert not match(command, None)
+
+
+@pytest.mark.skipif(not getattr(pacman, 'enabled_by_default', True),
+                    reason='Skip if pacman is not available')
+@pytest.mark.parametrize('command, new_command', [
+    (Command('vim'), '{} -S extra/gvim && vim'.format(pacman_cmd)),
+    (Command('convert'), '{} -S extra/imagemagick && convert'.format(pacman_cmd))])
+def test_get_new_command(command, new_command, mocker):
+    assert get_new_command(command, None) == new_command
+
+
+@pytest.mark.parametrize('command, new_command, return_value', [
+    (Command('vim'), '{} -S extra/gvim && vim'.format(pacman_cmd),
+        PKGFILE_OUTPUT_VIM),
+    (Command('convert'), '{} -S extra/imagemagick && convert'.format(pacman_cmd),
+        PKGFILE_OUTPUT_CONVERT)])
+@patch('thefuck.rules.pacman.subprocess')
+@patch.multiple(pacman, create=True, pacman=pacman_cmd)
+def test_get_new_command_mocked(subp_mock, command, new_command, return_value):
+    subp_mock.check_output.return_value = return_value
+    assert get_new_command(command, None) == new_command
+    assert subp_mock.check_output.called

tests/rules/test_whois.py

@@ -0,0 +1,19 @@
+import pytest
+from thefuck.rules.whois import match, get_new_command
+from tests.utils import Command
+
+
+@pytest.mark.parametrize('command', [
+    Command(script='whois https://en.wikipedia.org/wiki/Main_Page'),
+    Command(script='whois https://en.wikipedia.org/'),
+    Command(script='whois en.wikipedia.org')])
+def test_match(command):
+    assert match(command, None)
+
+
+@pytest.mark.parametrize('command, new_command', [
+    (Command('whois https://en.wikipedia.org/wiki/Main_Page'), 'whois en.wikipedia.org'),
+    (Command('whois https://en.wikipedia.org/'), 'whois en.wikipedia.org'),
+    (Command('whois en.wikipedia.org'), 'whois wikipedia.org')])
+def test_get_new_command(command, new_command):
+    assert get_new_command(command, None) == new_command

tests/test_conf.py

@@ -1,89 +1,102 @@
+import pytest
 import six
-from mock import patch, Mock
+from mock import Mock
 from thefuck import conf
 from tests.utils import Rule
 
 
-def test_default():
-    assert Rule('test', enabled_by_default=True) in conf.DEFAULT_RULES
-    assert Rule('test', enabled_by_default=False) not in conf.DEFAULT_RULES
-    assert Rule('test', enabled_by_default=False) in (conf.DEFAULT_RULES + ['test'])
+@pytest.mark.parametrize('enabled, rules, result', [
+    (True, conf.DEFAULT_RULES, True),
+    (False, conf.DEFAULT_RULES, False),
+    (False, conf.DEFAULT_RULES + ['test'], True)])
+def test_default(enabled, rules, result):
+    assert (Rule('test', enabled_by_default=enabled) in rules) == result
 
 
-def test_settings_defaults():
-    with patch('thefuck.conf.load_source', return_value=object()), \
-         patch('thefuck.conf.os.environ', new_callable=lambda: {}):
-        for key, val in conf.DEFAULT_SETTINGS.items():
-            assert getattr(conf.get_settings(Mock()), key) == val
+@pytest.fixture
+def load_source(mocker):
+    return mocker.patch('thefuck.conf.load_source')
 
 
-def test_settings_from_file():
-    with patch('thefuck.conf.load_source', return_value=Mock(rules=['test'],
-                                                             wait_command=10,
-                                                             require_confirmation=True,
-                                                             no_colors=True)), \
-         patch('thefuck.conf.os.environ', new_callable=lambda: {}):
+@pytest.fixture
+def environ(monkeypatch):
+    data = {}
+    monkeypatch.setattr('thefuck.conf.os.environ', data)
+    return data
+
+
+@pytest.mark.usefixture('environ')
+def test_settings_defaults(load_source):
+    load_source.return_value = object()
+    for key, val in conf.DEFAULT_SETTINGS.items():
+        assert getattr(conf.get_settings(Mock()), key) == val
+
+
+@pytest.mark.usefixture('environ')
+class TestSettingsFromFile(object):
+    def test_from_file(self, load_source):
+        load_source.return_value = Mock(rules=['test'],
+                                        wait_command=10,
+                                        require_confirmation=True,
+                                        no_colors=True,
+                                        priority={'vim': 100})
         settings = conf.get_settings(Mock())
         assert settings.rules == ['test']
         assert settings.wait_command == 10
         assert settings.require_confirmation is True
         assert settings.no_colors is True
+        assert settings.priority == {'vim': 100}
 
-
-def test_settings_from_file_with_DEFAULT():
-    with patch('thefuck.conf.load_source', return_value=Mock(rules=conf.DEFAULT_RULES + ['test'],
-                                                             wait_command=10,
-                                                             require_confirmation=True,
-                                                             no_colors=True)), \
-         patch('thefuck.conf.os.environ', new_callable=lambda: {}):
+    def test_from_file_with_DEFAULT(self, load_source):
+        load_source.return_value = Mock(rules=conf.DEFAULT_RULES + ['test'],
+                                        wait_command=10,
+                                        require_confirmation=True,
+                                        no_colors=True)
         settings = conf.get_settings(Mock())
         assert settings.rules == conf.DEFAULT_RULES + ['test']
 
 
-def test_settings_from_env():
-    with patch('thefuck.conf.load_source', return_value=Mock(rules=['test'],
-                                                             wait_command=10)), \
-         patch('thefuck.conf.os.environ',
-               new_callable=lambda: {'THEFUCK_RULES': 'bash:lisp',
-                                     'THEFUCK_WAIT_COMMAND': '55',
-                                     'THEFUCK_REQUIRE_CONFIRMATION': 'true',
-                                     'THEFUCK_NO_COLORS': 'false'}):
+@pytest.mark.usefixture('load_source')
+class TestSettingsFromEnv(object):
+    def test_from_env(self, environ):
+        environ.update({'THEFUCK_RULES': 'bash:lisp',
+                        'THEFUCK_WAIT_COMMAND': '55',
+                        'THEFUCK_REQUIRE_CONFIRMATION': 'true',
+                        'THEFUCK_NO_COLORS': 'false',
+                        'THEFUCK_PRIORITY': 'bash=10:lisp=wrong:vim=15'})
         settings = conf.get_settings(Mock())
         assert settings.rules == ['bash', 'lisp']
         assert settings.wait_command == 55
         assert settings.require_confirmation is True
         assert settings.no_colors is False
+        assert settings.priority == {'bash': 10, 'vim': 15}
 
-
-def test_settings_from_env_with_DEFAULT():
-    with patch('thefuck.conf.load_source', return_value=Mock()), \
-         patch('thefuck.conf.os.environ', new_callable=lambda: {'THEFUCK_RULES': 'DEFAULT_RULES:bash:lisp'}):
+    def test_from_env_with_DEFAULT(self, environ):
+        environ.update({'THEFUCK_RULES': 'DEFAULT_RULES:bash:lisp'})
         settings = conf.get_settings(Mock())
         assert settings.rules == conf.DEFAULT_RULES + ['bash', 'lisp']
 
 
-def test_initialize_settings_file_ignore_if_exists():
-    settings_path_mock = Mock(is_file=Mock(return_value=True), open=Mock())
-    user_dir_mock = Mock(joinpath=Mock(return_value=settings_path_mock))
-    conf.initialize_settings_file(user_dir_mock)
-    assert settings_path_mock.is_file.call_count == 1
-    assert not settings_path_mock.open.called
+class TestInitializeSettingsFile(object):
+    def test_ignore_if_exists(self):
+        settings_path_mock = Mock(is_file=Mock(return_value=True), open=Mock())
+        user_dir_mock = Mock(joinpath=Mock(return_value=settings_path_mock))
+        conf.initialize_settings_file(user_dir_mock)
+        assert settings_path_mock.is_file.call_count == 1
+        assert not settings_path_mock.open.called
 
-
-def test_initialize_settings_file_create_if_exists_not():
-    settings_file = six.StringIO()
-    settings_path_mock = Mock(
-        is_file=Mock(return_value=False),
-        open=Mock(return_value=Mock(
-            __exit__=lambda *args: None, __enter__=lambda *args: settings_file
-        )),
-    )
-    user_dir_mock = Mock(joinpath=Mock(return_value=settings_path_mock))
-    conf.initialize_settings_file(user_dir_mock)
-    settings_file_contents = settings_file.getvalue()
-    assert settings_path_mock.is_file.call_count == 1
-    assert settings_path_mock.open.call_count == 1
-    assert conf.SETTINGS_HEADER in settings_file_contents
-    for setting in conf.DEFAULT_SETTINGS.items():
-        assert '# {} = {}\n'.format(*setting) in settings_file_contents
-    settings_file.close()
+    def test_create_if_doesnt_exists(self):
+        settings_file = six.StringIO()
+        settings_path_mock = Mock(
+            is_file=Mock(return_value=False),
+            open=Mock(return_value=Mock(
+                __exit__=lambda *args: None, __enter__=lambda *args: settings_file)))
+        user_dir_mock = Mock(joinpath=Mock(return_value=settings_path_mock))
+        conf.initialize_settings_file(user_dir_mock)
+        settings_file_contents = settings_file.getvalue()
+        assert settings_path_mock.is_file.call_count == 1
+        assert settings_path_mock.open.call_count == 1
+        assert conf.SETTINGS_HEADER in settings_file_contents
+        for setting in conf.DEFAULT_SETTINGS.items():
+            assert '# {} = {}\n'.format(*setting) in settings_file_contents
+        settings_file.close()

tests/test_main.py

@@ -1,115 +1,173 @@
+import pytest
 from subprocess import PIPE
 from pathlib import PosixPath, Path
-from mock import patch, Mock
+from mock import Mock
 from thefuck import main, conf, types
 from tests.utils import Rule, Command
 
 
-def test_load_rule():
+def test_load_rule(mocker):
     match = object()
     get_new_command = object()
-    with patch('thefuck.main.load_source',
-               return_value=Mock(
-                   match=match,
-                   get_new_command=get_new_command,
-                   enabled_by_default=True)) as load_source:
-        assert main.load_rule(Path('/rules/bash.py')) \
-               == Rule('bash', match, get_new_command)
-        load_source.assert_called_once_with('bash', '/rules/bash.py')
+    load_source = mocker.patch(
+        'thefuck.main.load_source',
+        return_value=Mock(match=match,
+                          get_new_command=get_new_command,
+                          enabled_by_default=True,
+                          priority=900))
+    assert main.load_rule(Path('/rules/bash.py')) \
+           == Rule('bash', match, get_new_command, priority=900)
+    load_source.assert_called_once_with('bash', '/rules/bash.py')
 
 
-def test_get_rules():
-    with patch('thefuck.main.Path.glob') as glob, \
-            patch('thefuck.main.load_source',
-                  lambda x, _: Mock(match=x, get_new_command=x,
-                                    enabled_by_default=True)):
+class TestGetRules(object):
+    @pytest.fixture(autouse=True)
+    def glob(self, mocker):
+        return mocker.patch('thefuck.main.Path.glob', return_value=[])
+
+    def _compare_names(self, rules, names):
+        return [r.name for r in rules] == names
+
+    @pytest.mark.parametrize('conf_rules, rules', [
+        (conf.DEFAULT_RULES, ['bash', 'lisp', 'bash', 'lisp']),
+        (types.RulesNamesList(['bash']), ['bash', 'bash'])])
+    def test_get(self, monkeypatch, glob, conf_rules, rules):
         glob.return_value = [PosixPath('bash.py'), PosixPath('lisp.py')]
-        assert list(main.get_rules(
-            Path('~'),
-            Mock(rules=conf.DEFAULT_RULES))) \
-               == [Rule('bash', 'bash', 'bash'),
-                   Rule('lisp', 'lisp', 'lisp'),
-                   Rule('bash', 'bash', 'bash'),
-                   Rule('lisp', 'lisp', 'lisp')]
-        assert list(main.get_rules(
-            Path('~'),
-            Mock(rules=types.RulesNamesList(['bash'])))) \
-               == [Rule('bash', 'bash', 'bash'),
-                   Rule('bash', 'bash', 'bash')]
+        monkeypatch.setattr('thefuck.main.load_source',
+                            lambda x, _: Rule(x))
+        assert self._compare_names(
+            main.get_rules(Path('~'), Mock(rules=conf_rules, priority={})),
+            rules)
+
+    @pytest.mark.parametrize('priority, unordered, ordered', [
+        ({},
+         [Rule('bash', priority=100), Rule('python', priority=5)],
+         ['python', 'bash']),
+        ({},
+         [Rule('lisp', priority=9999), Rule('c', priority=conf.DEFAULT_PRIORITY)],
+         ['c', 'lisp']),
+        ({'python': 9999},
+         [Rule('bash', priority=100), Rule('python', priority=5)],
+         ['bash', 'python'])])
+    def test_ordered_by_priority(self, monkeypatch, priority, unordered, ordered):
+        monkeypatch.setattr('thefuck.main._get_loaded_rules',
+                            lambda *_: unordered)
+        assert self._compare_names(
+            main.get_rules(Path('~'), Mock(priority=priority)),
+            ordered)
 
 
-def test_get_command():
-    with patch('thefuck.main.Popen') as Popen, \
-            patch('thefuck.main.os.environ',
-                  new_callable=lambda: {}), \
-            patch('thefuck.main.wait_output',
-                  return_value=True):
+class TestGetCommand(object):
+    @pytest.fixture(autouse=True)
+    def Popen(self, monkeypatch):
+        Popen = Mock()
         Popen.return_value.stdout.read.return_value = b'stdout'
         Popen.return_value.stderr.read.return_value = b'stderr'
-        assert main.get_command(Mock(), ['thefuck', 'apt-get',
-                                         'search', 'vim']) \
+        monkeypatch.setattr('thefuck.main.Popen', Popen)
+        return Popen
+
+    @pytest.fixture(autouse=True)
+    def prepare(self, monkeypatch):
+        monkeypatch.setattr('thefuck.main.os.environ', {})
+        monkeypatch.setattr('thefuck.main.wait_output', lambda *_: True)
+
+    @pytest.fixture(autouse=True)
+    def generic_shell(self, monkeypatch):
+        monkeypatch.setattr('thefuck.shells.from_shell', lambda x: x)
+        monkeypatch.setattr('thefuck.shells.to_shell', lambda x: x)
+
+    def test_get_command_calls(self, Popen):
+        assert main.get_command(Mock(),
+            ['thefuck', 'apt-get', 'search', 'vim']) \
                == Command('apt-get search vim', 'stdout', 'stderr')
         Popen.assert_called_once_with('apt-get search vim',
                                       shell=True,
                                       stdout=PIPE,
                                       stderr=PIPE,
                                       env={'LANG': 'C'})
-        assert main.get_command(Mock(), ['']) is None
+
+    @pytest.mark.parametrize('args, result', [
+        (['thefuck', 'ls', '-la'], 'ls -la'),
+        (['thefuck', 'ls'], 'ls')])
+    def test_get_command_script(self, args, result):
+        if result:
+            assert main.get_command(Mock(), args).script == result
+        else:
+            assert main.get_command(Mock(), args) is None
 
 
-def test_get_matched_rule(capsys):
-    rules = [Rule('', lambda x, _: x.script == 'cd ..'),
-             Rule('', lambda *_: False),
-             Rule('rule', Mock(side_effect=OSError('Denied')))]
-    assert main.get_matched_rule(Command('ls'),
-                                 rules, Mock(no_colors=True)) is None
-    assert main.get_matched_rule(Command('cd ..'),
-                                 rules, Mock(no_colors=True)) == rules[0]
-    assert capsys.readouterr()[1].split('\n')[0] \
-           == '[WARN] Rule rule:'
+class TestGetMatchedRule(object):
+    def test_no_match(self):
+        assert main.get_matched_rule(
+            Command('ls'), [Rule('', lambda *_: False)],
+            Mock(no_colors=True)) is None
+
+    def test_match(self):
+        rule = Rule('', lambda x, _: x.script == 'cd ..')
+        assert main.get_matched_rule(
+            Command('cd ..'), [rule], Mock(no_colors=True)) == rule
+
+    def test_when_rule_failed(self, capsys):
+        main.get_matched_rule(
+            Command('ls'), [Rule('test', Mock(side_effect=OSError('Denied')))],
+            Mock(no_colors=True))
+        assert capsys.readouterr()[1].split('\n')[0] == '[WARN] Rule test:'
 
 
-def test_run_rule(capsys):
-    with patch('thefuck.main.confirm', return_value=True):
+class TestRunRule(object):
+    @pytest.fixture(autouse=True)
+    def confirm(self, mocker):
+        return mocker.patch('thefuck.main.confirm', return_value=True)
+
+    def test_run_rule(self, capsys):
         main.run_rule(Rule(get_new_command=lambda *_: 'new-command'),
-                      None, None)
+                      Command(), None)
         assert capsys.readouterr() == ('new-command\n', '')
-        # With side effect:
+
+    def test_run_rule_with_side_effect(self, capsys):
         side_effect = Mock()
         settings = Mock()
-        command = Mock()
+        command = Command()
         main.run_rule(Rule(get_new_command=lambda *_: 'new-command',
                            side_effect=side_effect),
                       command, settings)
         assert capsys.readouterr() == ('new-command\n', '')
         side_effect.assert_called_once_with(command, settings)
-    with patch('thefuck.main.confirm', return_value=False):
+
+    def test_when_not_comfirmed(self, capsys, confirm):
+        confirm.return_value = False
         main.run_rule(Rule(get_new_command=lambda *_: 'new-command'),
-                      None, None)
+                      Command(), None)
         assert capsys.readouterr() == ('', '')
 
 
-def test_confirm(capsys):
-    # When confirmation not required:
-    assert main.confirm('command', None, Mock(require_confirmation=False))
-    assert capsys.readouterr() == ('', 'command\n')
-    # With side effect and without confirmation:
-    assert main.confirm('command', Mock(), Mock(require_confirmation=False))
-    assert capsys.readouterr() == ('', 'command*\n')
-    # When confirmation required and confirmed:
-    with patch('thefuck.main.sys.stdin.read', return_value='\n'):
-        assert main.confirm(
-            'command', None, Mock(require_confirmation=True,
-                                  no_colors=True))
+class TestConfirm(object):
+    @pytest.fixture
+    def stdin(self, mocker):
+        return mocker.patch('sys.stdin.read', return_value='\n')
+
+    def test_when_not_required(self, capsys):
+        assert main.confirm('command', None, Mock(require_confirmation=False))
+        assert capsys.readouterr() == ('', 'command\n')
+
+    def test_with_side_effect_and_without_confirmation(self, capsys):
+        assert main.confirm('command', Mock(), Mock(require_confirmation=False))
+        assert capsys.readouterr() == ('', 'command*\n')
+
+    # `stdin` fixture should be applied after `capsys`
+    def test_when_confirmation_required_and_confirmed(self, capsys, stdin):
+        assert main.confirm('command', None, Mock(require_confirmation=True,
+                                                  no_colors=True))
         assert capsys.readouterr() == ('', 'command [enter/ctrl+c]')
-        # With side effect:
-        assert main.confirm(
-            'command', Mock(), Mock(require_confirmation=True,
-                                    no_colors=True))
+
+    # `stdin` fixture should be applied after `capsys`
+    def test_when_confirmation_required_and_confirmed_with_side_effect(self, capsys, stdin):
+        assert main.confirm('command', Mock(), Mock(require_confirmation=True,
+                                                    no_colors=True))
         assert capsys.readouterr() == ('', 'command* [enter/ctrl+c]')
-    # When confirmation required and ctrl+c:
-    with patch('thefuck.main.sys.stdin.read', side_effect=KeyboardInterrupt):
-        assert not main.confirm('command', None,
-                                Mock(require_confirmation=True,
-                                     no_colors=True))
+
+    def test_when_confirmation_required_and_aborted(self, capsys, stdin):
+        stdin.side_effect = KeyboardInterrupt
+        assert not main.confirm('command', None, Mock(require_confirmation=True,
+                                                      no_colors=True))
         assert capsys.readouterr() == ('', 'command [enter/ctrl+c]Aborted\n')

tests/test_shells.py

@@ -0,0 +1,100 @@
+import pytest
+from thefuck import shells
+
+
+@pytest.fixture
+def builtins_open(mocker):
+    return mocker.patch('six.moves.builtins.open')
+
+
+@pytest.fixture
+def isfile(mocker):
+    return mocker.patch('os.path.isfile', return_value=True)
+
+
+class TestGeneric(object):
+    def test_from_shell(self):
+        assert shells.Generic().from_shell('pwd') == 'pwd'
+
+    def test_to_shell(self):
+        assert shells.Generic().to_shell('pwd') == 'pwd'
+
+    def test_put_to_history(self, builtins_open):
+        assert shells.Generic().put_to_history('ls') is None
+        assert builtins_open.call_count == 0
+
+
+@pytest.mark.usefixtures('isfile')
+class TestBash(object):
+    @pytest.fixture(autouse=True)
+    def Popen(self, mocker):
+        mock = mocker.patch('thefuck.shells.Popen')
+        mock.return_value.stdout.read.return_value = (
+            b'alias l=\'ls -CF\'\n'
+            b'alias la=\'ls -A\'\n'
+            b'alias ll=\'ls -alF\'')
+        return mock
+
+    @pytest.mark.parametrize('before, after', [
+        ('pwd', 'pwd'),
+        ('ll', 'ls -alF')])
+    def test_from_shell(self, before, after):
+        assert shells.Bash().from_shell(before) == after
+
+    def test_to_shell(self):
+        assert shells.Bash().to_shell('pwd') == 'pwd'
+
+    def test_put_to_history(self, builtins_open):
+        shells.Bash().put_to_history('ls')
+        builtins_open.return_value.__enter__.return_value. \
+            write.assert_called_once_with('ls\n')
+
+
+@pytest.mark.usefixtures('isfile')
+class TestFish(object):
+    @pytest.mark.parametrize('before, after', [
+        ('pwd', 'pwd'),
+        ('ll', 'll')])  # Fish has no aliases but functions
+    def test_from_shell(self, before, after):
+        assert shells.Fish().from_shell(before) == after
+
+    def test_to_shell(self):
+        assert shells.Fish().to_shell('pwd') == 'pwd'
+
+    def test_put_to_history(self, builtins_open, mocker):
+        mocker.patch('thefuck.shells.time',
+                     return_value=1430707243.3517463)
+        shells.Fish().put_to_history('ls')
+        builtins_open.return_value.__enter__.return_value. \
+            write.assert_called_once_with('- cmd: ls\n   when: 1430707243\n')
+
+    def test_and_(self):
+        assert shells.Fish().and_('foo', 'bar') == 'foo; and bar'
+
+
+@pytest.mark.usefixtures('isfile')
+class TestZsh(object):
+    @pytest.fixture(autouse=True)
+    def Popen(self, mocker):
+        mock = mocker.patch('thefuck.shells.Popen')
+        mock.return_value.stdout.read.return_value = (
+            b'l=\'ls -CF\'\n'
+            b'la=\'ls -A\'\n'
+            b'll=\'ls -alF\'')
+        return mock
+
+    @pytest.mark.parametrize('before, after', [
+        ('pwd', 'pwd'),
+        ('ll', 'ls -alF')])
+    def test_from_shell(self, before, after):
+        assert shells.Zsh().from_shell(before) == after
+
+    def test_to_shell(self):
+        assert shells.Zsh().to_shell('pwd') == 'pwd'
+
+    def test_put_to_history(self, builtins_open, mocker):
+        mocker.patch('thefuck.shells.time',
+                     return_value=1430707243.3517463)
+        shells.Zsh().put_to_history('ls')
+        builtins_open.return_value.__enter__.return_value. \
+            write.assert_called_once_with(': 1430707243:0;ls\n')

tests/test_utils.py

@@ -1,26 +1,26 @@
+import pytest
 from mock import Mock
 from thefuck.utils import sudo_support, wrap_settings
 from thefuck.types import Settings
 from tests.utils import Command
 
 
-def test_wrap_settings():
+@pytest.mark.parametrize('override, old, new', [
+    ({'key': 'val'}, {}, {'key': 'val'}),
+    ({'key': 'new-val'}, {'key': 'val'}, {'key': 'new-val'})])
+def test_wrap_settings(override, old, new):
     fn = lambda _, settings: settings
-    assert wrap_settings({'key': 'val'})(fn)(None, Settings({})) \
-           == {'key': 'val'}
-    assert wrap_settings({'key': 'new-val'})(fn)(
-        None, Settings({'key': 'val'})) == {'key': 'new-val'}
+    assert wrap_settings(override)(fn)(None, Settings(old)) == new
 
 
-def test_sudo_support():
-    fn = Mock(return_value=True, __name__='')
-    assert sudo_support(fn)(Command('sudo ls'), None)
-    fn.assert_called_once_with(Command('ls'), None)
-
-    fn.return_value = False
-    assert not sudo_support(fn)(Command('sudo ls'), None)
-
-    fn.return_value = 'pwd'
-    assert sudo_support(fn)(Command('sudo ls'), None) == 'sudo pwd'
-
-    assert sudo_support(fn)(Command('ls'), None) == 'pwd'
+@pytest.mark.parametrize('return_value, command, called, result', [
+    ('ls -lah', 'sudo ls', 'ls', 'sudo ls -lah'),
+    ('ls -lah', 'ls', 'ls', 'ls -lah'),
+    (True, 'sudo ls', 'ls', True),
+    (True, 'ls', 'ls', True),
+    (False, 'sudo ls', 'ls', False),
+    (False, 'ls', 'ls', False)])
+def test_sudo_support(return_value, command, called, result):
+    fn = Mock(return_value=return_value, __name__='')
+    assert sudo_support(fn)(Command(command), None) == result
+    fn.assert_called_once_with(Command(called), None)

tests/utils.py

@@ -1,4 +1,5 @@
 from thefuck import types
+from thefuck.conf import DEFAULT_PRIORITY
 
 
 def Command(script='', stdout='', stderr=''):
@@ -8,6 +9,8 @@ def Command(script='', stdout='', stderr=''):
 def Rule(name='', match=lambda *_: True,
          get_new_command=lambda *_: '',
          enabled_by_default=True,
-         side_effect=None):
+         side_effect=None,
+         priority=DEFAULT_PRIORITY):
     return types.Rule(name, match, get_new_command,
-                      enabled_by_default, side_effect)
+                      enabled_by_default, side_effect,
+                      priority)

thefuck/conf.py

@@ -22,17 +22,20 @@ class _DefaultRulesNames(types.RulesNamesList):
 
 
 DEFAULT_RULES = _DefaultRulesNames([])
+DEFAULT_PRIORITY = 1000
 
 
 DEFAULT_SETTINGS = {'rules': DEFAULT_RULES,
                     'wait_command': 3,
                     'require_confirmation': False,
-                    'no_colors': False}
+                    'no_colors': False,
+                    'priority': {}}
 
 ENV_TO_ATTR = {'THEFUCK_RULES': 'rules',
                'THEFUCK_WAIT_COMMAND': 'wait_command',
                'THEFUCK_REQUIRE_CONFIRMATION': 'require_confirmation',
-               'THEFUCK_NO_COLORS': 'no_colors'}
+               'THEFUCK_NO_COLORS': 'no_colors',
+               'THEFUCK_PRIORITY': 'priority'}
 
 
 SETTINGS_HEADER = u"""# ~/.thefuck/settings.py: The Fuck settings file
@@ -65,16 +68,29 @@ def _rules_from_env(val):
     return val
 
 
+def _priority_from_env(val):
+    """Gets priority pairs from env."""
+    for part in val.split(':'):
+        try:
+            rule, priority = part.split('=')
+            yield rule, int(priority)
+        except ValueError:
+            continue
+
+
 def _val_from_env(env, attr):
     """Transforms env-strings to python."""
     val = os.environ[env]
     if attr == 'rules':
-        val = _rules_from_env(val)
+        return _rules_from_env(val)
+    elif attr == 'priority':
+        return dict(_priority_from_env(val))
     elif attr == 'wait_command':
-        val = int(val)
+        return int(val)
     elif attr in ('require_confirmation', 'no_colors'):
-        val = val.lower() == 'true'
-    return val
+        return val.lower() == 'true'
+    else:
+        return val
 
 
 def _settings_from_env():

thefuck/main.py

@@ -6,7 +6,8 @@ import os
 import sys
 from psutil import Process, TimeoutExpired
 import colorama
-from . import logs, conf, types
+import six
+from . import logs, conf, types, shells
 
 
 def setup_user_dir():
@@ -25,7 +26,17 @@ def load_rule(rule):
     return types.Rule(rule.name[:-3], rule_module.match,
                       rule_module.get_new_command,
                       getattr(rule_module, 'enabled_by_default', True),
-                      getattr(rule_module, 'side_effect', None))
+                      getattr(rule_module, 'side_effect', None),
+                      getattr(rule_module, 'priority', conf.DEFAULT_PRIORITY))
+
+
+def _get_loaded_rules(rules, settings):
+    """Yields all available rules."""
+    for rule in rules:
+        if rule.name != '__init__.py':
+            loaded_rule = load_rule(rule)
+            if loaded_rule in settings.rules:
+                yield loaded_rule
 
 
 def get_rules(user_dir, settings):
@@ -34,11 +45,9 @@ def get_rules(user_dir, settings):
         .joinpath('rules') \
         .glob('*.py')
     user = user_dir.joinpath('rules').glob('*.py')
-    for rule in sorted(list(bundled)) + list(user):
-        if rule.name != '__init__.py':
-            loaded_rule = load_rule(rule)
-            if loaded_rule in settings.rules:
-                yield loaded_rule
+    rules = _get_loaded_rules(sorted(bundled) + sorted(user), settings)
+    return sorted(rules, key=lambda rule: settings.priority.get(
+        rule.name, rule.priority))
 
 
 def wait_output(settings, popen):
@@ -61,7 +70,7 @@ def wait_output(settings, popen):
 
 def get_command(settings, args):
     """Creates command from `args` and executes it."""
-    if sys.version_info[0] < 3:
+    if six.PY2:
         script = ' '.join(arg.decode('utf-8') for arg in args[1:])
     else:
         script = ' '.join(args[1:])
@@ -69,6 +78,7 @@ def get_command(settings, args):
     if not script:
         return
 
+    script = shells.from_shell(script)
     result = Popen(script, shell=True, stdout=PIPE, stderr=PIPE,
                    env=dict(os.environ, LANG='C'))
     if wait_output(settings, result):
@@ -103,22 +113,14 @@ def confirm(new_command, side_effect, settings):
 
 def run_rule(rule, command, settings):
     """Runs command from rule for passed command."""
-    new_command = rule.get_new_command(command, settings)
+    new_command = shells.to_shell(rule.get_new_command(command, settings))
     if confirm(new_command, rule.side_effect, settings):
         if rule.side_effect:
             rule.side_effect(command, settings)
+        shells.put_to_history(new_command)
         print(new_command)
 
 
-def is_second_run(command):
-    """Is it the second run of `fuck`?"""
-    return command.script.startswith('fuck')
-
-
-def alias():
-    print("\nalias fuck='eval $(thefuck $(fc -ln -1))'\n")
-
-
 def main():
     colorama.init()
     user_dir = setup_user_dir()
@@ -126,10 +128,6 @@ def main():
 
     command = get_command(settings, sys.argv)
     if command:
-        if is_second_run(command):
-            logs.failed("Can't fuck twice", settings)
-            return
-
         rules = get_rules(user_dir, settings)
         matched_rule = get_matched_rule(command, rules, settings)
         if matched_rule:

thefuck/rules/apt_get.py

@@ -1,3 +1,5 @@
+from thefuck import shells
+
 try:
     import CommandNotFound
 except ImportError:
@@ -20,4 +22,5 @@ def get_new_command(command, settings):
     c = CommandNotFound.CommandNotFound()
     pkgs = c.getPackages(command.script.split(" ")[0])
     name, _ = pkgs[0]
-    return "sudo apt-get install {} && {}".format(name, command.script)
+    formatme = shells.and_('sudo apt-get install {}', '{}')
+    return formatme.format(name, command.script)

thefuck/rules/brew_install.py

@@ -3,12 +3,11 @@ import os
 import re
 from subprocess import check_output
 
-import thefuck.logs
-
 # Formulars are base on each local system's status
 brew_formulas = []
 try:
-    brew_path_prefix = check_output(['brew', '--prefix']).strip()
+    brew_path_prefix = check_output(['brew', '--prefix'],
+                                    universal_newlines=True).strip()
     brew_formula_path = brew_path_prefix + '/Library/Formula'
 
     for file_name in os.listdir(brew_formula_path):

thefuck/rules/brew_unknown_command.py

@@ -2,7 +2,7 @@ import difflib
 import os
 import re
 import subprocess
-import thefuck.logs
+
 
 BREW_CMD_PATH = '/Library/Homebrew/cmd'
 TAP_PATH = '/Library/Taps'
@@ -10,26 +10,27 @@ TAP_CMD_PATH = '/%s/%s/cmd'
 
 
 def _get_brew_path_prefix():
-    '''To get brew path'''
+    """To get brew path"""
     try:
-        return subprocess.check_output(['brew', '--prefix']).strip()
+        return subprocess.check_output(['brew', '--prefix'],
+                                       universal_newlines=True).strip()
     except:
         return None
 
 
 def _get_brew_commands(brew_path_prefix):
-    '''To get brew default commands on local environment'''
+    """To get brew default commands on local environment"""
     brew_cmd_path = brew_path_prefix + BREW_CMD_PATH
 
-    commands = (name.replace('.rb', '') for name in os.listdir(brew_cmd_path)
-                if name.endswith('.rb'))
+    commands = [name.replace('.rb', '') for name in os.listdir(brew_cmd_path)
+                if name.endswith('.rb')]
 
     return commands
 
 
 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'''
+    """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
 
@@ -61,17 +62,20 @@ def _get_directory_names_only(path):
     return [d for d in os.listdir(path)
             if os.path.isdir(os.path.join(path, d))]
 
-brew_commands = []
+
 brew_path_prefix = _get_brew_path_prefix()
 
+# Failback commands for testing (Based on Homebrew 0.9.5)
+brew_commands = ['info', 'home', 'options', 'install', 'uninstall',
+                 'search', 'list', 'update', 'upgrade', 'pin', 'unpin',
+                 'doctor', 'create', 'edit']
+
 if brew_path_prefix:
-    brew_commands += _get_brew_commands(brew_path_prefix)
-    brew_commands += _get_brew_tap_specific_commands(brew_path_prefix)
-else:
-    # Failback commands for testing (Based on Homebrew 0.9.5)
-    brew_commands = ['info', 'home', 'options', 'install', 'uninstall',
-                     'search', 'list', 'update', 'upgrade', 'pin', 'unpin',
-                     'doctor', 'create', 'edit']
+    try:
+        brew_commands = _get_brew_commands(brew_path_prefix) \
+                        + _get_brew_tap_specific_commands(brew_path_prefix)
+    except OSError:
+        pass
 
 
 def _get_similar_commands(command):

thefuck/rules/cd_correction.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python
+__author__ = "mmussomele"
+
+"""Attempts to spellcheck and correct failed cd commands"""
+
+import os
+from difflib import get_close_matches
+from thefuck.utils import sudo_support
+from thefuck.rules import cd_mkdir
+
+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
+def match(command, settings):
+    """Match function copied from cd_mkdir.py"""
+    return (command.script.startswith('cd ')
+            and ('no such file or directory' in command.stderr.lower()
+                 or 'cd: can\'t cd to' in command.stderr.lower()))
+
+
+@sudo_support
+def get_new_command(command, settings):
+    """
+    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.split()[1].split(os.sep)
+    if dest[-1] == '':
+        dest = dest[:-1]
+    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, settings)
+    return "cd {0}".format(cwd)
+
+
+enabled_by_default = True

thefuck/rules/cd_mkdir.py

@@ -1,4 +1,5 @@
 import re
+from thefuck import shells
 from thefuck.utils import sudo_support
 
 
@@ -11,4 +12,5 @@ def match(command, settings):
 
 @sudo_support
 def get_new_command(command, settings):
-    return re.sub(r'^cd (.*)', 'mkdir -p \\1 && cd \\1', command.script)
+    repl = shells.and_('mkdir -p \\1', 'cd \\1')
+    return re.sub(r'^cd (.*)', repl, command.script)

thefuck/rules/cpp11.py

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

thefuck/rules/dry.py

@@ -0,0 +1,12 @@
+def match(command, settings):
+    split_command = command.script.split()
+
+    return len(split_command) >= 2 and split_command[0] == split_command[1]
+
+
+def get_new_command(command, settings):
+    return command.script[command.script.find(' ')+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/git_add.py

@@ -0,0 +1,17 @@
+import re
+from thefuck import shells
+
+
+def match(command, settings):
+    return ('git' in command.script
+            and 'did not match any file(s) known to git.' in command.stderr
+            and "Did you forget to 'git add'?" in command.stderr)
+
+
+def get_new_command(command, settings):
+    missing_file = re.findall(
+            r"error: pathspec '([^']*)' "
+            "did not match any file\(s\) known to git.", command.stderr)[0]
+
+    formatme = shells.and_('git add -- {}', '{}')
+    return formatme.format(missing_file, command.script)

thefuck/rules/git_checkout.py

@@ -0,0 +1,17 @@
+import re
+from thefuck import shells
+
+
+def match(command, settings):
+    return ('git' in command.script
+            and 'did not match any file(s) known to git.' in command.stderr
+            and "Did you forget to 'git add'?" not in command.stderr)
+
+
+def get_new_command(command, settings):
+    missing_file = re.findall(
+            r"error: pathspec '([^']*)' "
+            "did not match any file\(s\) known to git.", command.stderr)[0]
+
+    formatme = shells.and_('git branch {}', '{}')
+    return formatme.format(missing_file, command.script)

thefuck/rules/git_stash.py

@@ -0,0 +1,12 @@
+from thefuck import shells
+
+
+def match(command, settings):
+    # catches "Please commit or stash them" and "Please, commit your changes or
+    # stash them before you can switch branches."
+    return 'git' in command.script and 'or stash them' in command.stderr
+
+
+def get_new_command(command, settings):
+    formatme = shells.and_('git stash', '{}')
+    return formatme.format(command.script)

thefuck/rules/grep_recursive.py

@@ -0,0 +1,7 @@
+def match(command, settings):
+	return (command.script.startswith('grep')
+            and 'is a directory' in command.stderr.lower())
+
+
+def get_new_command(command, settings):
+    return 'grep -r {}'.format(command.script[5:])

thefuck/rules/man_no_space.py

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

thefuck/rules/no_command.py

@@ -31,3 +31,6 @@ def get_new_command(command, settings):
     new_command = get_close_matches(old_command,
                                     _get_all_bins())[0]
     return ' '.join([new_command] + command.script.split(' ')[1:])
+
+
+priority = 3000

thefuck/rules/no_such_file.py

@@ -0,0 +1,30 @@
+import re
+from thefuck import shells
+
+
+patterns = (
+    r"mv: cannot move '[^']*' to '([^']*)': No such file or directory",
+    r"mv: cannot move '[^']*' to '([^']*)': Not a directory",
+    r"cp: cannot create regular file '([^']*)': No such file or directory",
+    r"cp: cannot create regular file '([^']*)': Not a directory",
+)
+
+
+def match(command, settings):
+    for pattern in patterns:
+        if re.search(pattern, command.stderr):
+            return True
+
+    return False
+
+
+def get_new_command(command, settings):
+    for pattern in patterns:
+        file = re.findall(pattern, command.stderr)
+
+        if file:
+            file = file[0]
+            dir = file[0:file.rfind('/')]
+
+            formatme = shells.and_('mkdir -p {}', '{}')
+            return formatme.format(dir, command.script)

thefuck/rules/pacman.py

@@ -0,0 +1,34 @@
+import subprocess
+from thefuck.utils import DEVNULL, which
+from thefuck import shells
+
+
+def __get_pkgfile(command):
+    try:
+        return subprocess.check_output(
+            ['pkgfile', '-b', '-v', command.script.split(" ")[0]],
+            universal_newlines=True, stderr=DEVNULL
+        ).split()
+    except subprocess.CalledProcessError:
+        return None
+
+
+def match(command, settings):
+    return 'not found' in command.stderr and __get_pkgfile(command)
+
+
+def get_new_command(command, settings):
+    package = __get_pkgfile(command)[0]
+
+    formatme = shells.and_('{} -S {}', '{}')
+    return formatme.format(pacman, package, command.script)
+
+
+if not which('pkgfile'):
+    enabled_by_default = False
+elif which('yaourt'):
+    pacman = 'yaourt'
+elif which('pacman'):
+    pacman = 'sudo pacman'
+else:
+    enabled_by_default = False

thefuck/rules/whois.py

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+from six.moves.urllib.parse import urlparse
+
+
+def match(command, settings):
+    """
+    What the `whois` command returns depends on the 'Whois server' it contacted
+    and is not consistent through different servers. But there can be only two
+    types of errors I can think of with `whois`:
+        - `whois https://en.wikipedia.org/` → `whois en.wikipedia.org`;
+        - `whois en.wikipedia.org` → `whois wikipedia.org`.
+    So we match any `whois` command and then:
+        - if there is a slash: keep only the FQDN;
+        - if there is no slash but there is a point: removes the left-most
+          subdomain.
+
+    We cannot either remove all subdomains because we cannot know which part is
+    the subdomains and which is the domain, consider:
+        - www.google.fr → subdomain: www, domain: 'google.fr';
+        - google.co.uk → subdomain: None, domain; 'google.co.uk'.
+    """
+    return 'whois' in command.script
+
+
+def get_new_command(command, settings):
+    url = command.script.split()[1]
+
+    if '/' in command.script:
+        return 'whois ' + urlparse(url).netloc
+    elif '.' in command.script:
+        return 'whois ' + '.'.join(urlparse(url).path.split('.')[1:])

thefuck/shells.py

@@ -0,0 +1,185 @@
+"""Module with shell specific actions, each shell class should
+implement `from_shell`, `to_shell`, `app_alias` and `put_to_history`
+methods.
+
+"""
+from collections import defaultdict
+from subprocess import Popen, PIPE
+from time import time
+import os
+from psutil import Process
+from .utils import DEVNULL
+
+
+class Generic(object):
+    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):
+        return "\nalias fuck='eval $(thefuck $(fc -ln -1))'\n"
+
+    def _get_history_file_name(self):
+        return ''
+
+    def _get_history_line(self, command_script):
+        return ''
+
+    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:
+                history.write(self._get_history_line(command_script))
+
+    def and_(self, *commands):
+        return ' && '.join(commands)
+
+
+class Bash(Generic):
+    def app_alias(self):
+        return "\nalias fuck='eval $(thefuck $(fc -ln -1)); history -r'\n"
+
+    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
+
+    def _get_aliases(self):
+        proc = Popen('bash -ic alias', stdout=PIPE, stderr=DEVNULL, shell=True)
+        return dict(
+            self._parse_alias(alias)
+            for alias in proc.stdout.read().decode('utf-8').split('\n')
+            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)
+
+
+class Fish(Generic):
+    def app_alias(self):
+        return ("function fuck -d 'Correct your previous console command'\n"
+                "    set -l exit_code $status\n"
+                "    set -l eval_script"
+                " (mktemp 2>/dev/null ; or mktemp -t 'thefuck')\n"
+                "    set -l fucked_up_commandd $history[1]\n"
+                "    thefuck $fucked_up_commandd > $eval_script\n"
+                "    . $eval_script\n"
+                "    rm $eval_script\n"
+                "    if test $exit_code -ne 0\n"
+                "        history --delete $fucked_up_commandd\n"
+                "    end\n"
+                "end")
+
+    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 and_(self, *commands):
+        return '; and '.join(commands)
+
+
+class Zsh(Generic):
+    def app_alias(self):
+        return "\nalias fuck='eval $(thefuck $(fc -ln -1 | tail -n 1)); fc -R'\n"
+
+    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
+
+    def _get_aliases(self):
+        proc = Popen('zsh -ic alias', stdout=PIPE, stderr=DEVNULL, shell=True)
+        return dict(
+            self._parse_alias(alias)
+            for alias in proc.stdout.read().decode('utf-8').split('\n')
+            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)
+
+
+class Tcsh(Generic):
+    def app_alias(self):
+        return "\nalias fuck 'set fucked_cmd=`history -h 2 | head -n 1` && eval `thefuck ${fucked_cmd}`'\n"
+
+    def _parse_alias(self, alias):
+        name, value = alias.split("\t", 1)
+        return name, value
+
+    def _get_aliases(self):
+        proc = Popen('tcsh -ic alias', stdout=PIPE, stderr=DEVNULL, shell=True)
+        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)
+
+
+shells = defaultdict(lambda: Generic(), {
+    'bash': Bash(),
+    'fish': Fish(),
+    'zsh': Zsh(),
+    '-csh': Tcsh(),
+    'tcsh': Tcsh()})
+
+
+def _get_shell():
+    try:
+        shell = Process(os.getpid()).parent().cmdline()[0]
+    except TypeError:
+        shell = Process(os.getpid()).parent.cmdline[0]
+    return shells[os.path.basename(shell)]
+
+
+def from_shell(command):
+    return _get_shell().from_shell(command)
+
+
+def to_shell(command):
+    return _get_shell().to_shell(command)
+
+
+def app_alias():
+    print(_get_shell().app_alias())
+
+
+def put_to_history(command):
+    return _get_shell().put_to_history(command)
+
+
+def and_(*commands):
+    return _get_shell().and_(*commands)

thefuck/types.py

@@ -4,7 +4,8 @@ from collections import namedtuple
 Command = namedtuple('Command', ('script', 'stdout', 'stderr'))
 
 Rule = namedtuple('Rule', ('name', 'match', 'get_new_command',
-                           'enabled_by_default', 'side_effect'))
+                           'enabled_by_default', 'side_effect',
+                           'priority'))
 
 
 class RulesNamesList(list):

thefuck/utils.py

@@ -4,6 +4,9 @@ import six
 from .types import Command
 
 
+DEVNULL = open(os.devnull, 'w')
+
+
 def which(program):
     """Returns `program` path or `None`."""
 

tox.ini

@@ -0,0 +1,6 @@
+[tox]
+envlist = py27,py33,py34
+
+[testenv]
+deps = -rrequirements.txt
+commands = py.test