Bump to 3.20

#662: Autoconfigure when `fuck` was called < 60 seconds ago from the same shell

.travis.yml

@@ -1,10 +1,28 @@
 language: python
 sudo: false
-python:
-  - "3.5"
-  - "3.4"
-  - "3.3"
-  - "2.7"
+matrix:
+  include:
+    - os: linux
+      dist: trusty
+      python: "3.6"
+    - os: linux
+      dist: trusty
+      python: "3.5"
+    - os: linux
+      dist: trusty
+      python: "3.4"
+    - os: linux
+      dist: trusty
+      python: "3.3"
+    - os: linux
+      dist: trusty
+      python: "2.7"
+    - os: osx
+      env: FORMULA="python"
+      language: generic
+    - os: osx
+      env: FORMULA="python3"
+      language: generic
 services:
   - docker
 addons:
@@ -12,16 +30,22 @@ addons:
     packages:
       - python-commandnotfound
       - python3-commandnotfound
-install:
+before_install:
+  - if [[ $TRAVIS_OS_NAME == "osx" ]]; then brew update ; fi
+  - if [[ $TRAVIS_OS_NAME == "osx" ]]; then if brew ls --versions $FORMULA; then brew upgrade $FORMULA || echo Python is up to date; else brew install $FORMULA; fi; fi
+  - if [[ $TRAVIS_OS_NAME == "osx" ]]; then virtualenv venv -p $FORMULA; fi
+  - if [[ $TRAVIS_OS_NAME == "osx" ]]; then source venv/bin/activate; fi
   - pip install -U pip
   - pip install -U coveralls
+install:
   - pip install -Ur requirements.txt
   - python setup.py develop
   - rm -rf build
 script:
+  - flake8
   - export COVERAGE_PYTHON_VERSION=python-${TRAVIS_PYTHON_VERSION:0:1}
-  - export RUN_TESTS="coverage run --source=thefuck,tests -m py.test -v --capture=sys"
-  - if [[ $TRAVIS_PYTHON_VERSION == 3.5 ]]; then $RUN_TESTS --enable-functional; fi
-  - if [[ $TRAVIS_PYTHON_VERSION != 3.5 ]]; then $RUN_TESTS; fi
+  - export RUN_TESTS="coverage run --source=thefuck,tests -m py.test -v --capture=sys tests"
+  - if [[ $TRAVIS_PYTHON_VERSION == 3.6 && $TRAVIS_OS_NAME != "osx" ]]; then $RUN_TESTS --enable-functional; fi
+  - if [[ $TRAVIS_PYTHON_VERSION != 3.6 || $TRAVIS_OS_NAME == "osx" ]]; then $RUN_TESTS; fi
 after_success:
-  - coveralls
+  - if [[ $TRAVIS_PYTHON_VERSION == 3.6 && $TRAVIS_OS_NAME != "osx" ]]; then coveralls; fi

README.md

@@ -103,17 +103,16 @@ brew install thefuck
 ```
 
 On Ubuntu you can install `The Fuck` with:
- 
 ```bash
 sudo apt update
 sudo apt install python3-dev python3-pip
-sudo -H pip3 install thefuck
+sudo pip3 install thefuck
 ```
 
 On other systems you can install `The Fuck` with `pip`:
 
 ```bash
-sudo -H pip install thefuck
+pip install thefuck
 ```
 
 [Or using an OS package manager (OS X, Ubuntu, Arch).](https://github.com/nvbn/thefuck/wiki/Installation)
@@ -121,9 +120,9 @@ sudo -H pip install thefuck
 You should place this command in your `.bash_profile`, `.bashrc`, `.zshrc` or other startup script:
 
 ```bash
-eval "$(thefuck --alias)"
+eval $(thefuck --alias)
 # You can use whatever you want as an alias, like for Mondays:
-eval "$(thefuck --alias FUCK)"
+eval $(thefuck --alias FUCK)
 ```
 
 [Or in your shell config (Bash, Zsh, Fish, Powershell, tcsh).](https://github.com/nvbn/thefuck/wiki/Shell-aliases)
@@ -131,11 +130,16 @@ eval "$(thefuck --alias FUCK)"
 Changes will be available only in a new shell session.
 To make them available immediately, run `source ~/.bashrc` (or your shell config file like `.zshrc`).
 
+If you want separate alias for running fixed command without confirmation you can use alias like:
+
+```bash
+alias fuck-it='export THEFUCK_REQUIRE_CONFIRMATION=False; fuck; export THEFUCK_REQUIRE_CONFIRMATION=True'
+```
 
 ## Update
 
 ```bash
-sudo pip install thefuck --upgrade
+pip install thefuck --upgrade
 ```
 
 **Aliases changed in 1.34.**
@@ -145,6 +149,8 @@ sudo pip install thefuck --upgrade
 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:
 
+* `ag_literal` – adds `-Q` to `ag` when suggested;
+* `aws_cli` – fixes misspelled commands like `aws dynamdb scan`;
 * `cargo` – runs `cargo build` instead of `cargo`;
 * `cargo_no_command` – fixes wrongs commands like `cargo buid`;
 * `cd_correction` – spellchecks and correct failed cd commands;
@@ -160,58 +166,86 @@ using the matched rule and runs it. Rules enabled by default are as follows:
 * `django_south_merge` – adds `--merge` to inconsistent django south migration;
 * `docker_not_command` – fixes wrong docker commands like `docker tags`;
 * `dry` – fixes repetitions like `git git push`;
+* `fab_command_not_found` – fix misspelled fabric commands;
 * `fix_alt_space` – replaces Alt+Space with Space character;
 * `fix_file` – opens a file with an error in your `$EDITOR`;
+* `gem_unknown_command` – fixes wrong `gem` commands;
 * `git_add` – fixes *"pathspec 'foo' did not match any file(s) known to git."*;
+* `git_add_force` &ndash; adds `--force` to `git add <pathspec>...` when paths are .gitignore'd;
+* `git_bisect_usage` &ndash; fixes `git bisect strt`, `git bisect goood`, `git bisect rset`, etc. when bisecting;
 * `git_branch_delete` &ndash; changes `git branch -d` to `git branch -D`;
 * `git_branch_exists` &ndash; offers `git branch -d foo`, `git branch -D foo` or `git checkout foo` when creating a branch that already exists;
 * `git_branch_list` &ndash; catches `git branch list` in place of `git branch` and removes created branch;
 * `git_checkout` &ndash; fixes branch name or creates new branch;
+* `git_diff_no_index` &ndash; adds `--no-index` to previous `git diff` on untracked files;
 * `git_diff_staged` &ndash; adds `--staged` to previous `git diff` with unexpected output;
 * `git_fix_stash` &ndash; fixes `git stash` commands (misspelled subcommand and missing `save`);
+* `git_flag_after_filename` &ndash; fixes `fatal: bad flag '...' after filename`
 * `git_help_aliased` &ndash; fixes `git help <alias>` commands replacing <alias> with the aliased command;
 * `git_not_command` &ndash; fixes wrong git commands like `git brnch`;
 * `git_pull` &ndash; sets upstream before executing previous `git pull`;
 * `git_pull_clone` &ndash; clones instead of pulling when the repo does not exist;
+* `git_pull_uncommitted_changes` &ndash; stashes changes before pulling and pops them afterwards;
 * `git_push` &ndash; adds `--set-upstream origin $branch` to previous failed `git push`;
 * `git_push_pull` &ndash; runs `git pull` when `push` was rejected;
+* `git_push_without_commits` &ndash; Creates an initial commit if you forget and only `git add .`, when setting up a new project;
 * `git_rebase_no_changes` &ndash; runs `git rebase --skip` instead of `git rebase --continue` when there are no changes;
+* `git_rm_local_modifications` &ndash;  adds `-f` or `--cached` when you try to `rm` a locally modified file;
 * `git_rm_recursive` &ndash; adds `-r` when you try to `rm` a directory;
+* `git_rm_staged` &ndash;  adds `-f` or `--cached` when you try to `rm` a file with staged changes
+* `git_rebase_merge_dir` &ndash; offers `git rebase (--continue | --abort | --skip)` or removing the `.git/rebase-merge` dir when a rebase is in progress;
 * `git_remote_seturl_add` &ndash; runs `git remote add` when `git remote set_url` on nonexistant remote;
-* `git_stash` &ndash; stashes you local modifications before rebasing or switching branch;
+* `git_stash` &ndash; stashes your local modifications before rebasing or switching branch;
+* `git_stash_pop` &ndash; adds your local modifications before popping stash, then resets;
+* `git_tag_force` &ndash; adds `--force` to `git tag <tagname>` when the tag already exists;
 * `git_two_dashes` &ndash; adds a missing dash to commands like `git commit -amend` or `git rebase -continue`;
 * `go_run` &ndash; appends `.go` extension when compiling/running Go programs;
+* `gradle_no_task` &ndash; fixes not found or ambiguous `gradle` task;
+* `gradle_wrapper` &ndash; replaces `gradle` with `./gradlew`;
 * `grep_arguments_order` &ndash; fixes grep arguments order for situations like `grep -lir . test`;
 * `grep_recursive` &ndash; adds `-r` when you trying to `grep` directory;
+* `grunt_task_not_found` &ndash; fixes misspelled `grunt` commands;
 * `gulp_not_task` &ndash; fixes misspelled `gulp` tasks;
 * `has_exists_script` &ndash; prepends `./` when script/binary exists;
 * `heroku_not_command` &ndash; fixes wrong `heroku` commands like `heroku log`;
 * `history` &ndash; tries to replace command with most similar command from history;
+* `hostscli` &ndash; tries to fix `hostscli` usage;
+* `ifconfig_device_not_found` &ndash; fixes wrong device names like `wlan0` to `wlp2s0`;
 * `java` &ndash; removes `.java` extension when running Java programs;
 * `javac` &ndash; appends missing `.java` when compiling Java files;
 * `lein_not_task` &ndash; fixes wrong `lein` tasks like `lein rpl`;
 * `ln_no_hard_link` &ndash; catches hard link creation on directories, suggest symbolic link;
 * `ln_s_order` &ndash; fixes `ln -s` arguments order;
+* `ls_all` &ndash; adds `-A` to `ls` when output is empty;
 * `ls_lah` &ndash; adds `-lah` to `ls`;
 * `man` &ndash; changes manual section;
 * `man_no_space` &ndash; fixes man commands without spaces, for example `mandiff`;
 * `mercurial` &ndash; fixes wrong `hg` commands;
+* `missing_space_before_subcommand` &ndash; fixes command with missing space like `npminstall`;
 * `mkdir_p` &ndash; adds `-p` when you trying to create directory without parent;
 * `mvn_no_command` &ndash; adds `clean package` to `mvn`;
 * `mvn_unknown_lifecycle_phase` &ndash; fixes misspelled lifecycle phases with `mvn`;
+* `npm_missing_script` &ndash; fixes `npm` custom script name in `npm run-script <script>`;
+* `npm_run_script` &ndash; adds missing `run-script` for custom `npm` scripts;
 * `npm_wrong_command` &ndash; fixes wrong npm commands like `npm urgrade`;
 * `no_command` &ndash; fixes wrong console commands, for example `vom/vim`;
 * `no_such_file` &ndash; creates missing directories with `mv` and `cp` commands;
-* `open` &ndash; prepends `http` to address passed to `open`;
+* `open` &ndash; either prepends `http://` to address passed to `open` or create a new file or directory and passes it to `open`;
 * `pip_unknown_command` &ndash; fixes wrong `pip` commands, for example `pip instatl/pip install`;
+* `port_already_in_use` &ndash; kills process that bound port;
 * `python_command` &ndash; prepends `python` when you trying to run not executable/without `./` python script;
 * `python_execute` &ndash; appends missing `.py` when executing Python files;
 * `quotation_marks` &ndash; fixes uneven usage of `'` and `"` when containing args';
+* `path_from_history` &ndash; replaces not found path with similar absolute path from history;
+* `react_native_command_unrecognized` &ndash; fixes unrecognized `react-native` commands;
+* `remove_trailing_cedilla` &ndash; remove trailling cedillas `ç`, a common typo for european keyboard layouts;
 * `rm_dir` &ndash; adds `-rf` when you trying to remove directory;
+* `scm_correction` &ndash; corrects wrong scm like `hg log` to `git log`;
 * `sed_unterminated_s` &ndash; adds missing '/' to `sed`'s `s` commands;
 * `sl_ls` &ndash; changes `sl` to `ls`;
 * `ssh_known_hosts` &ndash; removes host from `known_hosts` on warning;
 * `sudo` &ndash; prepends `sudo` to previous command if it failed because of permissions;
+* `sudo_command_from_user_path` &ndash; runs commands from users `$PATH` with `sudo`;
 * `switch_lang` &ndash; switches command from your local layout to en;
 * `systemctl` &ndash; correctly orders parameters of confusing `systemctl`;
 * `test.py` &ndash; runs `py.test` instead of `test.py`;
@@ -221,7 +255,12 @@ using the matched rule and runs it. Rules enabled by default are as follows:
 * `tmux` &ndash; fixes `tmux` commands;
 * `unknown_command` &ndash; fixes hadoop hdfs-style "unknown command", for example adds missing '-' to the command on `hdfs dfs ls`;
 * `vagrant_up` &ndash; starts up the vagrant instance;
-* `whois` &ndash; fixes `whois` command.
+* `whois` &ndash; fixes `whois` command;
+* `workon_doesnt_exists` &ndash; fixes `virtualenvwrapper` env name os suggests to create new.
+* `yarn_alias` &ndash; fixes aliased `yarn` commands like `yarn ls`;
+* `yarn_command_not_found` &ndash; fixes misspelled `yarn` commands;
+* `yarn_command_replaced` &ndash; fixes replaced `yarn` commands;
+* `yarn_help` &ndash; makes it easier to open `yarn` documentation;
 
 Enabled by default only on specific platforms:
 
@@ -229,6 +268,8 @@ Enabled by default only on specific platforms:
 * `apt_get_search` &ndash; changes trying to search using `apt-get` with searching using `apt-cache`;
 * `apt_invalid_operation` &ndash; fixes invalid `apt` and `apt-get` calls, like `apt-get isntall vim`;
 * `brew_install` &ndash; fixes formula name for `brew install`;
+* `brew_link` &ndash; adds `--overwrite --dry-run` if linking fails;
+* `brew_uninstall` &ndash; adds `--force` to `brew uninstall` if multiple versions were installed;
 * `brew_unknown_command` &ndash; fixes wrong brew commands, for example `brew docto/brew doctor`;
 * `brew_update_formula` &ndash; turns `brew update <formula>` into `brew upgrade <formula>`;
 * `brew_upgrade` &ndash; appends `--all` to `brew upgrade` as per Homebrew's new behaviour;
@@ -257,7 +298,9 @@ side_effect(old_command: Command, fixed_command: str) -> None
 ```
 and optional `enabled_by_default`, `requires_output` and `priority` variables.
 
-`Command` has three attributes: `script`, `stdout` and `stderr`.
+`Command` has three attributes: `script`, `stdout`, `stderr` and `script_parts`.
+Rule shouldn't change `Command`.
+
 
 *Rules api changed in 3.0:* For accessing settings in rule you need to import it with `from thefuck.conf import settings`.
 `settings` is a special object filled with `~/.config/thefuck/settings.py` and values from env ([see more below](#settings)).
@@ -300,7 +343,9 @@ The Fuck has a few settings parameters which can be changed in `$XDG_CONFIG_HOME
 * `priority` &ndash; dict with rules priorities, rule with lower `priority` will be matched first;
 * `debug` &ndash; enables debug output, by default `False`;
 * `history_limit` &ndash; numeric value of how many history commands will be scanned, like `2000`;
-* `alter_history` &ndash; push fixed command to history, by default `True`.
+* `alter_history` &ndash; push fixed command to history, by default `True`;
+* `wait_slow_command` &ndash; max amount of time in seconds for getting previous command output if it in `slow_commands` list;
+* `slow_commands` &ndash; list of slow commands.
 
 Example of `settings.py`:
 
@@ -312,6 +357,9 @@ wait_command = 10
 no_colors = False
 priority = {'sudo': 100, 'no_command': 9999}
 debug = False
+history_limit = 9999
+wait_slow_command = 20
+slow_commands = ['react-native', 'gradle']
 ```
 
 Or via environment variables:
@@ -325,7 +373,9 @@ Or via environment variables:
 rule with lower `priority` will be matched first;
 * `THEFUCK_DEBUG` &ndash; enables debug output, `true/false`;
 * `THEFUCK_HISTORY_LIMIT` &ndash; how many history commands will be scanned, like `2000`;
-* `THEFUCK_ALTER_HISTORY` &ndash; push fixed command to history `true/false`.
+* `THEFUCK_ALTER_HISTORY` &ndash; push fixed command to history `true/false`;
+* `THEFUCK_WAIT_SLOW_COMMAND` &ndash; max amount of time in seconds for getting previous command output if it in `slow_commands` list;
+* `THEFUCK_SLOW_COMMANDS` &ndash; list of slow commands, like `lein:gradle`.
 
 For example:
 
@@ -348,6 +398,12 @@ pip install -r requirements.txt
 python setup.py develop
 ```
 
+Run code style checks:
+
+```bash
+flake8
+```
+
 Run unit tests:
 
 ```bash
@@ -373,9 +429,9 @@ Project License can be found [here](LICENSE.md).
 
 [version-badge]:   https://img.shields.io/pypi/v/thefuck.svg?label=version
 [version-link]:    https://pypi.python.org/pypi/thefuck/
-[travis-badge]:    https://img.shields.io/travis/nvbn/thefuck.svg
+[travis-badge]:    https://travis-ci.org/nvbn/thefuck.svg?branch=master
 [travis-link]:     https://travis-ci.org/nvbn/thefuck
-[appveyor-badge]:  https://img.shields.io/appveyor/ci/nvbn/thefuck.svg?label=windows%20build
+[appveyor-badge]:  https://ci.appveyor.com/api/projects/status/1sskj4imj02um0gu/branch/master?svg=true
 [appveyor-link]:   https://ci.appveyor.com/project/nvbn/thefuck
 [coverage-badge]:  https://img.shields.io/coveralls/nvbn/thefuck.svg
 [coverage-link]:   https://coveralls.io/github/nvbn/thefuck

appveyor.yml

@@ -6,6 +6,7 @@ environment:
     - PYTHON: "C:/Python33"
     - PYTHON: "C:/Python34"
     - PYTHON: "C:/Python35"
+    - PYTHON: "C:/Python36"
 
 init:
   - "ECHO %PYTHON%"
@@ -19,4 +20,5 @@ install:
   - "%PYTHON%/Scripts/pip.exe install -U -r requirements.txt"
 
 test_script:
+  - "%PYTHON%/python.exe -m flake8"
   - "%PYTHON%/Scripts/py.test.exe -sv"

requirements.txt

@@ -1,4 +1,5 @@
 pip
+flake8
 pytest
 mock
 pytest-mock

setup.py

@@ -1,13 +1,16 @@
 #!/usr/bin/env python
 from setuptools import setup, find_packages
-import pip
+import pkg_resources
 import sys
 import os
 
-if int(pip.__version__.split('.')[0]) < 6:
-    print('pip older than 6.0 not supported, please upgrade pip with:\n\n'
-          '    pip install -U pip')
-    sys.exit(-1)
+try:
+    if int(pkg_resources.get_distribution("pip").version.split('.')[0]) < 6:
+        print('pip older than 6.0 not supported, please upgrade pip with:\n\n'
+              '    pip install -U pip')
+        sys.exit(-1)
+except pkg_resources.DistributionNotFound:
+    pass
 
 if os.environ.get('CONVERT_README'):
     import pypandoc
@@ -26,7 +29,7 @@ elif (3, 0) < version < (3, 3):
           ' ({}.{} detected).'.format(*version))
     sys.exit(-1)
 
-VERSION = '3.10'
+VERSION = '3.20'
 
 install_requires = ['psutil', 'colorama', 'six', 'decorator']
 extras_require = {':python_version<"3.4"': ['pathlib2'],
@@ -48,5 +51,4 @@ setup(name='thefuck',
       extras_require=extras_require,
       entry_points={'console_scripts': [
           'thefuck = thefuck.main:main',
-          'thefuck-alias = thefuck.main:print_alias',
-          'fuck = thefuck.main:how_to_configure_alias']})
+          'fuck = thefuck.not_configured:main']})

tests/conftest.py

@@ -1,16 +1,14 @@
-try:
-    from pathlib import Path
-except ImportError:
-    from pathlib2 import Path
+import os
 import pytest
 from thefuck import shells
 from thefuck import conf, const
+from thefuck.system import Path
 
 shells.shell = shells.Generic()
 
 
 def pytest_addoption(parser):
-    """Adds `--run-without-docker` argument."""
+    """Adds `--enable-functional` argument."""
     group = parser.getgroup("thefuck")
     group.addoption('--enable-functional', action="store_true", default=False,
                     help="Enable functional tests")
@@ -59,7 +57,13 @@ def set_shell(monkeypatch, request):
     def _set(cls):
         shell = cls()
         monkeypatch.setattr('thefuck.shells.shell', shell)
-        request.addfinalizer()
         return shell
 
     return _set
+
+
+@pytest.fixture(autouse=True)
+def os_environ(monkeypatch):
+    env = {'PATH': os.environ['PATH']}
+    monkeypatch.setattr('os.environ', env)
+    return env

tests/functional/plots.py

@@ -81,6 +81,5 @@ def without_confirmation(proc, TIMEOUT):
 
 
 def how_to_configure(proc, TIMEOUT):
-    proc.sendline(u'unalias fuck')
     proc.sendline(u'fuck')
     assert proc.expect([TIMEOUT, u"alias isn't configured"])

tests/functional/test_bash.py

@@ -3,26 +3,19 @@ from tests.functional.plots import with_confirmation, without_confirmation, \
     refuse_with_confirmation, history_changed, history_not_changed, \
     select_command_with_arrows, how_to_configure
 
-containers = ((u'thefuck/ubuntu-python3-bash',
-               u'''FROM ubuntu:latest
-                   RUN apt-get update
-                   RUN apt-get install -yy python3 python3-pip python3-dev git
-                   RUN pip3 install -U setuptools
-                   RUN ln -s /usr/bin/pip3 /usr/bin/pip''',
+containers = ((u'thefuck/python3-bash',
+               u'FROM python:3',
                u'bash'),
-              (u'thefuck/ubuntu-python2-bash',
-               u'''FROM ubuntu:latest
-                   RUN apt-get update
-                   RUN apt-get install -yy python python-pip python-dev git
-                   RUN pip2 install -U pip setuptools''',
+              (u'thefuck/python2-bash',
+               u'FROM python:2',
                u'bash'))
 
 
 @pytest.fixture(params=containers)
-def proc(request, spawnu, run_without_docker):
+def proc(request, spawnu, TIMEOUT):
     proc = spawnu(*request.param)
-    if not run_without_docker:
-        proc.sendline(u"pip install /src")
+    proc.sendline(u"pip install /src")
+    assert proc.expect([TIMEOUT, u'Successfully installed'])
     proc.sendline(u"export PS1='$ '")
     proc.sendline(u'eval $(thefuck --alias)')
     proc.sendline(u'echo > $HISTFILE')
@@ -30,38 +23,30 @@ def proc(request, spawnu, run_without_docker):
 
 
 @pytest.mark.functional
-@pytest.mark.once_without_docker
-def test_with_confirmation(proc, TIMEOUT, run_without_docker):
+def test_with_confirmation(proc, TIMEOUT):
     with_confirmation(proc, TIMEOUT)
-    if not run_without_docker:
-        history_changed(proc, TIMEOUT, u'echo test')
+    history_changed(proc, TIMEOUT, u'echo test')
 
 
 @pytest.mark.functional
-@pytest.mark.once_without_docker
-def test_select_command_with_arrows(proc, TIMEOUT, run_without_docker):
+def test_select_command_with_arrows(proc, TIMEOUT):
     select_command_with_arrows(proc, TIMEOUT)
-    if not run_without_docker:
-        history_changed(proc, TIMEOUT, u'git help')
+    history_changed(proc, TIMEOUT, u'git help')
 
 
 @pytest.mark.functional
-@pytest.mark.once_without_docker
-def test_refuse_with_confirmation(proc, TIMEOUT, run_without_docker):
+def test_refuse_with_confirmation(proc, TIMEOUT):
     refuse_with_confirmation(proc, TIMEOUT)
-    if not run_without_docker:
-        history_not_changed(proc, TIMEOUT)
+    history_not_changed(proc, TIMEOUT)
 
 
 @pytest.mark.functional
-@pytest.mark.once_without_docker
-def test_without_confirmation(proc, TIMEOUT, run_without_docker):
+def test_without_confirmation(proc, TIMEOUT):
     without_confirmation(proc, TIMEOUT)
-    if not run_without_docker:
-        history_changed(proc, TIMEOUT, u'echo test')
+    history_changed(proc, TIMEOUT, u'echo test')
 
 
 @pytest.mark.functional
-@pytest.mark.once_without_docker
 def test_how_to_configure_alias(proc, TIMEOUT):
+    proc.sendline('unset -f fuck')
     how_to_configure(proc, TIMEOUT)

tests/functional/test_fish.py

@@ -2,52 +2,50 @@ import pytest
 from tests.functional.plots import with_confirmation, without_confirmation, \
     refuse_with_confirmation, select_command_with_arrows
 
-containers = (('thefuck/ubuntu-python3-fish',
-               u'''FROM ubuntu:latest
+containers = (('thefuck/python3-fish',
+               u'''FROM python:3
+                   # Use jessie-backports since it has the fish package. See here for details:
+                   # https://github.com/tianon/docker-brew-debian/blob/88ae21052affd8a14553bb969f9d41c464032122/jessie/backports/Dockerfile
+                   RUN awk '$1 ~ "^deb" { $3 = $3 "-backports"; print; exit }' /etc/apt/sources.list > /etc/apt/sources.list.d/backports.list
                    RUN apt-get update
-                   RUN apt-get install -yy python3 python3-pip python3-dev fish git
-                   RUN pip3 install -U setuptools
-                   RUN ln -s /usr/bin/pip3 /usr/bin/pip
                    RUN apt-get install -yy fish''',
                u'fish'),
-              ('thefuck/ubuntu-python2-fish',
-               u'''FROM ubuntu:latest
+              ('thefuck/python2-fish',
+               u'''FROM python:2
+                   # Use jessie-backports since it has the fish package. See here for details:
+                   # https://github.com/tianon/docker-brew-debian/blob/88ae21052affd8a14553bb969f9d41c464032122/jessie/backports/Dockerfile
+                   RUN awk '$1 ~ "^deb" { $3 = $3 "-backports"; print; exit }' /etc/apt/sources.list > /etc/apt/sources.list.d/backports.list
                    RUN apt-get update
-                   RUN apt-get install -yy python python-pip python-dev git
-                   RUN pip2 install -U pip setuptools
                    RUN apt-get install -yy fish''',
                u'fish'))
 
 
 @pytest.fixture(params=containers)
-def proc(request, spawnu):
+def proc(request, spawnu, TIMEOUT):
     proc = spawnu(*request.param)
     proc.sendline(u"pip install /src")
+    assert proc.expect([TIMEOUT, u'Successfully installed'])
     proc.sendline(u'thefuck --alias > ~/.config/fish/config.fish')
     proc.sendline(u'fish')
     return proc
 
 
 @pytest.mark.functional
-@pytest.mark.once_without_docker
 def test_with_confirmation(proc, TIMEOUT):
     with_confirmation(proc, TIMEOUT)
 
 
 @pytest.mark.functional
-@pytest.mark.once_without_docker
 def test_select_command_with_arrows(proc, TIMEOUT):
     select_command_with_arrows(proc, TIMEOUT)
 
 
 @pytest.mark.functional
-@pytest.mark.once_without_docker
 def test_refuse_with_confirmation(proc, TIMEOUT):
     refuse_with_confirmation(proc, TIMEOUT)
 
 
 @pytest.mark.functional
-@pytest.mark.once_without_docker
 def test_without_confirmation(proc, TIMEOUT):
     without_confirmation(proc, TIMEOUT)
 

tests/functional/test_performance.py

@@ -2,11 +2,7 @@ import pytest
 import time
 
 dockerfile = u'''
-FROM ubuntu:latest
-RUN apt-get update
-RUN apt-get install -yy python3 python3-pip python3-dev git
-RUN pip3 install -U setuptools
-RUN ln -s /usr/bin/pip3 /usr/bin/pip
+FROM python:3
 RUN adduser --disabled-password --gecos '' test
 ENV SEED "{seed}"
 WORKDIR /src
@@ -40,10 +36,9 @@ def plot(proc, TIMEOUT):
 
 
 @pytest.mark.functional
-@pytest.mark.once_without_docker
 @pytest.mark.benchmark(min_rounds=10)
 def test_performance(spawnu, TIMEOUT, benchmark):
-    proc = spawnu(u'thefuck/ubuntu-python3-bash-performance',
+    proc = spawnu(u'thefuck/python3-bash-performance',
                   dockerfile, u'bash')
     proc.sendline(u'pip install /src')
     proc.sendline(u'su test')

tests/functional/test_tcsh.py

@@ -2,28 +2,23 @@ import pytest
 from tests.functional.plots import with_confirmation, without_confirmation, \
     refuse_with_confirmation, select_command_with_arrows
 
-containers = (('thefuck/ubuntu-python3-tcsh',
-               u'''FROM ubuntu:latest
+containers = (('thefuck/python3-tcsh',
+               u'''FROM python:3
                    RUN apt-get update
-                   RUN apt-get install -yy python3 python3-pip python3-dev git
-                   RUN pip3 install -U setuptools
-                   RUN ln -s /usr/bin/pip3 /usr/bin/pip
                    RUN apt-get install -yy tcsh''',
                u'tcsh'),
-              ('thefuck/ubuntu-python2-tcsh',
-               u'''FROM ubuntu:latest
+              ('thefuck/python2-tcsh',
+               u'''FROM python:2
                    RUN apt-get update
-                   RUN apt-get install -yy python python-pip python-dev git
-                   RUN pip2 install -U pip setuptools
                    RUN apt-get install -yy tcsh''',
                u'tcsh'))
 
 
 @pytest.fixture(params=containers)
-def proc(request, spawnu, run_without_docker):
+def proc(request, spawnu, TIMEOUT):
     proc = spawnu(*request.param)
-    if not run_without_docker:
-        proc.sendline(u'pip install /src')
+    proc.sendline(u'pip install /src')
+    assert proc.expect([TIMEOUT, u'Successfully installed'])
     proc.sendline(u'tcsh')
     proc.sendline(u'setenv PYTHONIOENCODING utf8')
     proc.sendline(u'eval `thefuck --alias`')
@@ -31,25 +26,21 @@ def proc(request, spawnu, run_without_docker):
 
 
 @pytest.mark.functional
-@pytest.mark.once_without_docker
 def test_with_confirmation(proc, TIMEOUT):
     with_confirmation(proc, TIMEOUT)
 
 
 @pytest.mark.functional
-@pytest.mark.once_without_docker
 def test_select_command_with_arrows(proc, TIMEOUT):
     select_command_with_arrows(proc, TIMEOUT)
 
 
 @pytest.mark.functional
-@pytest.mark.once_without_docker
 def test_refuse_with_confirmation(proc, TIMEOUT):
     refuse_with_confirmation(proc, TIMEOUT)
 
 
 @pytest.mark.functional
-@pytest.mark.once_without_docker
 def test_without_confirmation(proc, TIMEOUT):
     without_confirmation(proc, TIMEOUT)
 

tests/functional/test_zsh.py

@@ -3,28 +3,23 @@ from tests.functional.plots import with_confirmation, without_confirmation, \
     refuse_with_confirmation, history_changed, history_not_changed, \
     select_command_with_arrows, how_to_configure
 
-containers = (('thefuck/ubuntu-python3-zsh',
-               u'''FROM ubuntu:latest
+containers = (('thefuck/python3-zsh',
+               u'''FROM python:3
                    RUN apt-get update
-                   RUN apt-get install -yy python3 python3-pip python3-dev git
-                   RUN pip3 install -U setuptools
-                   RUN ln -s /usr/bin/pip3 /usr/bin/pip
                    RUN apt-get install -yy zsh''',
                u'zsh'),
-              ('thefuck/ubuntu-python2-zsh',
-               u'''FROM ubuntu:latest
+              ('thefuck/python2-zsh',
+               u'''FROM python:2
                    RUN apt-get update
-                   RUN apt-get install -yy python python-pip python-dev git
-                   RUN pip2 install -U pip setuptools
                    RUN apt-get install -yy zsh''',
                u'zsh'))
 
 
 @pytest.fixture(params=containers)
-def proc(request, spawnu, run_without_docker):
+def proc(request, spawnu, TIMEOUT):
     proc = spawnu(*request.param)
-    if not run_without_docker:
-        proc.sendline(u'pip install /src')
+    proc.sendline(u'pip install /src')
+    assert proc.expect([TIMEOUT, u'Successfully installed'])
     proc.sendline(u'eval $(thefuck --alias)')
     proc.sendline(u'export HISTFILE=~/.zsh_history')
     proc.sendline(u'echo > $HISTFILE')
@@ -35,34 +30,30 @@ def proc(request, spawnu, run_without_docker):
 
 
 @pytest.mark.functional
-@pytest.mark.once_without_docker
 def test_with_confirmation(proc, TIMEOUT):
     with_confirmation(proc, TIMEOUT)
     history_changed(proc, TIMEOUT, u'echo test')
 
 
 @pytest.mark.functional
-@pytest.mark.once_without_docker
 def test_select_command_with_arrows(proc, TIMEOUT):
     select_command_with_arrows(proc, TIMEOUT)
     history_changed(proc, TIMEOUT, u'git help')
 
 
 @pytest.mark.functional
-@pytest.mark.once_without_docker
 def test_refuse_with_confirmation(proc, TIMEOUT):
     refuse_with_confirmation(proc, TIMEOUT)
     history_not_changed(proc, TIMEOUT)
 
 
 @pytest.mark.functional
-@pytest.mark.once_without_docker
 def test_without_confirmation(proc, TIMEOUT):
     without_confirmation(proc, TIMEOUT)
     history_changed(proc, TIMEOUT, u'echo test')
 
 
 @pytest.mark.functional
-@pytest.mark.once_without_docker
 def test_how_to_configure_alias(proc, TIMEOUT):
+    proc.sendline(u'unfunction fuck')
     how_to_configure(proc, TIMEOUT)

tests/rules/test_ag_literal.py

@@ -0,0 +1,25 @@
+import pytest
+from thefuck.rules.ag_literal import get_new_command, match
+from tests.utils import Command
+
+
+@pytest.fixture
+def stderr():
+    return ('ERR: Bad regex! pcre_compile() failed at position 1: missing )\n'
+            'If you meant to search for a literal string, run ag with -Q\n')
+
+
+@pytest.mark.parametrize('script', ['ag \('])
+def test_match(script, stderr):
+    assert match(Command(script=script, stderr=stderr))
+
+
+@pytest.mark.parametrize('script', ['ag foo'])
+def test_not_match(script):
+    assert not match(Command(script=script))
+
+
+@pytest.mark.parametrize('script, new_cmd', [
+    ('ag \(', 'ag -Q \(')])
+def test_get_new_command(script, new_cmd, stderr):
+    assert get_new_command((Command(script=script, stderr=stderr))) == new_cmd

tests/rules/test_apt_get.py

@@ -1,68 +1,43 @@
 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)
-
-
-@pytest.mark.parametrize('command, return_value', [
+@pytest.mark.parametrize('command, packages', [
     (Command(script='vim', stderr='vim: command not found'),
      [('vim', 'main'), ('vim-tiny', 'main')]),
     (Command(script='sudo vim', stderr='vim: command not found'),
+     [('vim', 'main'), ('vim-tiny', 'main')]),
+    (Command(script='vim', stderr="The program 'vim' is currently not installed. You can install it by typing: sudo apt install vim"),
      [('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)
+def test_match(mocker, command, packages):
+    mocker.patch('thefuck.rules.apt_get.which', return_value=None)
+    mock = mocker.patch('thefuck.rules.apt_get.command_not_found',
+                        create=True)
+    mock.getPackages.return_value = packages
+
     assert match(command)
-    assert cmdnf_mock.CommandNotFound.called
-    assert get_packages.called
 
 
-# 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='a_bad_cmd', stderr='a_bad_cmd: command not found'),
-    Command(script='vim', stderr=''), Command()])
-def test_not_match(command):
+@pytest.mark.parametrize('command, packages, which', [
+    (Command(script='a_bad_cmd', stderr='a_bad_cmd: command not found'),
+     [], None),
+    (Command(script='vim', stderr=''), [], None),
+    (Command(), [], None),
+    (Command(script='vim', stderr='vim: command not found'),
+     ['vim'], '/usr/bin/vim'),
+    (Command(script='sudo vim', stderr='vim: command not found'),
+     ['vim'], '/usr/bin/vim')])
+def test_not_match(mocker, command, packages, which):
+    mocker.patch('thefuck.rules.apt_get.which', return_value=which)
+    mock = mocker.patch('thefuck.rules.apt_get.command_not_found',
+                        create=True)
+    mock.getPackages.return_value = packages
+
     assert not match(command)
 
 
-@pytest.mark.parametrize('command, return_value', [
-    (Command(script='a_bad_cmd', stderr='a_bad_cmd: command not found'), []),
-    (Command(script='vim', stderr=''), []), (Command(), [])])
-@patch('thefuck.rules.apt_get.CommandNotFound', create=True)
-@patch.multiple(apt_get, create=True, apt_get='apt_get')
-def test_not_match_mocked(cmdnf_mock, command, return_value):
-    get_packages = Mock(return_value=return_value)
-    cmdnf_mock.CommandNotFound.return_value = Mock(getPackages=get_packages)
-    assert not match(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, new_command', [
-    (Command('vim'), 'sudo apt-get install vim && vim'),
-    (Command('convert'), 'sudo apt-get install imagemagick && convert'),
-    (Command('sudo vim'), 'sudo apt-get install vim && sudo vim'),
-    (Command('sudo convert'), 'sudo apt-get install imagemagick && sudo convert')])
-def test_get_new_command(command, new_command):
-    assert get_new_command(command) == new_command
-
-
-@pytest.mark.parametrize('command, new_command, return_value', [
+@pytest.mark.parametrize('command, new_command, packages', [
     (Command('vim'), 'sudo apt-get install vim && vim',
      [('vim', 'main'), ('vim-tiny', 'main')]),
     (Command('convert'), 'sudo apt-get install imagemagick && convert',
@@ -73,9 +48,8 @@ def test_get_new_command(command, new_command):
     (Command('sudo convert'), 'sudo apt-get install imagemagick && sudo 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)
+def test_get_new_command(mocker, command, new_command, packages):
+    mock = mocker.patch('thefuck.rules.apt_get.command_not_found',
+                        create=True)
+    mock.getPackages.return_value = packages
     assert get_new_command(command) == new_command

tests/rules/test_aws_cli.py

@@ -0,0 +1,101 @@
+import pytest
+
+from thefuck.rules.aws_cli import match, get_new_command
+from tests.utils import Command
+
+
+no_suggestions = '''\
+usage: aws [options] <command> <subcommand> [<subcommand> ...] [parameters]
+To see help text, you can run:
+
+  aws help
+  aws <command> help
+  aws <command> <subcommand> help
+aws: error: argument command: Invalid choice, valid choices are:
+
+dynamodb                                 | dynamodbstreams
+ec2                                      | ecr
+'''
+
+
+misspelled_command = '''\
+usage: aws [options] <command> <subcommand> [<subcommand> ...] [parameters]
+To see help text, you can run:
+
+  aws help
+  aws <command> help
+  aws <command> <subcommand> help
+aws: error: argument command: Invalid choice, valid choices are:
+
+dynamodb                                 | dynamodbstreams
+ec2                                      | ecr
+
+
+Invalid choice: 'dynamdb', maybe you meant:
+
+  * dynamodb
+'''
+
+
+misspelled_subcommand = '''\
+usage: aws [options] <command> <subcommand> [<subcommand> ...] [parameters]
+To see help text, you can run:
+
+  aws help
+  aws <command> help
+  aws <command> <subcommand> help
+aws: error: argument operation: Invalid choice, valid choices are:
+
+query                                    | scan
+update-item                              | update-table
+
+
+Invalid choice: 'scn', maybe you meant:
+
+  * scan
+'''
+
+
+misspelled_subcommand_with_multiple_options = '''\
+usage: aws [options] <command> <subcommand> [<subcommand> ...] [parameters]
+To see help text, you can run:
+
+  aws help
+  aws <command> help
+  aws <command> <subcommand> help
+aws: error: argument operation: Invalid choice, valid choices are:
+
+describe-table                           | get-item
+list-tables                              | put-item
+
+
+Invalid choice: 't-item', maybe you meant:
+
+  * put-item
+  * get-item
+'''
+
+
+@pytest.mark.parametrize('command', [
+    Command('aws dynamdb scan', stderr=misspelled_command),
+    Command('aws dynamodb scn', stderr=misspelled_subcommand),
+    Command('aws dynamodb t-item',
+            stderr=misspelled_subcommand_with_multiple_options)])
+def test_match(command):
+    assert match(command)
+
+
+def test_not_match():
+    assert not match(Command('aws dynamodb invalid', stderr=no_suggestions))
+
+
+@pytest.mark.parametrize('command, result', [
+    (Command('aws dynamdb scan', stderr=misspelled_command),
+     ['aws dynamodb scan']),
+    (Command('aws dynamodb scn', stderr=misspelled_subcommand),
+     ['aws dynamodb scan']),
+    (Command('aws dynamodb t-item',
+             stderr=misspelled_subcommand_with_multiple_options),
+     ['aws dynamodb put-item', 'aws dynamodb get-item'])])
+def test_get_new_command(command, result):
+    assert get_new_command(command) == result

tests/rules/test_brew_link.py

@@ -0,0 +1,38 @@
+import pytest
+from tests.utils import Command
+from thefuck.rules.brew_link import get_new_command, match
+
+
+@pytest.fixture
+def stderr():
+    return ("Error: Could not symlink bin/gcp\n"
+            "Target /usr/local/bin/gcp\n"
+            "already exists. You may want to remove it:\n"
+            "  rm '/usr/local/bin/gcp'\n"
+            "\n"
+            "To force the link and overwrite all conflicting files:\n"
+            "  brew link --overwrite coreutils\n"
+            "\n"
+            "To list all files that would be deleted:\n"
+            "  brew link --overwrite --dry-run coreutils\n")
+
+
+@pytest.fixture
+def new_command(formula):
+    return 'brew link --overwrite --dry-run {}'.format(formula)
+
+
+@pytest.mark.parametrize('script', ['brew link coreutils', 'brew ln coreutils'])
+def test_match(stderr, script):
+    assert match(Command(script=script, stderr=stderr))
+
+
+@pytest.mark.parametrize('script', ['brew link coreutils'])
+def test_not_match(script):
+    stderr = ''
+    assert not match(Command(script=script, stderr=stderr))
+
+
+@pytest.mark.parametrize('script, formula, ', [('brew link coreutils', 'coreutils')])
+def test_get_new_command(stderr, new_command, script, formula):
+    assert get_new_command(Command(script=script, stderr=stderr)) == new_command

tests/rules/test_brew_uninstall.py

@@ -0,0 +1,31 @@
+import pytest
+from tests.utils import Command
+from thefuck.rules.brew_uninstall import get_new_command, match
+
+
+@pytest.fixture
+def stdout():
+    return ("Uninstalling /usr/local/Cellar/tbb/4.4-20160916... (118 files, 1.9M)\n"
+            "tbb 4.4-20160526, 4.4-20160722 are still installed.\n"
+            "Remove all versions with `brew uninstall --force tbb`.\n")
+
+
+@pytest.fixture
+def new_command(formula):
+    return 'brew uninstall --force {}'.format(formula)
+
+
+@pytest.mark.parametrize('script', ['brew uninstall tbb', 'brew rm tbb', 'brew remove tbb'])
+def test_match(stdout, script):
+    assert match(Command(script=script, stdout=stdout))
+
+
+@pytest.mark.parametrize('script', ['brew remove gnuplot'])
+def test_not_match(script):
+    stdout = 'Uninstalling /usr/local/Cellar/gnuplot/5.0.4_1... (44 files, 2.3M)\n'
+    assert not match(Command(script=script, stdout=stdout))
+
+
+@pytest.mark.parametrize('script, formula, ', [('brew uninstall tbb', 'tbb')])
+def test_get_new_command(stdout, new_command, script, formula):
+    assert get_new_command(Command(script=script, stdout=stdout)) == new_command

tests/rules/test_brew_unknown_command.py

@@ -21,8 +21,8 @@ def test_match(brew_unknown_cmd):
 
 
 def test_get_new_command(brew_unknown_cmd, brew_unknown_cmd2):
-    assert get_new_command(Command('brew inst', stderr=brew_unknown_cmd)) \
-           == ['brew list', 'brew install', 'brew uninstall']
+    assert (get_new_command(Command('brew inst', stderr=brew_unknown_cmd))
+            == ['brew list', 'brew install', 'brew uninstall'])
 
     cmds = get_new_command(Command('brew instaa', stderr=brew_unknown_cmd2))
     assert 'brew install' in cmds

tests/rules/test_cargo_no_command.py

@@ -3,19 +3,26 @@ from thefuck.rules.cargo_no_command import match, get_new_command
 from tests.utils import Command
 
 
-no_such_subcommand = """No such subcommand
+no_such_subcommand_old = """No such subcommand
 
         Did you mean `build`?
 """
 
+no_such_subcommand = """error: no such subcommand
+
+\tDid you mean `build`?
+"""
+
 
 @pytest.mark.parametrize('command', [
-    Command(script='cargo buid', stderr=no_such_subcommand)])
+    Command(script='cargo buid', stderr=no_such_subcommand_old),
+    Command(script='cargo buils', stderr=no_such_subcommand)])
 def test_match(command):
     assert match(command)
 
 
 @pytest.mark.parametrize('command, new_command', [
-    (Command('cargo buid', stderr=no_such_subcommand), 'cargo build')])
+    (Command('cargo buid', stderr=no_such_subcommand_old), 'cargo build'),
+    (Command('cargo buils', stderr=no_such_subcommand), 'cargo build')])
 def test_get_new_command(command, new_command):
     assert get_new_command(command) == new_command

tests/rules/test_composer_not_command.py

@@ -48,9 +48,9 @@ def test_match(composer_not_command, composer_not_command_one_of_this):
 
 
 def test_get_new_command(composer_not_command, composer_not_command_one_of_this):
-    assert get_new_command(Command('composer udpate',
-                                   stderr=composer_not_command)) \
-           == 'composer update'
-    assert get_new_command(
-        Command('composer pdate', stderr=composer_not_command_one_of_this)) \
-           == 'composer selfupdate'
+    assert (get_new_command(Command('composer udpate',
+                                    stderr=composer_not_command))
+            == 'composer update')
+    assert (get_new_command(Command('composer pdate',
+                                    stderr=composer_not_command_one_of_this))
+            == 'composer selfupdate')

tests/rules/test_dirty_untar.py

@@ -2,7 +2,7 @@ import os
 import pytest
 import tarfile
 from thefuck.rules.dirty_untar import match, get_new_command, side_effect, \
-                                      tar_extensions
+                                      tar_extensions  # noqa: E126
 from tests.utils import Command
 
 
@@ -33,12 +33,12 @@ def tar_error(tmpdir):
 
     return fixture
 
+
 parametrize_extensions = pytest.mark.parametrize('ext', tar_extensions)
 
 # (filename as typed by the user, unquoted filename, quoted filename as per shells.quote)
 parametrize_filename = pytest.mark.parametrize('filename, unquoted, quoted', [
     ('foo{}', 'foo{}', 'foo{}'),
-    ('foo\ bar{}', 'foo bar{}', "'foo bar{}'"),
     ('"foo bar{}"', 'foo bar{}', "'foo bar{}'")])
 
 parametrize_script = pytest.mark.parametrize('script, fixed', [

tests/rules/test_dirty_unzip.py

@@ -64,7 +64,6 @@ def test_side_effect(zip_error, script, filename):
 @pytest.mark.parametrize('script,fixed,filename', [
     (u'unzip café', u"unzip café -d 'café'", u'café.zip'),
     (u'unzip foo', u'unzip foo -d foo', u'foo.zip'),
-    (u"unzip foo\\ bar.zip", u"unzip foo\\ bar.zip -d 'foo bar'", u'foo.zip'),
     (u"unzip 'foo bar.zip'", u"unzip 'foo bar.zip' -d 'foo bar'", u'foo.zip'),
     (u'unzip foo.zip', u'unzip foo.zip -d foo', u'foo.zip')])
 def test_get_new_command(zip_error, script, fixed, filename):

tests/rules/test_django_south_ghost.py

@@ -37,7 +37,7 @@ south.exceptions.GhostMigrations:
  ! I'm not trusting myself; either fix this yourself by fiddling
  ! with the south_migrationhistory table, or pass --delete-ghost-migrations
  ! to South to have it delete ALL of these records (this may not be good).
-'''
+'''  # noqa
 
 
 def test_match(stderr):

tests/rules/test_django_south_merge.py

@@ -39,5 +39,5 @@ def test_match(stderr):
 
 
 def test_get_new_command():
-    assert get_new_command(Command('./manage.py migrate auth')) \
-           == './manage.py migrate auth --merge'
+    assert (get_new_command(Command('./manage.py migrate auth'))
+            == './manage.py migrate auth --merge')

tests/rules/test_fab_command_not_found.py

@@ -0,0 +1,49 @@
+import pytest
+from thefuck.rules.fab_command_not_found import match, get_new_command
+from tests.utils import Command
+
+stderr = '''
+Warning: Command(s) not found:
+    extenson
+    deloyp
+'''
+stdout = '''
+Available commands:
+
+    update_config
+    prepare_extension
+    Template               A string class for supporting $-substitutions.
+    deploy
+    glob                   Return a list of paths matching a pathname pattern.
+    install_web
+    set_version
+'''
+
+
+@pytest.mark.parametrize('command', [
+    Command('fab extenson', stderr=stderr),
+    Command('fab deloyp', stderr=stderr),
+    Command('fab extenson deloyp', stderr=stderr)])
+def test_match(command):
+    assert match(command)
+
+
+@pytest.mark.parametrize('command', [
+    Command('gulp extenson', stderr=stderr),
+    Command('fab deloyp')])
+def test_not_match(command):
+    assert not match(command)
+
+
+@pytest.mark.parametrize('script, result', [
+    ('fab extenson', 'fab prepare_extension'),
+    ('fab extenson:version=2016',
+     'fab prepare_extension:version=2016'),
+    ('fab extenson:version=2016 install_web set_version:val=0.5.0',
+     'fab prepare_extension:version=2016 install_web set_version:val=0.5.0'),
+    ('fab extenson:version=2016 deloyp:beta=true -H the.fuck',
+     'fab prepare_extension:version=2016 deploy:beta=true -H the.fuck'),
+])
+def test_get_new_command(script, result):
+    command = Command(script, stdout, stderr)
+    assert get_new_command(command) == result

tests/rules/test_fix_alt_space.py

@@ -18,5 +18,5 @@ def test_match():
 
 def test_get_new_command():
     """ Replace the Alt+Space character by a simple space """
-    assert get_new_command(Command(u'ps -ef | grep foo'))\
-           == 'ps -ef | grep foo'
+    assert (get_new_command(Command(u'ps -ef | grep foo'))
+            == 'ps -ef | grep foo')

tests/rules/test_fix_file.py

@@ -191,7 +191,7 @@ E       NameError: name 'mocker' is not defined
 
 /home/thefuck/tests/rules/test_fix_file.py:218: NameError
 """, ''),
-)
+)  # noqa
 
 
 @pytest.mark.parametrize('test', tests)
@@ -227,10 +227,6 @@ def test_get_new_command(mocker, monkeypatch, test):
     mocker.patch('os.path.isfile', return_value=True)
     monkeypatch.setenv('EDITOR', 'dummy_editor')
 
-    cmd = Command(script=test[0], stdout=test[4], stderr=test[5])
-    #assert (get_new_command(cmd, Settings({})) ==
-    #    'dummy_editor {} +{} && {}'.format(test[1], test[2], test[0]))
-
 
 @pytest.mark.parametrize('test', tests)
 @pytest.mark.usefixtures('no_memoize')
@@ -243,7 +239,7 @@ def test_get_new_command_with_settings(mocker, monkeypatch, test, settings):
 
     if test[3]:
         assert (get_new_command(cmd) ==
-            u'dummy_editor {} +{}:{} && {}'.format(test[1], test[2], test[3], test[0]))
+                u'dummy_editor {} +{}:{} && {}'.format(test[1], test[2], test[3], test[0]))
     else:
         assert (get_new_command(cmd) ==
-            u'dummy_editor {} +{} && {}'.format(test[1], test[2], test[0]))
+                u'dummy_editor {} +{} && {}'.format(test[1], test[2], test[0]))

tests/rules/test_gem_unknown_command.py

@@ -0,0 +1,82 @@
+import pytest
+from six import BytesIO
+from thefuck.rules.gem_unknown_command import match, get_new_command
+from tests.utils import Command
+
+stderr = '''
+ERROR:  While executing gem ... (Gem::CommandLineError)
+    Unknown command {}
+'''
+
+gem_help_commands_stdout = b'''
+GEM commands are:
+
+    build             Build a gem from a gemspec
+    cert              Manage RubyGems certificates and signing settings
+    check             Check a gem repository for added or missing files
+    cleanup           Clean up old versions of installed gems
+    contents          Display the contents of the installed gems
+    dependency        Show the dependencies of an installed gem
+    environment       Display information about the RubyGems environment
+    fetch             Download a gem and place it in the current directory
+    generate_index    Generates the index files for a gem server directory
+    help              Provide help on the 'gem' command
+    install           Install a gem into the local repository
+    list              Display local gems whose name matches REGEXP
+    lock              Generate a lockdown list of gems
+    mirror            Mirror all gem files (requires rubygems-mirror)
+    open              Open gem sources in editor
+    outdated          Display all gems that need updates
+    owner             Manage gem owners of a gem on the push server
+    pristine          Restores installed gems to pristine condition from files
+                      located in the gem cache
+    push              Push a gem up to the gem server
+    query             Query gem information in local or remote repositories
+    rdoc              Generates RDoc for pre-installed gems
+    search            Display remote gems whose name matches REGEXP
+    server            Documentation and gem repository HTTP server
+    sources           Manage the sources and cache file RubyGems uses to search
+                      for gems
+    specification     Display gem specification (in yaml)
+    stale             List gems along with access times
+    uninstall         Uninstall gems from the local repository
+    unpack            Unpack an installed gem to the current directory
+    update            Update installed gems to the latest version
+    which             Find the location of a library file you can require
+    yank              Remove a pushed gem from the index
+
+For help on a particular command, use 'gem help COMMAND'.
+
+Commands may be abbreviated, so long as they are unambiguous.
+e.g. 'gem i rake' is short for 'gem install rake'.
+
+'''
+
+
+@pytest.fixture(autouse=True)
+def gem_help_commands(mocker):
+    patch = mocker.patch('subprocess.Popen')
+    patch.return_value.stdout = BytesIO(gem_help_commands_stdout)
+    return patch
+
+
+@pytest.mark.parametrize('script, command', [
+    ('gem isntall jekyll', 'isntall'),
+    ('gem last --local', 'last')])
+def test_match(script, command):
+    assert match(Command(script, stderr=stderr.format(command)))
+
+
+@pytest.mark.parametrize('script, stderr', [
+    ('gem install jekyll', ''),
+    ('git log', stderr.format('log'))])
+def test_not_match(script, stderr):
+    assert not match(Command(script, stderr=stderr))
+
+
+@pytest.mark.parametrize('script, stderr, result', [
+    ('gem isntall jekyll', stderr.format('isntall'), 'gem install jekyll'),
+    ('gem last --local', stderr.format('last'), 'gem list --local')])
+def test_get_new_command(script, stderr, result):
+    new_command = get_new_command(Command(script, stderr=stderr))
+    assert new_command[0] == result

tests/rules/test_git_add.py

@@ -3,6 +3,12 @@ from thefuck.rules.git_add import match, get_new_command
 from tests.utils import Command
 
 
+@pytest.fixture(autouse=True)
+def path_exists(mocker):
+    return mocker.patch('thefuck.rules.git_add.Path.exists',
+                        return_value=True)
+
+
 @pytest.fixture
 def stderr(target):
     return ("error: pathspec '{}' did not match any "
@@ -16,10 +22,13 @@ def test_match(stderr, script, target):
     assert match(Command(script=script, stderr=stderr))
 
 
-@pytest.mark.parametrize('script', [
-    'git submodule update known', 'git commit known'])
-def test_not_match(script):
-    assert not match(Command(script=script, stderr=''))
+@pytest.mark.parametrize('script, target, exists', [
+    ('git submodule update known', '', True),
+    ('git commit known', '', True),
+    ('git submodule update known', stderr, False)])
+def test_not_match(path_exists, stderr, script, target, exists):
+    path_exists.return_value = exists
+    assert not match(Command(script=script, stderr=stderr))
 
 
 @pytest.mark.parametrize('script, target, new_command', [

tests/rules/test_git_add_force.py

@@ -0,0 +1,22 @@
+import pytest
+from thefuck.rules.git_add_force import match, get_new_command
+from tests.utils import Command
+
+
+@pytest.fixture
+def stderr():
+    return ('The following paths are ignored by one of your .gitignore files:\n'
+            'dist/app.js\n'
+            'dist/background.js\n'
+            'dist/options.js\n'
+            'Use -f if you really want to add them.\n')
+
+
+def test_match(stderr):
+    assert match(Command('git add dist/*.js', stderr=stderr))
+    assert not match(Command('git add dist/*.js'))
+
+
+def test_get_new_command(stderr):
+    assert (get_new_command(Command('git add dist/*.js', stderr=stderr))
+            == "git add --force dist/*.js")

tests/rules/test_git_bisect_usage.py

@@ -0,0 +1,30 @@
+import pytest
+from tests.utils import Command
+from thefuck.rules.git_bisect_usage import match, get_new_command
+
+
+@pytest.fixture
+def stderr():
+    return ("usage: git bisect [help|start|bad|good|new|old"
+            "|terms|skip|next|reset|visualize|replay|log|run]")
+
+
+@pytest.mark.parametrize('script', [
+    'git bisect strt', 'git bisect rset', 'git bisect goood'])
+def test_match(stderr, script):
+    assert match(Command(script=script, stderr=stderr))
+
+
+@pytest.mark.parametrize('script', [
+    'git bisect', 'git bisect start', 'git bisect good'])
+def test_not_match(script):
+    assert not match(Command(script=script, stderr=''))
+
+
+@pytest.mark.parametrize('script, new_cmd, ', [
+    ('git bisect goood', ['good', 'old', 'log']),
+    ('git bisect strt', ['start', 'terms', 'reset']),
+    ('git bisect rset', ['reset', 'next', 'start'])])
+def test_get_new_command(stderr, script, new_cmd):
+    new_cmd = ['git bisect %s' % cmd for cmd in new_cmd]
+    assert get_new_command(Command(script=script, stderr=stderr)) == new_cmd

tests/rules/test_git_branch_exists.py

@@ -12,22 +12,23 @@ def stderr(branch_name):
 def new_command(branch_name):
     return [cmd.format(branch_name) for cmd in [
         'git branch -d {0} && git branch {0}',
-        'git branch -D {0} && git branch {0}', 'git checkout {0}']]
+        'git branch -d {0} && git checkout -b {0}',
+        'git branch -D {0} && git branch {0}',
+        'git branch -D {0} && git checkout -b {0}', 'git checkout {0}']]
 
 
 @pytest.mark.parametrize('script, branch_name', [
-    ('git branch foo', 'foo'),
-    ('git branch bar', 'bar')])
+    ('git branch foo', 'foo'), ('git checkout bar', 'bar')])
 def test_match(stderr, script, branch_name):
     assert match(Command(script=script, stderr=stderr))
 
 
-@pytest.mark.parametrize('script', ['git branch foo', 'git branch bar'])
+@pytest.mark.parametrize('script', ['git branch foo', 'git checkout bar'])
 def test_not_match(script):
     assert not match(Command(script=script, stderr=''))
 
 
 @pytest.mark.parametrize('script, branch_name, ', [
-    ('git branch foo', 'foo'), ('git branch bar', 'bar')])
+    ('git branch foo', 'foo'), ('git checkout bar', 'bar')])
 def test_get_new_command(stderr, new_command, script, branch_name):
     assert get_new_command(Command(script=script, stderr=stderr)) == new_command

tests/rules/test_git_diff_no_index.py

@@ -0,0 +1,23 @@
+import pytest
+from thefuck.rules.git_diff_no_index import match, get_new_command
+from tests.utils import Command
+
+
+@pytest.mark.parametrize('command', [
+    Command(script='git diff foo bar')])
+def test_match(command):
+    assert match(command)
+
+
+@pytest.mark.parametrize('command', [
+    Command(script='git diff --no-index foo bar'),
+    Command(script='git diff foo'),
+    Command(script='git diff foo bar baz')])
+def test_not_match(command):
+    assert not match(command)
+
+
+@pytest.mark.parametrize('command, new_command', [
+    (Command('git diff foo bar'), 'git diff --no-index foo bar')])
+def test_get_new_command(command, new_command):
+    assert get_new_command(command) == new_command

tests/rules/test_git_flag_after_filename.py

@@ -0,0 +1,31 @@
+import pytest
+from thefuck.rules.git_flag_after_filename import match, get_new_command
+from tests.utils import Command
+
+command1 = Command('git log README.md -p',
+                   stderr="fatal: bad flag '-p' used after filename")
+command2 = Command('git log README.md -p CONTRIBUTING.md',
+                   stderr="fatal: bad flag '-p' used after filename")
+command3 = Command('git log -p README.md --name-only',
+                   stderr="fatal: bad flag '--name-only' used after filename")
+
+
+@pytest.mark.parametrize('command', [
+    command1, command2, command3])
+def test_match(command):
+    assert match(command)
+
+
+@pytest.mark.parametrize('command', [
+    Command('git log README.md'),
+    Command('git log -p README.md')])
+def test_not_match(command):
+    assert not match(command)
+
+
+@pytest.mark.parametrize('command, result', [
+    (command1, "git log -p README.md"),
+    (command2, "git log -p README.md CONTRIBUTING.md"),
+    (command3, "git log -p --name-only README.md")])
+def test_get_new_command(command, result):
+    assert get_new_command(command) == result

tests/rules/test_git_not_command.py

@@ -7,7 +7,7 @@ from tests.utils import Command
 def git_not_command():
     return """git: 'brnch' is not a git command. See 'git --help'.
 
-Did you mean this?
+The most similar command is
 branch
 """
 
@@ -16,7 +16,7 @@ branch
 def git_not_command_one_of_this():
     return """git: 'st' is not a git command. See 'git --help'.
 
-Did you mean one of these?
+The most similar commands are
 status
 reset
 stage
@@ -29,7 +29,7 @@ stats
 def git_not_command_closest():
     return '''git: 'tags' is not a git command. See 'git --help'.
 
-Did you mean one of these?
+The most similar commands are
 \tstage
 \ttag
 '''
@@ -49,9 +49,9 @@ def test_match(git_not_command, git_command, git_not_command_one_of_this):
 
 def test_get_new_command(git_not_command, git_not_command_one_of_this,
                          git_not_command_closest):
-    assert get_new_command(Command('git brnch', stderr=git_not_command)) \
-           == ['git branch']
-    assert get_new_command(Command('git st', stderr=git_not_command_one_of_this)) \
-           == ['git stats', 'git stash', 'git stage']
-    assert get_new_command(Command('git tags', stderr=git_not_command_closest)) \
-           == ['git tag', 'git stage']
+    assert (get_new_command(Command('git brnch', stderr=git_not_command))
+            == ['git branch'])
+    assert (get_new_command(Command('git st', stderr=git_not_command_one_of_this))
+            == ['git stats', 'git stash', 'git stage'])
+    assert (get_new_command(Command('git tags', stderr=git_not_command_closest))
+            == ['git tag', 'git stage'])

tests/rules/test_git_pull.py

@@ -25,5 +25,5 @@ def test_match(stderr):
 
 
 def test_get_new_command(stderr):
-    assert get_new_command(Command('git pull', stderr=stderr)) \
-           == "git branch --set-upstream-to=origin/master master && git pull"
+    assert (get_new_command(Command('git pull', stderr=stderr))
+            == "git branch --set-upstream-to=origin/master master && git pull")

tests/rules/test_git_pull_uncommitted_changes.py

@@ -0,0 +1,19 @@
+import pytest
+from thefuck.rules.git_pull_uncommitted_changes import match, get_new_command
+from tests.utils import Command
+
+
+@pytest.fixture
+def stderr():
+    return '''error: Cannot pull with rebase: You have unstaged changes.'''
+
+
+def test_match(stderr):
+    assert match(Command('git pull', stderr=stderr))
+    assert not match(Command('git pull'))
+    assert not match(Command('ls', stderr=stderr))
+
+
+def test_get_new_command(stderr):
+    assert (get_new_command(Command('git pull', stderr=stderr))
+            == "git stash && git pull && git stash pop")

tests/rules/test_git_pull_unstaged_changes.py

@@ -0,0 +1,19 @@
+import pytest
+from thefuck.rules.git_pull_uncommitted_changes import match, get_new_command
+from tests.utils import Command
+
+
+@pytest.fixture
+def stderr():
+    return '''error: Cannot pull with rebase: Your index contains uncommitted changes.'''
+
+
+def test_match(stderr):
+    assert match(Command('git pull', stderr=stderr))
+    assert not match(Command('git pull'))
+    assert not match(Command('ls', stderr=stderr))
+
+
+def test_get_new_command(stderr):
+    assert (get_new_command(Command('git pull', stderr=stderr))
+            == "git stash && git pull && git stash pop")

tests/rules/test_git_push.py

@@ -14,6 +14,7 @@ To push the current branch and set the remote as upstream, use
 
 
 def test_match(stderr):
+    assert match(Command('git push', stderr=stderr))
     assert match(Command('git push master', stderr=stderr))
     assert not match(Command('git push master'))
     assert not match(Command('ls', stderr=stderr))
@@ -22,3 +23,11 @@ def test_match(stderr):
 def test_get_new_command(stderr):
     assert get_new_command(Command('git push', stderr=stderr))\
         == "git push --set-upstream origin master"
+    assert get_new_command(Command('git push -u', stderr=stderr))\
+        == "git push --set-upstream origin master"
+    assert get_new_command(Command('git push -u origin', stderr=stderr))\
+        == "git push --set-upstream origin master"
+    assert get_new_command(Command('git push --set-upstream origin', stderr=stderr))\
+        == "git push --set-upstream origin master"
+    assert get_new_command(Command('git push --quiet', stderr=stderr))\
+        == "git push --set-upstream origin master --quiet"

tests/rules/test_git_push_pull.py

@@ -13,6 +13,17 @@ To /tmp/foo
  hint: See the 'Note about fast-forwards' in 'git push --help' for details.
 '''
 
+git_err2 = '''
+To /tmp/foo
+ ! [rejected]        master -> master (non-fast-forward)
+ error: failed to push some refs to '/tmp/bar'
+hint: Updates were rejected because the remote contains work that you do
+hint: not have locally. This is usually caused by another repository pushing
+hint: to the same ref. You may want to first integrate the remote changes
+hint: (e.g., 'git pull ...') before pushing again.
+hint: See the 'Note about fast-forwards' in 'git push --help' for details.
+'''
+
 git_uptodate = 'Everything up-to-date'
 git_ok = '''
 Counting objects: 3, done.
@@ -28,7 +39,10 @@ To /tmp/bar
 @pytest.mark.parametrize('command', [
     Command(script='git push', stderr=git_err),
     Command(script='git push nvbn', stderr=git_err),
-    Command(script='git push nvbn master', stderr=git_err)])
+    Command(script='git push nvbn master', stderr=git_err),
+    Command(script='git push', stderr=git_err2),
+    Command(script='git push nvbn', stderr=git_err2),
+    Command(script='git push nvbn master', stderr=git_err2)])
 def test_match(command):
     assert match(command)
 
@@ -49,6 +63,11 @@ def test_not_match(command):
     (Command(script='git push nvbn', stderr=git_err),
      'git pull nvbn && git push nvbn'),
     (Command(script='git push nvbn master', stderr=git_err),
+     'git pull nvbn master && git push nvbn master'),
+    (Command(script='git push', stderr=git_err2), 'git pull && git push'),
+    (Command(script='git push nvbn', stderr=git_err2),
+     'git pull nvbn && git push nvbn'),
+    (Command(script='git push nvbn master', stderr=git_err2),
      'git pull nvbn master && git push nvbn master')])
 def test_get_new_command(command, output):
     assert get_new_command(command) == output

tests/rules/test_git_push_without_commits.py

@@ -0,0 +1,27 @@
+import pytest
+
+from tests.utils import Command
+from thefuck.rules.git_push_without_commits import (
+    fix,
+    get_new_command,
+    match,
+)
+
+command = 'git push -u origin master'
+expected_error = '''
+error: src refspec master does not match any.
+error: failed to push some refs to 'git@github.com:User/repo.git'
+'''
+
+
+@pytest.mark.parametrize('command', [Command(command, stderr=expected_error)])
+def test_match(command):
+    assert match(command)
+
+
+@pytest.mark.parametrize('command, result', [(
+    Command(command, stderr=expected_error),
+    fix.format(command=command),
+)])
+def test_get_new_command(command, result):
+    assert get_new_command(command) == result

tests/rules/test_git_rebase_merge_dir.py

@@ -0,0 +1,40 @@
+import pytest
+from thefuck.rules.git_rebase_merge_dir import match, get_new_command
+from tests.utils import Command
+
+
+@pytest.fixture
+def stderr():
+    return ('\n\nIt seems that there is already a rebase-merge directory, and\n'
+            'I wonder if you are in the middle of another rebase.  If that is the\n'
+            'case, please try\n'
+            '\tgit rebase (--continue | --abort | --skip)\n'
+            'If that is not the case, please\n'
+            '\trm -fr "/foo/bar/baz/egg/.git/rebase-merge"\n'
+            'and run me again.  I am stopping in case you still have something\n'
+            'valuable there.\n')
+
+
+@pytest.mark.parametrize('script', [
+    ('git rebase master'), ('git rebase -skip'), ('git rebase')])
+def test_match(stderr, script):
+    assert match(Command(script=script, stderr=stderr))
+
+
+@pytest.mark.parametrize('script', ['git rebase master', 'git rebase -abort'])
+def test_not_match(script):
+    assert not match(Command(script=script))
+
+
+@pytest.mark.parametrize('script, result', [
+    ('git rebase master', [
+        'git rebase --abort', 'git rebase --skip', 'git rebase --continue',
+        'rm -fr "/foo/bar/baz/egg/.git/rebase-merge"']),
+    ('git rebase -skip', [
+        'git rebase --skip', 'git rebase --abort', 'git rebase --continue',
+        'rm -fr "/foo/bar/baz/egg/.git/rebase-merge"']),
+    ('git rebase', [
+        'git rebase --skip', 'git rebase --abort', 'git rebase --continue',
+        'rm -fr "/foo/bar/baz/egg/.git/rebase-merge"'])])
+def test_get_new_command(stderr, script, result):
+    assert get_new_command(Command(script=script, stderr=stderr)) == result

tests/rules/test_git_remote_seturl_add.py

@@ -14,11 +14,11 @@ def test_match(command):
     Command('git remote add origin url'),
     Command('git remote remove origin'),
     Command('git remote prune origin'),
-    Command('git remote set-branches origin branch')
-    ])
+    Command('git remote set-branches origin branch')])
 def test_not_match(command):
     assert not match(command)
 
+
 @pytest.mark.parametrize('command, new_command', [
     (Command('git remote set-url origin git@github.com:nvbn/thefuck.git'),
      'git remote add origin git@github.com:nvbn/thefuck.git')])

tests/rules/test_git_rm_local_modifications.py

@@ -0,0 +1,28 @@
+import pytest
+from thefuck.rules.git_rm_local_modifications import match, get_new_command
+from tests.utils import Command
+
+
+@pytest.fixture
+def stderr(target):
+    return ('error: the following file has local modifications:\n    {}\n(use '
+            '--cached to keep the file, or -f to force removal)').format(target)
+
+
+@pytest.mark.parametrize('script, target', [
+    ('git rm foo', 'foo'),
+    ('git rm foo bar', 'bar')])
+def test_match(stderr, script, target):
+    assert match(Command(script=script, stderr=stderr))
+
+
+@pytest.mark.parametrize('script', ['git rm foo', 'git rm foo bar', 'git rm'])
+def test_not_match(script):
+    assert not match(Command(script=script, stderr=''))
+
+
+@pytest.mark.parametrize('script, target, new_command', [
+    ('git rm foo', 'foo', ['git rm --cached foo', 'git rm -f foo']),
+    ('git rm foo bar', 'bar', ['git rm --cached foo bar', 'git rm -f foo bar'])])
+def test_get_new_command(stderr, script, target, new_command):
+    assert get_new_command(Command(script=script, stderr=stderr)) == new_command

tests/rules/test_git_rm_staged.py

@@ -0,0 +1,28 @@
+import pytest
+from thefuck.rules.git_rm_staged import match, get_new_command
+from tests.utils import Command
+
+
+@pytest.fixture
+def stderr(target):
+    return ('error: the following file has changes staged in the index:\n    {}\n(use '
+            '--cached to keep the file, or -f to force removal)').format(target)
+
+
+@pytest.mark.parametrize('script, target', [
+    ('git rm foo', 'foo'),
+    ('git rm foo bar', 'bar')])
+def test_match(stderr, script, target):
+    assert match(Command(script=script, stderr=stderr))
+
+
+@pytest.mark.parametrize('script', ['git rm foo', 'git rm foo bar', 'git rm'])
+def test_not_match(script):
+    assert not match(Command(script=script, stderr=''))
+
+
+@pytest.mark.parametrize('script, target, new_command', [
+    ('git rm foo', 'foo', ['git rm --cached foo', 'git rm -f foo']),
+    ('git rm foo bar', 'bar', ['git rm --cached foo bar', 'git rm -f foo bar'])])
+def test_get_new_command(stderr, script, target, new_command):
+    assert get_new_command(Command(script=script, stderr=stderr)) == new_command

tests/rules/test_git_stash.py

@@ -4,14 +4,14 @@ from tests.utils import Command
 
 
 cherry_pick_error = (
-        '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')
+    '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')
 
 
 rebase_error = (
-        'Cannot rebase: Your index contains uncommitted changes.\n'
-        'Please commit or stash them.')
+    'Cannot rebase: Your index contains uncommitted changes.\n'
+    'Please commit or stash them.')
 
 
 @pytest.mark.parametrize('command', [

tests/rules/test_git_stash_pop.py

@@ -0,0 +1,18 @@
+import pytest
+from thefuck.rules.git_stash_pop import match, get_new_command
+from tests.utils import Command
+
+
+@pytest.fixture
+def stderr():
+    return '''error: Your local changes to the following files would be overwritten by merge:'''
+
+
+def test_match(stderr):
+    assert match(Command('git stash pop', stderr=stderr))
+    assert not match(Command('git stash'))
+
+
+def test_get_new_command(stderr):
+    assert (get_new_command(Command('git stash pop', stderr=stderr))
+            == "git add --update && git stash pop && git reset .")

tests/rules/test_git_tag_force.py

@@ -0,0 +1,18 @@
+import pytest
+from thefuck.rules.git_tag_force import match, get_new_command
+from tests.utils import Command
+
+
+@pytest.fixture
+def stderr():
+    return '''fatal: tag 'alert' already exists'''
+
+
+def test_match(stderr):
+    assert match(Command('git tag alert', stderr=stderr))
+    assert not match(Command('git tag alert'))
+
+
+def test_get_new_command(stderr):
+    assert (get_new_command(Command('git tag alert', stderr=stderr))
+            == "git tag --force alert")

tests/rules/test_gradle_not_task.py

@@ -0,0 +1,158 @@
+import pytest
+from io import BytesIO
+from thefuck.rules.gradle_no_task import match, get_new_command
+from tests.utils import Command
+
+gradle_tasks = b'''
+:tasks
+
+------------------------------------------------------------
+All tasks runnable from root project
+------------------------------------------------------------
+
+Android tasks
+-------------
+androidDependencies - Displays the Android dependencies of the project.
+signingReport - Displays the signing info for each variant.
+sourceSets - Prints out all the source sets defined in this project.
+
+Build tasks
+-----------
+assemble - Assembles all variants of all applications and secondary packages.
+assembleAndroidTest - Assembles all the Test applications.
+assembleDebug - Assembles all Debug builds.
+assembleRelease - Assembles all Release builds.
+build - Assembles and tests this project.
+buildDependents - Assembles and tests this project and all projects that depend on it.
+buildNeeded - Assembles and tests this project and all projects it depends on.
+compileDebugAndroidTestSources
+compileDebugSources
+compileDebugUnitTestSources
+compileReleaseSources
+compileReleaseUnitTestSources
+extractDebugAnnotations - Extracts Android annotations for the debug variant into the archive file
+extractReleaseAnnotations - Extracts Android annotations for the release variant into the archive file
+mockableAndroidJar - Creates a version of android.jar that's suitable for unit tests.
+
+Build Setup tasks
+-----------------
+init - Initializes a new Gradle build. [incubating]
+wrapper - Generates Gradle wrapper files. [incubating]
+
+Help tasks
+----------
+components - Displays the components produced by root project 'org.rerenderer_example.snake'. [incubating]
+dependencies - Displays all dependencies declared in root project 'org.rerenderer_example.snake'.
+dependencyInsight - Displays the insight into a specific dependency in root project 'org.rerenderer_example.snake'.
+help - Displays a help message.
+model - Displays the configuration model of root project 'org.rerenderer_example.snake'. [incubating]
+projects - Displays the sub-projects of root project 'org.rerenderer_example.snake'.
+properties - Displays the properties of root project 'org.rerenderer_example.snake'.
+tasks - Displays the tasks runnable from root project 'org.rerenderer_example.snake' (some of the displayed tasks may belong to subprojects).
+
+Install tasks
+-------------
+installDebug - Installs the Debug build.
+installDebugAndroidTest - Installs the android (on device) tests for the Debug build.
+installRelease - Installs the Release build.
+uninstallAll - Uninstall all applications.
+uninstallDebug - Uninstalls the Debug build.
+uninstallDebugAndroidTest - Uninstalls the android (on device) tests for the Debug build.
+uninstallRelease - Uninstalls the Release build.
+
+React tasks
+-----------
+bundleDebugJsAndAssets - bundle JS and assets for Debug.
+bundleReleaseJsAndAssets - bundle JS and assets for Release.
+
+Verification tasks
+------------------
+check - Runs all checks.
+clean - Deletes the build directory.
+connectedAndroidTest - Installs and runs instrumentation tests for all flavors on connected devices.
+connectedCheck - Runs all device checks on currently connected devices.
+connectedDebugAndroidTest - Installs and runs the tests for debug on connected devices.
+deviceAndroidTest - Installs and runs instrumentation tests using all Device Providers.
+deviceCheck - Runs all device checks using Device Providers and Test Servers.
+lint - Runs lint on all variants.
+lintDebug - Runs lint on the Debug build.
+lintRelease - Runs lint on the Release build.
+test - Run unit tests for all variants.
+testDebugUnitTest - Run unit tests for the debug build.
+testReleaseUnitTest - Run unit tests for the release build.
+
+Other tasks
+-----------
+assembleDefault
+copyDownloadableDepsToLibs
+jarDebugClasses
+jarReleaseClasses
+
+To see all tasks and more detail, run gradlew tasks --all
+
+To see more detail about a task, run gradlew help --task <task>
+
+BUILD SUCCESSFUL
+
+Total time: 1.936 secs
+'''
+
+stderr_not_found = '''
+
+FAILURE: Build failed with an exception.
+
+* What went wrong:
+Task '{}' not found in root project 'org.rerenderer_example.snake'.
+
+* Try:
+Run gradlew tasks to get a list of available tasks. Run with --stacktrace option to get the stack trace. Run with --info or --debug option to get more log output.
+'''.format
+
+stderr_ambiguous = '''
+
+FAILURE: Build failed with an exception.
+
+* What went wrong:
+Task '{}' is ambiguous in root project 'org.rerenderer_example.snake'. Candidates are: 'assembleRelease', 'assembleReleaseUnitTest'.
+
+* Try:
+Run gradlew tasks to get a list of available tasks. Run with --stacktrace option to get the stack trace. Run with --info or --debug option to get more log output.
+'''.format
+
+
+@pytest.fixture(autouse=True)
+def tasks(mocker):
+    patch = mocker.patch('thefuck.rules.gradle_no_task.Popen')
+    patch.return_value.stdout = BytesIO(gradle_tasks)
+    return patch
+
+
+@pytest.mark.parametrize('command', [
+    Command('./gradlew assembler', stderr=stderr_ambiguous('assembler')),
+    Command('./gradlew instar', stderr=stderr_not_found('instar')),
+    Command('gradle assembler', stderr=stderr_ambiguous('assembler')),
+    Command('gradle instar', stderr=stderr_not_found('instar'))])
+def test_match(command):
+    assert match(command)
+
+
+@pytest.mark.parametrize('command', [
+    Command('./gradlew assemble'),
+    Command('gradle assemble'),
+    Command('npm assembler', stderr=stderr_ambiguous('assembler')),
+    Command('npm instar', stderr=stderr_not_found('instar'))])
+def test_not_match(command):
+    assert not match(command)
+
+
+@pytest.mark.parametrize('command, result', [
+    (Command('./gradlew assembler', stderr=stderr_ambiguous('assembler')),
+     './gradlew assemble'),
+    (Command('./gradlew instardebug', stderr=stderr_not_found('instardebug')),
+     './gradlew installDebug'),
+    (Command('gradle assembler', stderr=stderr_ambiguous('assembler')),
+     'gradle assemble'),
+    (Command('gradle instardebug', stderr=stderr_not_found('instardebug')),
+     'gradle installDebug')])
+def test_get_new_command(command, result):
+    assert get_new_command(command)[0] == result

tests/rules/test_gradle_wrapper.py

@@ -0,0 +1,38 @@
+import pytest
+from thefuck.rules.gradle_wrapper import match, get_new_command
+from tests.utils import Command
+
+
+@pytest.fixture(autouse=True)
+def exists(mocker):
+    return mocker.patch('thefuck.rules.gradle_wrapper.os.path.isfile',
+                        return_value=True)
+
+
+@pytest.mark.parametrize('command', [
+    Command('gradle tasks', stderr='gradle: not found'),
+    Command('gradle build', stderr='gradle: not found')])
+def test_match(mocker, command):
+    mocker.patch('thefuck.rules.gradle_wrapper.which', return_value=None)
+
+    assert match(command)
+
+
+@pytest.mark.parametrize('command, gradlew, which', [
+    (Command('gradle tasks', stderr='gradle: not found'), False, None),
+    (Command('gradle tasks', stderr='command not found'), True, '/usr/bin/gradle'),
+    (Command('npm tasks', stderr='npm: not found'), True, None)])
+def test_not_match(mocker, exists, command, gradlew, which):
+    mocker.patch('thefuck.rules.gradle_wrapper.which', return_value=which)
+    exists.return_value = gradlew
+
+    assert not match(command)
+
+
+@pytest.mark.parametrize('script, result', [
+    ('gradle assemble', './gradlew assemble'),
+    ('gradle --help', './gradlew --help'),
+    ('gradle build -c', './gradlew build -c')])
+def test_get_new_command(script, result):
+    command = Command(script)
+    assert get_new_command(command) == result

tests/rules/test_grunt_task_not_found.py

@@ -0,0 +1,129 @@
+# -*- encoding: utf-8 -*-
+
+from io import BytesIO
+import pytest
+from tests.utils import Command
+from thefuck.rules.grunt_task_not_found import match, get_new_command
+
+stdout = '''
+Warning: Task "{}" not found. Use --force to continue.
+
+Aborted due to warnings.
+
+
+Execution Time (2016-08-13 21:01:40 UTC+3)
+loading tasks  11ms  ▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇ 92%
+Total 12ms
+
+'''.format
+
+grunt_help_stdout = b'''
+Grunt: The JavaScript Task Runner (v0.4.5)
+
+Usage
+ grunt [options] [task [task ...]]
+
+Options
+    --help, -h  Display this help text.
+        --base  Specify an alternate base path. By default, all file paths are
+                relative to the Gruntfile. (grunt.file.setBase) *
+    --no-color  Disable colored output.
+   --gruntfile  Specify an alternate Gruntfile. By default, grunt looks in the
+                current or parent directories for the nearest Gruntfile.js or
+                Gruntfile.coffee file.
+   --debug, -d  Enable debugging mode for tasks that support it.
+       --stack  Print a stack trace when exiting with a warning or fatal error.
+   --force, -f  A way to force your way past warnings. Want a suggestion? Don't
+                use this option, fix your code.
+       --tasks  Additional directory paths to scan for task and "extra" files.
+                (grunt.loadTasks) *
+         --npm  Npm-installed grunt plugins to scan for task and "extra" files.
+                (grunt.loadNpmTasks) *
+    --no-write  Disable writing files (dry run).
+ --verbose, -v  Verbose mode. A lot more information output.
+ --version, -V  Print the grunt version. Combine with --verbose for more info.
+  --completion  Output shell auto-completion rules. See the grunt-cli
+                documentation for more information.
+
+Options marked with * have methods exposed via the grunt API and should instead
+be specified inside the Gruntfile wherever possible.
+
+Available tasks
+  autoprefixer  Prefix CSS files. *
+    concurrent  Run grunt tasks concurrently *
+         clean  Clean files and folders. *
+       compass  Compile Sass to CSS using Compass *
+        concat  Concatenate files. *
+       connect  Start a connect web server. *
+          copy  Copy files. *
+        cssmin  Minify CSS *
+       htmlmin  Minify HTML *
+      imagemin  Minify PNG, JPEG, GIF and SVG images *
+        jshint  Validate files with JSHint. *
+        uglify  Minify files with UglifyJS. *
+         watch  Run predefined tasks whenever watched files change.
+       filerev  File revisioning based on content hashing *
+        cdnify  Replace scripts with refs to the Google CDN *
+         karma  run karma. *
+         newer  Run a task with only those source files that have been modified
+                since the last successful run.
+     any-newer  DEPRECATED TASK.  Use the "newer" task instead
+ newer-postrun  Internal task.
+   newer-clean  Remove cached timestamps.
+    ngAnnotate  Add, remove and rebuild AngularJS dependency injection
+                annotations *
+    ngconstant  Dynamic angular constant generator task. *
+        svgmin  Minify SVG *
+        usemin  Replaces references to non-minified scripts / stylesheets *
+ useminPrepare  Using HTML markup as the primary source of information *
+       wiredep  Inject Bower components into your source code. *
+         serve  Compile then start a connect web server
+        server  DEPRECATED TASK. Use the "serve" task instead
+          test  Alias for "clean:server", "ngconstant:test", "wiredep",
+                "concurrent:test", "autoprefixer", "connect:test", "karma"
+                tasks.
+         build  Alias for "ngconstant:production", "clean:dist", "wiredep",
+                "useminPrepare", "concurrent:dist", "autoprefixer", "concat",
+                "ngAnnotate", "copy:dist", "cdnify", "cssmin", "uglify",
+                "filerev", "usemin", "htmlmin" tasks.
+       default  Alias for "newer:jshint", "test", "build" tasks.
+
+Tasks run in the order specified. Arguments may be passed to tasks that accept
+them by using colons, like "lint:files". Tasks marked with * are "multi tasks"
+and will iterate over all sub-targets if no argument is specified.
+
+The list of available tasks may change based on tasks directories or grunt
+plugins specified in the Gruntfile or via command-line options.
+
+For more information, see http://gruntjs.com/
+'''
+
+
+@pytest.fixture(autouse=True)
+def grunt_help(mocker):
+    patch = mocker.patch('thefuck.rules.grunt_task_not_found.Popen')
+    patch.return_value.stdout = BytesIO(grunt_help_stdout)
+    return patch
+
+
+@pytest.mark.parametrize('command', [
+    Command('grunt defualt', stdout('defualt')),
+    Command('grunt buld:css', stdout('buld:css'))])
+def test_match(command):
+    assert match(command)
+
+
+@pytest.mark.parametrize('command', [
+    Command('npm nuild', stdout('nuild')),
+    Command('grunt rm')])
+def test_not_match(command):
+    assert not match(command)
+
+
+@pytest.mark.parametrize('command, result', [
+    (Command('grunt defualt', stdout('defualt')), 'grunt default'),
+    (Command('grunt cmpass:all', stdout('cmpass:all')), 'grunt compass:all'),
+    (Command('grunt cmpass:all --color', stdout('cmpass:all')),
+     'grunt compass:all --color')])
+def test_get_new_command(command, result):
+    assert get_new_command(command) == result

tests/rules/test_has_exists_script.py

@@ -7,7 +7,7 @@ def test_match():
     with patch('os.path.exists', return_value=True):
         assert match(Command(script='main', stderr='main: command not found'))
         assert match(Command(script='main --help',
-                          stderr='main: command not found'))
+                             stderr='main: command not found'))
         assert not match(Command(script='main', stderr=''))
 
     with patch('os.path.exists', return_value=False):

tests/rules/test_heroku_not_command.py

@@ -1,34 +1,31 @@
+# -*- coding: utf-8 -*-
+
 import pytest
 from tests.utils import Command
 from thefuck.rules.heroku_not_command import match, get_new_command
 
 
-def suggest_stderr(cmd):
-    return ''' !    `{}` is not a heroku command.
-     !    Perhaps you meant `logs`, `pg`.
-     !    See `heroku help` for a list of available commands.'''.format(cmd)
+suggest_stderr = '''
+ ▸    log is not a heroku command.
+ ▸    Perhaps you meant logs?
+ ▸    Run heroku _ to run heroku logs.
+ ▸    Run heroku help for a list of available commands.'''
 
 
-no_suggest_stderr = ''' !    `aaaaa` is not a heroku command.
- !    See `heroku help` for a list of available commands.'''
-
-
-@pytest.mark.parametrize('cmd', ['log', 'pge'])
+@pytest.mark.parametrize('cmd', ['log'])
 def test_match(cmd):
     assert match(
-        Command('heroku {}'.format(cmd), stderr=suggest_stderr(cmd)))
+        Command('heroku {}'.format(cmd), stderr=suggest_stderr))
 
 
 @pytest.mark.parametrize('script, stderr', [
-    ('cat log', suggest_stderr('log')),
-    ('heroku aaa', no_suggest_stderr)])
+    ('cat log', suggest_stderr)])
 def test_not_match(script, stderr):
     assert not match(Command(script, stderr=stderr))
 
 
 @pytest.mark.parametrize('cmd, result', [
-    ('log', ['heroku logs', 'heroku pg']),
-    ('pge', ['heroku pg', 'heroku logs'])])
+    ('log', 'heroku logs')])
 def test_get_new_command(cmd, result):
-    command = Command('heroku {}'.format(cmd), stderr=suggest_stderr(cmd))
+    command = Command('heroku {}'.format(cmd), stderr=suggest_stderr)
     assert get_new_command(command) == result

tests/rules/test_hostscli.py

@@ -0,0 +1,29 @@
+import pytest
+from thefuck.rules.hostscli import no_website, get_new_command, match
+from tests.utils import Command
+
+no_website_long = '''
+{}:
+
+No Domain list found for website: a_website_that_does_not_exist
+
+Please raise a Issue here: https://github.com/dhilipsiva/hostscli/issues/new
+if you think we should add domains for this website.
+
+type `hostscli websites` to see a list of websites that you can block/unblock
+'''.format(no_website)
+
+
+@pytest.mark.parametrize('command', [
+    Command('hostscli block a_website_that_does_not_exist',
+            stderr=no_website_long)])
+def test_match(command):
+    assert match(command)
+
+
+@pytest.mark.parametrize('command, result', [(
+    Command('hostscli block a_website_that_does_not_exist',
+            stderr=no_website_long),
+    ['hostscli websites'])])
+def test_get_new_command(command, result):
+    assert get_new_command(command) == result

tests/rules/test_ifconfig_device_not_found.py

@@ -0,0 +1,53 @@
+import pytest
+from six import BytesIO
+from thefuck.rules.ifconfig_device_not_found import match, get_new_command
+from tests.utils import Command
+
+
+stderr = '{}: error fetching interface information: Device not found'
+
+stdout = b'''
+wlp2s0    Link encap:Ethernet  HWaddr 5c:51:4f:7c:58:5d
+          inet addr:192.168.0.103  Bcast:192.168.0.255  Mask:255.255.255.0
+          inet6 addr: fe80::be23:69b9:96d2:6d39/64 Scope:Link
+          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
+          RX packets:23581604 errors:0 dropped:0 overruns:0 frame:0
+          TX packets:17017655 errors:0 dropped:0 overruns:0 carrier:0
+          collisions:0 txqueuelen:1000
+          RX bytes:16148429061 (16.1 GB)  TX bytes:7067533695 (7.0 GB)
+'''
+
+
+@pytest.fixture(autouse=True)
+def ifconfig(mocker):
+    mock = mocker.patch(
+        'thefuck.rules.ifconfig_device_not_found.subprocess.Popen')
+    mock.return_value.stdout = BytesIO(stdout)
+    return mock
+
+
+@pytest.mark.parametrize('script, stderr', [
+    ('ifconfig wlan0', stderr.format('wlan0')),
+    ('ifconfig -s eth0', stderr.format('eth0')),
+])
+def test_match(script, stderr):
+    assert match(Command(script, stderr=stderr))
+
+
+@pytest.mark.parametrize('script, stderr', [
+    ('config wlan0',
+     'wlan0: error fetching interface information: Device not found'),
+    ('ifconfig eth0', ''),
+])
+def test_not_match(script, stderr):
+    assert not match(Command(script, stderr=stderr))
+
+
+@pytest.mark.parametrize('script, result', [
+    ('ifconfig wlan0', ['ifconfig wlp2s0']),
+    ('ifconfig -s wlan0', ['ifconfig -s wlp2s0']),
+])
+def test_get_new_comman(script, result):
+    new_command = get_new_command(
+        Command(script, stderr=stderr.format('wlan0')))
+    assert new_command == result

tests/rules/test_lein_not_task.py

@@ -19,5 +19,5 @@ def test_match(is_not_task):
 
 
 def test_get_new_command(is_not_task):
-    assert get_new_command(Command(script='lein rpl --help', stderr=is_not_task)) \
-           == ['lein repl --help', 'lein jar --help']
+    assert (get_new_command(Command(script='lein rpl --help', stderr=is_not_task))
+            == ['lein repl --help', 'lein jar --help'])

tests/rules/test_ln_s_order.py

@@ -11,16 +11,6 @@ def file_exists(mocker):
 get_stderr = "ln: failed to create symbolic link '{}': File exists".format
 
 
-@pytest.mark.usefixtures('file_exists')
-@pytest.mark.parametrize('script', [
-    'ln -s dest source',
-    'ln dest -s source',
-    'ln dest source -s'])
-def test_match(script):
-    stderr = get_stderr('source')
-    assert match(Command(script, stderr=stderr))
-
-
 @pytest.mark.parametrize('script, stderr, exists', [
     ('ln dest source', get_stderr('source'), True),
     ('ls -s dest source', get_stderr('source'), True),
@@ -38,4 +28,5 @@ def test_not_match(file_exists, script, stderr, exists):
     ('ln dest source -s', 'ln source -s dest')])
 def test_match(script, result):
     stderr = get_stderr('source')
+    assert match(Command(script, stderr=stderr))
     assert get_new_command(Command(script, stderr=stderr)) == result

tests/rules/test_ls_all.py

@@ -0,0 +1,12 @@
+from thefuck.rules.ls_all import match, get_new_command
+from tests.utils import Command
+
+
+def test_match():
+    assert match(Command(script='ls'))
+    assert not match(Command(script='ls', stdout='file.py\n'))
+
+
+def test_get_new_command():
+    assert get_new_command(Command(script='ls empty_dir')) == 'ls -A empty_dir'
+    assert get_new_command(Command(script='ls')) == 'ls -A'

tests/rules/test_man.py

@@ -23,7 +23,8 @@ def test_not_match(command):
 
 
 @pytest.mark.parametrize('command, new_command', [
-    (Command('man read'), ['man 3 read', 'man 2 read']),
+    (Command('man read'), ['man 3 read', 'man 2 read', 'read --help']),
+    (Command('man missing', stderr="No manual entry for missing\n"), ['missing --help']),
     (Command('man 2 read'), 'man 3 read'),
     (Command('man 3 read'), 'man 2 read'),
     (Command('man -s2 read'), 'man -s3 read'),

tests/rules/test_missing_space_before_subcommand.py

@@ -0,0 +1,30 @@
+import pytest
+from thefuck.rules.missing_space_before_subcommand import (
+    match, get_new_command)
+from tests.utils import Command
+
+
+@pytest.fixture(autouse=True)
+def all_executables(mocker):
+    return mocker.patch(
+        'thefuck.rules.missing_space_before_subcommand.get_all_executables',
+        return_value=['git', 'ls', 'npm'])
+
+
+@pytest.mark.parametrize('script', [
+    'gitbranch', 'ls-la', 'npminstall'])
+def test_match(script):
+    assert match(Command(script))
+
+
+@pytest.mark.parametrize('script', ['git branch', 'vimfile'])
+def test_not_match(script):
+    assert not match(Command(script))
+
+
+@pytest.mark.parametrize('script, result', [
+    ('gitbranch', 'git branch'),
+    ('ls-la', 'ls -la'),
+    ('npminstall webpack', 'npm install webpack')])
+def test_get_new_command(script, result):
+    assert get_new_command(Command(script)) == result

tests/rules/test_mvn_no_command.py

@@ -25,7 +25,7 @@ def test_match(command):
 [INFO] Finished at: Wed Aug 26 13:05:47 BST 2015
 [INFO] Final Memory: 6M/240M
 [INFO] ------------------------------------------------------------------------
-"""),
+"""),  # noqa
     Command(script='mvn --help'),
     Command(script='mvn -v')
 ])

tests/rules/test_mvn_unknown_lifecycle_phase.py

@@ -25,7 +25,7 @@ def test_match(command):
 [INFO] Finished at: Wed Aug 26 13:05:47 BST 2015
 [INFO] Final Memory: 6M/240M
 [INFO] ------------------------------------------------------------------------
-"""),
+"""),  # noqa
     Command(script='mvn --help'),
     Command(script='mvn -v')
 ])

tests/rules/test_no_command.py

@@ -21,15 +21,20 @@ def history_without_current(mocker):
     ('vom file.py', 'vom: not found'),
     ('fucck', 'fucck: not found'),
     ('got commit', 'got: command not found')])
-def test_match(script, stderr):
+def test_match(mocker, script, stderr):
+    mocker.patch('thefuck.rules.no_command.which', return_value=None)
+
     assert match(Command(script, stderr=stderr))
 
 
 @pytest.mark.usefixtures('no_memoize')
-@pytest.mark.parametrize('script, stderr', [
-    ('qweqwe', 'qweqwe: not found'),
-    ('vom file.py', 'some text')])
-def test_not_match(script, stderr):
+@pytest.mark.parametrize('script, stderr, which', [
+    ('qweqwe', 'qweqwe: not found', None),
+    ('vom file.py', 'some text', None),
+    ('vim file.py', 'vim: not found', 'vim')])
+def test_not_match(mocker, script, stderr, which):
+    mocker.patch('thefuck.rules.no_command.which', return_value=which)
+
     assert not match(Command(script, stderr=stderr))
 
 

tests/rules/test_npm_missing_script.py

@@ -0,0 +1,69 @@
+import pytest
+from io import BytesIO
+from tests.utils import Command
+from thefuck.rules.npm_missing_script import match, get_new_command
+
+stderr = '''
+npm ERR! Linux 4.4.0-31-generic
+npm ERR! argv "/opt/node/bin/node" "/opt/node/bin/npm" "run" "dvelop"
+npm ERR! node v4.4.7
+npm ERR! npm  v2.15.8
+
+npm ERR! missing script: {}
+npm ERR!
+npm ERR! If you need help, you may report this error at:
+npm ERR!     <https://github.com/npm/npm/issues>
+
+npm ERR! Please include the following file with any support request:
+npm ERR!     /home/nvbn/exp/code_view/client_web/npm-debug.log
+'''.format
+
+run_script_stdout = b'''
+Lifecycle scripts included in code-view-web:
+  test
+    jest
+
+available via `npm run-script`:
+  build
+    cp node_modules/ace-builds/src-min/ -a resources/ace/ && webpack --progress --colors -p --config ./webpack.production.config.js
+  develop
+    cp node_modules/ace-builds/src/ -a resources/ace/ && webpack-dev-server --progress --colors
+  watch-test
+    jest --verbose --watch
+
+'''
+
+
+@pytest.fixture(autouse=True)
+def run_script(mocker):
+    patch = mocker.patch('thefuck.specific.npm.Popen')
+    patch.return_value.stdout = BytesIO(run_script_stdout)
+    return patch.return_value
+
+
+@pytest.mark.parametrize('command', [
+    Command('npm ru wach', stderr=stderr('wach')),
+    Command('npm run live-tes', stderr=stderr('live-tes')),
+    Command('npm run-script sahare', stderr=stderr('sahare'))])
+def test_match(command):
+    assert match(command)
+
+
+@pytest.mark.parametrize('command', [
+    Command('npm wach', stderr=stderr('wach')),
+    Command('vim live-tes', stderr=stderr('live-tes')),
+    Command('npm run-script sahare')])
+def test_not_match(command):
+    assert not match(command)
+
+
+@pytest.mark.parametrize('script, stderr, result', [
+    ('npm ru wach-tests', stderr('wach-tests'), 'npm ru watch-test'),
+    ('npm -i run-script dvelop', stderr('dvelop'),
+     'npm -i run-script develop'),
+    ('npm -i run-script buld -X POST', stderr('buld'),
+     'npm -i run-script build -X POST')])
+def test_get_new_command(script, stderr, result):
+    command = Command(script, stderr=stderr)
+
+    assert get_new_command(command)[0] == result

tests/rules/test_npm_run_script.py

@@ -0,0 +1,84 @@
+import pytest
+from io import BytesIO
+from thefuck.rules.npm_run_script import match, get_new_command
+from tests.utils import Command
+
+stdout = '''
+Usage: npm <command>
+
+where <command> is one of:
+    access, add-user, adduser, apihelp, author, bin, bugs, c,
+    cache, completion, config, ddp, dedupe, deprecate, dist-tag,
+    dist-tags, docs, edit, explore, faq, find, find-dupes, get,
+    help, help-search, home, i, info, init, install, issues, la,
+    link, list, ll, ln, login, logout, ls, outdated, owner,
+    pack, ping, prefix, prune, publish, r, rb, rebuild, remove,
+    repo, restart, rm, root, run-script, s, se, search, set,
+    show, shrinkwrap, star, stars, start, stop, t, tag, team,
+    test, tst, un, uninstall, unlink, unpublish, unstar, up,
+    update, upgrade, v, version, view, whoami
+
+npm <cmd> -h     quick help on <cmd>
+npm -l           display full usage info
+npm faq          commonly asked questions
+npm help <term>  search for help on <term>
+npm help npm     involved overview
+
+Specify configs in the ini-formatted file:
+    /home/nvbn/.npmrc
+or on the command line via: npm <command> --key value
+Config info can be viewed via: npm help config
+
+'''
+
+run_script_stdout = b'''
+Lifecycle scripts included in code-view-web:
+  test
+    jest
+
+available via `npm run-script`:
+  build
+    cp node_modules/ace-builds/src-min/ -a resources/ace/ && webpack --progress --colors -p --config ./webpack.production.config.js
+  develop
+    cp node_modules/ace-builds/src/ -a resources/ace/ && webpack-dev-server --progress --colors
+  watch-test
+    jest --verbose --watch
+
+'''
+
+
+@pytest.fixture(autouse=True)
+def run_script(mocker):
+    patch = mocker.patch('thefuck.specific.npm.Popen')
+    patch.return_value.stdout = BytesIO(run_script_stdout)
+    return patch.return_value
+
+
+@pytest.mark.usefixtures('no_memoize')
+@pytest.mark.parametrize('script', [
+    'npm watch-test', 'npm develop'])
+def test_match(script):
+    command = Command(script, stdout)
+    assert match(command)
+
+
+@pytest.mark.usefixtures('no_memoize')
+@pytest.mark.parametrize('command, run_script_out', [
+    (Command('npm test', 'TEST FAIL'), run_script_stdout),
+    (Command('npm watch-test', 'TEST FAIL'), run_script_stdout),
+    (Command('npm test', stdout), run_script_stdout),
+    (Command('vim watch-test', stdout), run_script_stdout)])
+def test_not_match(run_script, command, run_script_out):
+    run_script.stdout = BytesIO(run_script_out)
+    assert not match(command)
+
+
+@pytest.mark.usefixtures('no_memoize')
+@pytest.mark.parametrize('script, result', [
+    ('npm watch-test', 'npm run-script watch-test'),
+    ('npm -i develop', 'npm run-script -i develop'),
+    ('npm -i watch-script --path ..',
+     'npm run-script -i watch-script --path ..')])
+def test_get_new_command(script, result):
+    command = Command(script, stdout)
+    assert get_new_command(command) == result

tests/rules/test_open.py

@@ -1,31 +1,49 @@
 import pytest
-from thefuck.rules.open import match, get_new_command
+from thefuck.rules.open import is_arg_url, match, get_new_command
 from tests.utils import Command
 
 
-@pytest.mark.parametrize('command', [
-    Command(script='open foo.com'),
-    Command(script='open foo.ly'),
-    Command(script='open foo.org'),
-    Command(script='open foo.net'),
-    Command(script='open foo.se'),
-    Command(script='open foo.io'),
-    Command(script='xdg-open foo.com'),
-    Command(script='gnome-open foo.com'),
-    Command(script='kde-open foo.com')])
-def test_match(command):
-    assert match(command)
+@pytest.fixture
+def stderr(script):
+    return 'The file {} does not exist.\n'.format(script.split(' ', 1)[1])
 
 
-@pytest.mark.parametrize('command, new_command', [
-    (Command('open foo.com'), 'open http://foo.com'),
-    (Command('open foo.ly'), 'open http://foo.ly'),
-    (Command('open foo.org'), 'open http://foo.org'),
-    (Command('open foo.net'), 'open http://foo.net'),
-    (Command('open foo.se'), 'open http://foo.se'),
-    (Command('open foo.io'), 'open http://foo.io'),
-    (Command('xdg-open foo.io'), 'xdg-open http://foo.io'),
-    (Command('gnome-open foo.io'), 'gnome-open http://foo.io'),
-    (Command('kde-open foo.io'), 'kde-open http://foo.io')])
-def test_get_new_command(command, new_command):
-    assert get_new_command(command) == new_command
+@pytest.mark.parametrize('script', [
+    'open foo.com',
+    'open foo.edu',
+    'open foo.info',
+    'open foo.io',
+    'open foo.ly',
+    'open foo.me',
+    'open foo.net',
+    'open foo.org',
+    'open foo.se',
+    'open www.foo.ru'])
+def test_is_arg_url(script):
+    assert is_arg_url(Command(script))
+
+
+@pytest.mark.parametrize('script', ['open foo', 'open bar.txt', 'open egg.doc'])
+def test_not_is_arg_url(script):
+    assert not is_arg_url(Command(script))
+
+
+@pytest.mark.parametrize('script', [
+    'open foo.com',
+    'xdg-open foo.com',
+    'gnome-open foo.com',
+    'kde-open foo.com',
+    'open nonest'])
+def test_match(script, stderr):
+    assert match(Command(script, stderr=stderr))
+
+
+@pytest.mark.parametrize('script, new_command', [
+    ('open foo.io', ['open http://foo.io']),
+    ('xdg-open foo.io', ['xdg-open http://foo.io']),
+    ('gnome-open foo.io', ['gnome-open http://foo.io']),
+    ('kde-open foo.io', ['kde-open http://foo.io']),
+    ('open nonest', ['touch nonest && open nonest',
+                     'mkdir nonest && open nonest'])])
+def test_get_new_command(script, new_command, stderr):
+    assert get_new_command(Command(script, stderr=stderr)) == new_command

tests/rules/test_path_from_history.py

@@ -0,0 +1,43 @@
+import pytest
+from thefuck.rules.path_from_history import match, get_new_command
+from tests.utils import Command
+
+
+@pytest.fixture(autouse=True)
+def history(mocker):
+    return mocker.patch(
+        'thefuck.rules.path_from_history.get_valid_history_without_current',
+        return_value=['cd /opt/java', 'ls ~/work/project/'])
+
+
+@pytest.fixture(autouse=True)
+def path_exists(mocker):
+    path_mock = mocker.patch('thefuck.rules.path_from_history.Path')
+    exists_mock = path_mock.return_value.expanduser.return_value.exists
+    exists_mock.return_value = True
+    return exists_mock
+
+
+@pytest.mark.parametrize('script, stderr', [
+    ('ls project', 'no such file or directory: project'),
+    ('cd project', "can't cd to project"),
+])
+def test_match(script, stderr):
+    assert match(Command(script, stderr=stderr))
+
+
+@pytest.mark.parametrize('script, stderr', [
+    ('myapp cats', 'no such file or directory: project'),
+    ('cd project', ""),
+])
+def test_not_match(script, stderr):
+    assert not match(Command(script, stderr=stderr))
+
+
+@pytest.mark.parametrize('script, stderr, result', [
+    ('ls project', 'no such file or directory: project', 'ls ~/work/project'),
+    ('cd java', "can't cd to java", 'cd /opt/java'),
+])
+def test_get_new_command(script, stderr, result):
+    new_command = get_new_command(Command(script, stderr=stderr))
+    assert new_command[0] == result

tests/rules/test_port_already_in_use.py

@@ -0,0 +1,101 @@
+from io import BytesIO
+
+import pytest
+from thefuck.rules.port_already_in_use import match, get_new_command
+from tests.utils import Command
+
+outputs = [
+    '''
+
+DE 70% 1/1 build modulesevents.js:141
+      throw er; // Unhandled 'error' event
+      ^
+
+Error: listen EADDRINUSE 127.0.0.1:8080
+    at Object.exports._errnoException (util.js:873:11)
+    at exports._exceptionWithHostPort (util.js:896:20)
+    at Server._listen2 (net.js:1250:14)
+    at listen (net.js:1286:10)
+    at net.js:1395:9
+    at GetAddrInfoReqWrap.asyncCallback [as callback] (dns.js:64:16)
+    at GetAddrInfoReqWrap.onlookup [as oncomplete] (dns.js:83:10)
+
+    ''',
+    '''
+[6:40:01 AM] <START> Building Dependency Graph
+[6:40:01 AM] <START> Crawling File System
+ ERROR  Packager can't listen on port 8080
+Most likely another process is already using this port
+Run the following command to find out which process:
+
+   lsof -n -i4TCP:8080
+
+You can either shut down the other process:
+
+   kill -9 <PID>
+
+or run packager on different port.
+
+    ''',
+    '''
+Traceback (most recent call last):
+  File "/usr/lib/python3.5/runpy.py", line 184, in _run_module_as_main
+    "__main__", mod_spec)
+  File "/usr/lib/python3.5/runpy.py", line 85, in _run_code
+    exec(code, run_globals)
+  File "/home/nvbn/exp/code_view/server/code_view/main.py", line 14, in <module>
+    web.run_app(app)
+  File "/home/nvbn/.virtualenvs/code_view/lib/python3.5/site-packages/aiohttp/web.py", line 310, in run_app
+    backlog=backlog))
+  File "/usr/lib/python3.5/asyncio/base_events.py", line 373, in run_until_complete
+    return future.result()
+  File "/usr/lib/python3.5/asyncio/futures.py", line 274, in result
+    raise self._exception
+  File "/usr/lib/python3.5/asyncio/tasks.py", line 240, in _step
+    result = coro.send(None)
+  File "/usr/lib/python3.5/asyncio/base_events.py", line 953, in create_server
+    % (sa, err.strerror.lower()))
+OSError: [Errno 98] error while attempting to bind on address ('0.0.0.0', 8080): address already in use
+Task was destroyed but it is pending!
+task: <Task pending coro=<RedisProtocol._reader_coroutine() running at /home/nvbn/.virtualenvs/code_view/lib/python3.5/site-packages/asyncio_redis/protocol.py:921> wait_for=<Future pending cb=[Task._wakeup()]>>
+    '''
+]
+
+lsof_stdout = b'''COMMAND   PID USER   FD   TYPE DEVICE SIZE/OFF NODE NAME
+node    18233 nvbn   16u  IPv4 557134      0t0  TCP localhost:http-alt (LISTEN)
+'''
+
+
+@pytest.fixture(autouse=True)
+def lsof(mocker):
+    patch = mocker.patch('thefuck.rules.port_already_in_use.Popen')
+    patch.return_value.stdout = BytesIO(lsof_stdout)
+    return patch
+
+
+@pytest.mark.usefixtures('no_memoize')
+@pytest.mark.parametrize(
+    'command',
+    [Command('./app', stdout=output) for output in outputs]
+    + [Command('./app', stderr=output) for output in outputs])
+def test_match(command):
+    assert match(command)
+
+
+@pytest.mark.usefixtures('no_memoize')
+@pytest.mark.parametrize('command, lsof_output', [
+    (Command('./app'), lsof_stdout),
+    (Command('./app', stdout=outputs[1]), b''),
+    (Command('./app', stderr=outputs[2]), b'')])
+def test_not_match(lsof, command, lsof_output):
+    lsof.return_value.stdout = BytesIO(lsof_output)
+
+    assert not match(command)
+
+
+@pytest.mark.parametrize(
+    'command',
+    [Command('./app', stdout=output) for output in outputs]
+    + [Command('./app', stderr=output) for output in outputs])
+def test_get_new_command(command):
+    assert get_new_command(command) == 'kill 18233 && ./app'

tests/rules/test_python_command.py

@@ -8,5 +8,5 @@ def test_match():
 
 
 def test_get_new_command():
-    assert get_new_command(Command('./test_sudo.py'))\
-           == 'python ./test_sudo.py'
+    assert (get_new_command(Command('./test_sudo.py'))
+            == 'python ./test_sudo.py')

tests/rules/test_react_native_command_unrecognized.py

@@ -0,0 +1,46 @@
+import pytest
+from thefuck.rules.react_native_command_unrecognized import match, \
+    get_new_command
+from tests.utils import Command
+
+stderr = 'Command `{}` unrecognized'.format
+
+stdout = '''
+Usage: react-native <command>
+
+Commands:
+  - start: starts the webserver
+  - bundle: builds the javascript bundle for offline use
+  - unbundle: builds javascript as "unbundle" for offline use
+  - new-library: generates a native library bridge
+  - android: generates an Android project for your app
+  - run-android: builds your app and starts it on a connected Android emulator or device
+  - log-android: print Android logs
+  - run-ios: builds your app and starts it on iOS simulator
+  - log-ios: print iOS logs
+  - upgrade: upgrade your app's template files to the latest version; run this after updating the react-native version in your package.json and running npm install
+  - link: link a library
+'''
+
+
+@pytest.mark.parametrize('command', [
+    Command('react-native star', stderr=stderr('star')),
+    Command('react-native android-logs', stderr=stderr('android-logs'))])
+def test_match(command):
+    assert match(command)
+
+
+@pytest.mark.parametrize('command', [
+    Command('gradle star', stderr=stderr('star')),
+    Command('react-native start')])
+def test_not_match(command):
+    assert not match(command)
+
+
+@pytest.mark.parametrize('command, result', [
+    (Command('react-native star', stdout, stderr('star')),
+     'react-native start'),
+    (Command('react-native logsandroid -f', stdout, stderr('logsandroid')),
+     'react-native log-android -f')])
+def test_get_new_command(command, result):
+    assert get_new_command(command)[0] == result

tests/rules/test_remove_trailing_cedilla.py

@@ -0,0 +1,17 @@
+import pytest
+from thefuck.rules.remove_trailing_cedilla import match, get_new_command, CEDILLA
+from tests.utils import Command
+
+
+@pytest.mark.parametrize('command', [
+    Command(script='wrong' + CEDILLA),
+    Command(script='wrong with args' + CEDILLA)])
+def test_match(command):
+    assert match(command)
+
+
+@pytest.mark.parametrize('command, new_command', [
+    (Command('wrong' + CEDILLA), 'wrong'),
+    (Command('wrong with args' + CEDILLA), 'wrong with args')])
+def test_get_new_command(command, new_command):
+    assert get_new_command(command) == new_command

tests/rules/test_rm_root.py

@@ -17,5 +17,5 @@ def test_not_match(command):
 
 
 def test_get_new_command():
-    assert get_new_command(Command(script='rm -rf /')) \
-           == 'rm -rf / --no-preserve-root'
+    assert (get_new_command(Command(script='rm -rf /'))
+            == 'rm -rf / --no-preserve-root')

tests/rules/test_scm_correction.py

@@ -0,0 +1,46 @@
+import pytest
+from thefuck.rules.scm_correction import match, get_new_command
+from tests.utils import Command
+
+
+@pytest.fixture
+def get_actual_scm_mock(mocker):
+    return mocker.patch('thefuck.rules.scm_correction._get_actual_scm',
+                        return_value=None)
+
+
+@pytest.mark.parametrize('script, stderr, actual_scm', [
+    ('git log', 'fatal: Not a git repository '
+                '(or any of the parent directories): .git',
+     'hg'),
+    ('hg log', "abort: no repository found in '/home/nvbn/exp/thefuck' "
+               "(.hg not found)!",
+     'git')])
+def test_match(get_actual_scm_mock, script, stderr, actual_scm):
+    get_actual_scm_mock.return_value = actual_scm
+    assert match(Command(script, stderr=stderr))
+
+
+@pytest.mark.parametrize('script, stderr, actual_scm', [
+    ('git log', '', 'hg'),
+    ('git log', 'fatal: Not a git repository '
+                '(or any of the parent directories): .git',
+     None),
+    ('hg log', "abort: no repository found in '/home/nvbn/exp/thefuck' "
+               "(.hg not found)!",
+     None),
+    ('not-scm log', "abort: no repository found in '/home/nvbn/exp/thefuck' "
+                    "(.hg not found)!",
+     'git')])
+def test_not_match(get_actual_scm_mock, script, stderr, actual_scm):
+    get_actual_scm_mock.return_value = actual_scm
+    assert not match(Command(script, stderr=stderr))
+
+
+@pytest.mark.parametrize('script, actual_scm, result', [
+    ('git log', 'hg', 'hg log'),
+    ('hg log', 'git', 'git log')])
+def test_get_new_command(get_actual_scm_mock, script, actual_scm, result):
+    get_actual_scm_mock.return_value = actual_scm
+    new_command = get_new_command(Command(script))
+    assert new_command == result

tests/rules/test_sed_unterminated_s.py

@@ -18,11 +18,11 @@ def test_match(sed_unterminated_s):
 
 
 def test_get_new_command(sed_unterminated_s):
-    assert get_new_command(Command('sed -e s/foo/bar', stderr=sed_unterminated_s)) \
-            == 'sed -e s/foo/bar/'
-    assert get_new_command(Command('sed -es/foo/bar', stderr=sed_unterminated_s)) \
-            == 'sed -es/foo/bar/'
-    assert get_new_command(Command(r"sed -e 's/\/foo/bar'", stderr=sed_unterminated_s)) \
-            == r"sed -e 's/\/foo/bar/'"
-    assert get_new_command(Command(r"sed -e s/foo/bar -es/baz/quz", stderr=sed_unterminated_s)) \
-            == r"sed -e s/foo/bar/ -es/baz/quz/"
+    assert (get_new_command(Command('sed -e s/foo/bar', stderr=sed_unterminated_s))
+            == 'sed -e s/foo/bar/')
+    assert (get_new_command(Command('sed -es/foo/bar', stderr=sed_unterminated_s))
+            == 'sed -es/foo/bar/')
+    assert (get_new_command(Command(r"sed -e 's/\/foo/bar'", stderr=sed_unterminated_s))
+            == r"sed -e 's/\/foo/bar/'")
+    assert (get_new_command(Command(r"sed -e s/foo/bar -es/baz/quz", stderr=sed_unterminated_s))
+            == r"sed -e s/foo/bar/ -es/baz/quz/")

tests/rules/test_sudo_command_from_user_path.py

@@ -0,0 +1,39 @@
+import pytest
+from thefuck.rules.sudo_command_from_user_path import match, get_new_command
+from tests.utils import Command
+
+
+stderr = 'sudo: {}: command not found'
+
+
+@pytest.fixture(autouse=True)
+def which(mocker):
+    return mocker.patch('thefuck.rules.sudo_command_from_user_path.which',
+                        return_value='/usr/bin/app')
+
+
+@pytest.mark.parametrize('script, stderr', [
+    ('sudo npm install -g react-native-cli', stderr.format('npm')),
+    ('sudo -u app appcfg update .', stderr.format('appcfg'))])
+def test_match(script, stderr):
+    assert match(Command(script, stderr=stderr))
+
+
+@pytest.mark.parametrize('script, stderr, which_result', [
+    ('npm --version', stderr.format('npm'), '/usr/bin/npm'),
+    ('sudo npm --version', '', '/usr/bin/npm'),
+    ('sudo npm --version', stderr.format('npm'), None)])
+def test_not_match(which, script, stderr, which_result):
+    which.return_value = which_result
+    assert not match(Command(script, stderr=stderr))
+
+
+@pytest.mark.parametrize('script, stderr, result', [
+    ('sudo npm install -g react-native-cli',
+     stderr.format('npm'),
+     'sudo env "PATH=$PATH" npm install -g react-native-cli'),
+    ('sudo -u app appcfg update .',
+     stderr.format('appcfg'),
+     'sudo -u app env "PATH=$PATH" appcfg update .')])
+def test_get_new_command(script, stderr, result):
+    assert get_new_command(Command(script, stderr=stderr)) == result

tests/rules/test_unknown_command.py

@@ -23,12 +23,12 @@ def test_not_match(command):
 
 @pytest.mark.parametrize('command, new_command', [
     (Command('hdfs dfs ls',
-        stderr='ls: Unknown command\nDid you mean -ls?  This command begins with a dash.'), ['hdfs dfs -ls']),
+             stderr='ls: Unknown command\nDid you mean -ls?  This command begins with a dash.'), ['hdfs dfs -ls']),
     (Command('hdfs dfs rm /foo/bar',
-        stderr='rm: Unknown command\nDid you mean -rm?  This command begins with a dash.'), ['hdfs dfs -rm /foo/bar']),
+             stderr='rm: Unknown command\nDid you mean -rm?  This command begins with a dash.'), ['hdfs dfs -rm /foo/bar']),
     (Command('./bin/hdfs dfs ls -R /foo/bar',
-        stderr='ls: Unknown command\nDid you mean -ls?  This command begins with a dash.'), ['./bin/hdfs dfs -ls -R /foo/bar']),
+             stderr='ls: Unknown command\nDid you mean -ls?  This command begins with a dash.'), ['./bin/hdfs dfs -ls -R /foo/bar']),
     (Command('./bin/hdfs dfs -Dtest=fred ls -R /foo/bar',
-        stderr='ls: Unknown command\nDid you mean -ls?  This command begins with a dash.'), ['./bin/hdfs dfs -Dtest=fred -ls -R /foo/bar'])])
+             stderr='ls: Unknown command\nDid you mean -ls?  This command begins with a dash.'), ['./bin/hdfs dfs -Dtest=fred -ls -R /foo/bar'])])
 def test_get_new_command(command, new_command):
     assert get_new_command(command) == new_command

tests/rules/test_vagrant_up.py

@@ -27,8 +27,8 @@ def test_not_match(command):
     (Command(script='vagrant ssh', stderr='VM must be running to open SSH connection. Run `vagrant up`\nto start the virtual machine.'), 'vagrant up && vagrant ssh'),
     (Command(script='vagrant ssh devbox', stderr='VM must be running to open SSH connection. Run `vagrant up`\nto start the virtual machine.'), ['vagrant up devbox && vagrant ssh devbox', 'vagrant up && vagrant ssh devbox']),
     (Command(script='vagrant rdp',
-            stderr='VM must be created before running this command. Run `vagrant up` first.'), 'vagrant up && vagrant rdp'),
+             stderr='VM must be created before running this command. Run `vagrant up` first.'), 'vagrant up && vagrant rdp'),
     (Command(script='vagrant rdp devbox',
-            stderr='VM must be created before running this command. Run `vagrant up` first.'), ['vagrant up devbox && vagrant rdp devbox', 'vagrant up && vagrant rdp devbox'])])
+             stderr='VM must be created before running this command. Run `vagrant up` first.'), ['vagrant up devbox && vagrant rdp devbox', 'vagrant up && vagrant rdp devbox'])])
 def test_get_new_command(command, new_command):
     assert get_new_command(command) == new_command

tests/rules/test_workon_doesnt_exists.py

@@ -0,0 +1,30 @@
+import pytest
+from thefuck.rules.workon_doesnt_exists import match, get_new_command
+from tests.utils import Command
+
+
+@pytest.fixture(autouse=True)
+def envs(mocker):
+    return mocker.patch(
+        'thefuck.rules.workon_doesnt_exists._get_all_environments',
+        return_value=['thefuck', 'code_view'])
+
+
+@pytest.mark.parametrize('script', [
+    'workon tehfuck', 'workon code-view', 'workon new-env'])
+def test_match(script):
+    assert match(Command(script))
+
+
+@pytest.mark.parametrize('script', [
+    'workon thefuck', 'workon code_view', 'work on tehfuck'])
+def test_not_match(script):
+    assert not match(Command(script))
+
+
+@pytest.mark.parametrize('script, result', [
+    ('workon tehfuck', 'workon thefuck'),
+    ('workon code-view', 'workon code_view'),
+    ('workon zzzz', 'mkvirtualenv zzzz')])
+def test_get_new_command(script, result):
+    assert get_new_command(Command(script))[0] == result

tests/rules/test_yarn_alias.py

@@ -0,0 +1,24 @@
+import pytest
+from thefuck.rules.yarn_alias import match, get_new_command
+from tests.utils import Command
+
+
+stderr_remove = 'error Did you mean `yarn remove`?'
+stderr_etl = 'error Command "etil" not found. Did you mean "etl"?'
+stderr_list = 'error Did you mean `yarn list`?'
+
+
+@pytest.mark.parametrize('command', [
+    Command(script='yarn rm', stderr=stderr_remove),
+    Command(script='yarn etil', stderr=stderr_etl),
+    Command(script='yarn ls', stderr=stderr_list)])
+def test_match(command):
+    assert match(command)
+
+
+@pytest.mark.parametrize('command, new_command', [
+    (Command('yarn rm', stderr=stderr_remove), 'yarn remove'),
+    (Command('yarn etil', stderr=stderr_etl), 'yarn etl'),
+    (Command('yarn ls', stderr=stderr_list), 'yarn list')])
+def test_get_new_command(command, new_command):
+    assert get_new_command(command) == new_command

tests/rules/test_yarn_command_not_found.py

@@ -0,0 +1,118 @@
+# -*- encoding: utf-8 -*-
+
+from io import BytesIO
+import pytest
+from tests.utils import Command
+from thefuck.rules.yarn_command_not_found import match, get_new_command
+
+stderr = '''
+error Command "{}" not found.
+'''.format
+
+yarn_help_stdout = b'''
+
+  Usage: yarn [command] [flags]
+
+  Options:
+
+    -h, --help                      output usage information
+    -V, --version                   output the version number
+    --verbose                       output verbose messages on internal operations
+    --offline                       trigger an error if any required dependencies are not available in local cache
+    --prefer-offline                use network only if dependencies are not available in local cache
+    --strict-semver                 
+    --json                          
+    --ignore-scripts                don't run lifecycle scripts
+    --har                           save HAR output of network traffic
+    --ignore-platform               ignore platform checks
+    --ignore-engines                ignore engines check
+    --ignore-optional               ignore optional dependencies
+    --force                         ignore all caches
+    --no-bin-links                  don't generate bin links when setting up packages
+    --flat                          only allow one version of a package
+    --prod, --production [prod]     
+    --no-lockfile                   don't read or generate a lockfile
+    --pure-lockfile                 don't generate a lockfile
+    --frozen-lockfile               don't generate a lockfile and fail if an update is needed
+    --link-duplicates               create hardlinks to the repeated modules in node_modules
+    --global-folder <path>          
+    --modules-folder <path>         rather than installing modules into the node_modules folder relative to the cwd, output them here
+    --cache-folder <path>           specify a custom folder to store the yarn cache
+    --mutex <type>[:specifier]      use a mutex to ensure only one yarn instance is executing
+    --no-emoji                      disable emoji in output
+    --proxy <host>                  
+    --https-proxy <host>            
+    --no-progress                   disable progress bar
+    --network-concurrency <number>  maximum number of concurrent network requests
+
+  Commands:
+
+    - access
+    - add
+    - bin
+    - cache
+    - check
+    - clean
+    - config
+    - generate-lock-entry
+    - global
+    - import
+    - info
+    - init
+    - install
+    - licenses
+    - link
+    - list
+    - login
+    - logout
+    - outdated
+    - owner
+    - pack
+    - publish
+    - remove
+    - run
+    - tag
+    - team
+    - unlink
+    - upgrade
+    - upgrade-interactive
+    - version
+    - versions
+    - why
+
+  Run `yarn help COMMAND` for more information on specific commands.
+  Visit https://yarnpkg.com/en/docs/cli/ to learn more about Yarn.
+''' # noqa
+
+
+@pytest.fixture(autouse=True)
+def yarn_help(mocker):
+    patch = mocker.patch('thefuck.rules.yarn_command_not_found.Popen')
+    patch.return_value.stdout = BytesIO(yarn_help_stdout)
+    return patch
+
+
+@pytest.mark.parametrize('command', [
+    Command('yarn whyy webpack', stderr=stderr('whyy'))])
+def test_match(command):
+    assert match(command)
+
+
+@pytest.mark.parametrize('command', [
+    Command('npm nuild', stderr=stderr('nuild')),
+    Command('yarn install')])
+def test_not_match(command):
+    assert not match(command)
+
+
+@pytest.mark.parametrize('command, result', [
+    (Command('yarn whyy webpack', stderr=stderr('whyy')),
+     'yarn why webpack'),
+    (Command('yarn require lodash', stderr=stderr('require')),
+     'yarn add lodash')])
+def test_get_new_command(command, result):
+    fixed_command = get_new_command(command)
+    if isinstance(fixed_command, list):
+        fixed_command = fixed_command[0]
+
+    assert fixed_command == result

tests/rules/test_yarn_command_replaced.py

@@ -0,0 +1,32 @@
+import pytest
+from tests.utils import Command
+from thefuck.rules.yarn_command_replaced import match, get_new_command
+
+
+stderr = ('error `install` has been replaced with `add` to add new '
+          'dependencies. Run "yarn add {}" instead.').format
+
+
+@pytest.mark.parametrize('command', [
+    Command(script='yarn install redux', stderr=stderr('redux')),
+    Command(script='yarn install moment', stderr=stderr('moment')),
+    Command(script='yarn install lodash', stderr=stderr('lodash'))])
+def test_match(command):
+    assert match(command)
+
+
+@pytest.mark.parametrize('command', [
+    Command('yarn install')])
+def test_not_match(command):
+    assert not match(command)
+
+
+@pytest.mark.parametrize('command, new_command', [
+    (Command('yarn install redux', stderr=stderr('redux')),
+     'yarn add redux'),
+    (Command('yarn install moment', stderr=stderr('moment')),
+     'yarn add moment'),
+    (Command('yarn install lodash', stderr=stderr('lodash')),
+     'yarn add lodash')])
+def test_get_new_command(command, new_command):
+    assert get_new_command(command) == new_command

tests/rules/test_yarn_help.py

@@ -0,0 +1,57 @@
+import pytest
+from thefuck.rules.yarn_help import match, get_new_command
+from tests.utils import Command
+from thefuck.system import open_command
+
+
+stdout_clean = '''
+
+  Usage: yarn [command] [flags]
+
+  Options:
+
+    -h, --help                      output usage information
+    -V, --version                   output the version number
+    --verbose                       output verbose messages on internal operations
+    --offline                       trigger an error if any required dependencies are not available in local cache
+    --prefer-offline                use network only if dependencies are not available in local cache
+    --strict-semver                 
+    --json                          
+    --ignore-scripts                don't run lifecycle scripts
+    --har                           save HAR output of network traffic
+    --ignore-platform               ignore platform checks
+    --ignore-engines                ignore engines check
+    --ignore-optional               ignore optional dependencies
+    --force                         ignore all caches
+    --no-bin-links                  don't generate bin links when setting up packages
+    --flat                          only allow one version of a package
+    --prod, --production [prod]     
+    --no-lockfile                   don't read or generate a lockfile
+    --pure-lockfile                 don't generate a lockfile
+    --frozen-lockfile               don't generate a lockfile and fail if an update is needed
+    --link-duplicates               create hardlinks to the repeated modules in node_modules
+    --global-folder <path>          
+    --modules-folder <path>         rather than installing modules into the node_modules folder relative to the cwd, output them here
+    --cache-folder <path>           specify a custom folder to store the yarn cache
+    --mutex <type>[:specifier]      use a mutex to ensure only one yarn instance is executing
+    --no-emoji                      disable emoji in output
+    --proxy <host>                  
+    --https-proxy <host>            
+    --no-progress                   disable progress bar
+    --network-concurrency <number>  maximum number of concurrent network requests
+
+  Visit https://yarnpkg.com/en/docs/cli/clean for documentation about this command.
+'''  # noqa
+
+
+@pytest.mark.parametrize('command', [
+    Command(script='yarn help clean', stdout=stdout_clean)])
+def test_match(command):
+    assert match(command)
+
+
+@pytest.mark.parametrize('command, url', [
+    (Command('yarn help clean', stdout=stdout_clean),
+     'https://yarnpkg.com/en/docs/cli/clean')])
+def test_get_new_command(command, url):
+    assert get_new_command(command) == open_command(url)

tests/shells/conftest.py

@@ -20,3 +20,11 @@ def history_lines(mocker):
             .return_value.readlines.return_value = lines
 
     return aux
+
+
+@pytest.fixture
+def config_exists(mocker):
+    path_mock = mocker.patch('thefuck.shells.generic.Path')
+    return path_mock.return_value \
+        .expanduser.return_value \
+        .exists

tests/shells/test_bash.py

@@ -33,6 +33,9 @@ class TestBash(object):
     def test_and_(self, shell):
         assert shell.and_('ls', 'cd') == 'ls && cd'
 
+    def test_or_(self, shell):
+        assert shell.or_('ls', 'cd') == 'ls || cd'
+
     def test_get_aliases(self, shell):
         assert shell.get_aliases() == {'fuck': 'eval $(thefuck $(fc -ln -1))',
                                        'l': 'ls -CF',
@@ -40,19 +43,32 @@ class TestBash(object):
                                        'll': 'ls -alF'}
 
     def test_app_alias(self, shell):
-        assert 'alias fuck' in shell.app_alias('fuck')
-        assert 'alias FUCK' in shell.app_alias('FUCK')
+        assert 'fuck () {' in shell.app_alias('fuck')
+        assert 'FUCK () {' in shell.app_alias('FUCK')
         assert 'thefuck' in shell.app_alias('fuck')
-        assert 'TF_ALIAS=fuck' in shell.app_alias('fuck')
-        assert 'PYTHONIOENCODING=utf-8' in shell.app_alias('fuck')
+        assert 'PYTHONIOENCODING' in shell.app_alias('fuck')
 
     def test_app_alias_variables_correctly_set(self, shell):
         alias = shell.app_alias('fuck')
-        assert "alias fuck='TF_CMD=$(TF_ALIAS" in alias
-        assert '$(TF_ALIAS=fuck PYTHONIOENCODING' in alias
-        assert 'PYTHONIOENCODING=utf-8 TF_SHELL_ALIASES' in alias
-        assert 'ALIASES=$(alias) thefuck' in alias
+        assert "fuck () {" in alias
+        assert "TF_ALIAS=fuck" in alias
+        assert 'PYTHONIOENCODING=utf-8' in alias
+        assert 'TF_SHELL_ALIASES=$(alias)' in alias
 
     def test_get_history(self, history_lines, shell):
         history_lines(['ls', 'rm'])
         assert list(shell.get_history()) == ['ls', 'rm']
+
+    def test_split_command(self, shell):
+        command = 'git log -p'
+        command_parts = ['git', 'log', '-p']
+        assert shell.split_command(command) == command_parts
+
+    def test_how_to_configure(self, shell, config_exists):
+        config_exists.return_value = True
+        assert shell.how_to_configure().can_configure_automatically
+
+    def test_how_to_configure_when_config_not_found(self, shell,
+                                                    config_exists):
+        config_exists.return_value = False
+        assert not shell.how_to_configure().can_configure_automatically

tests/shells/test_fish.py

@@ -18,17 +18,14 @@ class TestFish(object):
             b'man\nmath\npopd\npushd\nruby')
         return mock
 
-    @pytest.fixture
-    def os_environ(self, monkeypatch, key, value):
-        monkeypatch.setattr('os.environ', {key: value})
-
     @pytest.mark.parametrize('key, value', [
         ('TF_OVERRIDDEN_ALIASES', 'cut,git,sed'),  # legacy
         ('THEFUCK_OVERRIDDEN_ALIASES', 'cut,git,sed'),
         ('THEFUCK_OVERRIDDEN_ALIASES', 'cut, git, sed'),
         ('THEFUCK_OVERRIDDEN_ALIASES', ' cut,\tgit,sed\n'),
         ('THEFUCK_OVERRIDDEN_ALIASES', '\ncut,\n\ngit,\tsed\r')])
-    def test_get_overridden_aliases(self, shell, os_environ):
+    def test_get_overridden_aliases(self, shell, os_environ, key, value):
+        os_environ[key] = value
         assert shell._get_overridden_aliases() == {'cd', 'cut', 'git', 'grep',
                                                    'ls', 'man', 'open', 'sed'}
 
@@ -55,6 +52,9 @@ class TestFish(object):
     def test_and_(self, shell):
         assert shell.and_('foo', 'bar') == 'foo; and bar'
 
+    def test_or_(self, shell):
+        assert shell.or_('foo', 'bar') == 'foo; or bar'
+
     def test_get_aliases(self, shell):
         assert shell.get_aliases() == {'fish_config': 'fish_config',
                                        'fuck': 'fuck',
@@ -76,11 +76,11 @@ class TestFish(object):
 
     def test_app_alias_alter_history(self, settings, shell):
         settings.alter_history = True
-        assert 'history --delete' in shell.app_alias('FUCK')
-        assert 'history --merge' in shell.app_alias('FUCK')
+        assert 'builtin history delete' in shell.app_alias('FUCK')
+        assert 'builtin history merge' in shell.app_alias('FUCK')
         settings.alter_history = False
-        assert 'history --delete' not in shell.app_alias('FUCK')
-        assert 'history --merge' not in shell.app_alias('FUCK')
+        assert 'builtin history delete' not in shell.app_alias('FUCK')
+        assert 'builtin history merge' not in shell.app_alias('FUCK')
 
     def test_get_history(self, history_lines, shell):
         history_lines(['- cmd: ls', '  when: 1432613911',
@@ -95,3 +95,12 @@ class TestFish(object):
         shell.put_to_history(entry)
         builtins_open.return_value.__enter__.return_value. \
             write.assert_called_once_with(entry_utf8)
+
+    def test_how_to_configure(self, shell, config_exists):
+        config_exists.return_value = True
+        assert shell.how_to_configure().can_configure_automatically
+
+    def test_how_to_configure_when_config_not_found(self, shell,
+                                                    config_exists):
+        config_exists.return_value = False
+        assert not shell.how_to_configure().can_configure_automatically

tests/shells/test_generic.py

@@ -18,6 +18,9 @@ class TestGeneric(object):
     def test_and_(self, shell):
         assert shell.and_('ls', 'cd') == 'ls && cd'
 
+    def test_or_(self, shell):
+        assert shell.or_('ls', 'cd') == 'ls || cd'
+
     def test_get_aliases(self, shell):
         assert shell.get_aliases() == {}
 
@@ -37,3 +40,6 @@ class TestGeneric(object):
     def test_split_command(self, shell):
         assert shell.split_command('ls') == ['ls']
         assert shell.split_command(u'echo café') == [u'echo', u'café']
+
+    def test_how_to_configure(self, shell):
+        assert shell.how_to_configure() is None

tests/shells/test_powershell.py

@@ -17,3 +17,6 @@ class TestPowershell(object):
         assert 'function fuck' in shell.app_alias('fuck')
         assert 'function FUCK' in shell.app_alias('FUCK')
         assert 'thefuck' in shell.app_alias('fuck')
+
+    def test_how_to_configure(self, shell):
+        assert not shell.how_to_configure().can_configure_automatically

tests/shells/test_tcsh.py

@@ -34,6 +34,9 @@ class TestTcsh(object):
     def test_and_(self, shell):
         assert shell.and_('ls', 'cd') == 'ls && cd'
 
+    def test_or_(self, shell):
+        assert shell.or_('ls', 'cd') == 'ls || cd'
+
     def test_get_aliases(self, shell):
         assert shell.get_aliases() == {'fuck': 'eval $(thefuck $(fc -ln -1))',
                                        'l': 'ls -CF',
@@ -48,3 +51,12 @@ class TestTcsh(object):
     def test_get_history(self, history_lines, shell):
         history_lines(['ls', 'rm'])
         assert list(shell.get_history()) == ['ls', 'rm']
+
+    def test_how_to_configure(self, shell, config_exists):
+        config_exists.return_value = True
+        assert shell.how_to_configure().can_configure_automatically
+
+    def test_how_to_configure_when_config_not_found(self, shell,
+                                                    config_exists):
+        config_exists.return_value = False
+        assert not shell.how_to_configure().can_configure_automatically

tests/shells/test_zsh.py

@@ -32,6 +32,9 @@ class TestZsh(object):
     def test_and_(self, shell):
         assert shell.and_('ls', 'cd') == 'ls && cd'
 
+    def test_or_(self, shell):
+        assert shell.or_('ls', 'cd') == 'ls || cd'
+
     def test_get_aliases(self, shell):
         assert shell.get_aliases() == {
             'fuck': 'eval $(thefuck $(fc -ln -1 | tail -n 1))',
@@ -40,18 +43,27 @@ class TestZsh(object):
             'll': 'ls -alF'}
 
     def test_app_alias(self, shell):
-        assert 'alias fuck' in shell.app_alias('fuck')
-        assert 'alias FUCK' in shell.app_alias('FUCK')
+        assert 'fuck () {' in shell.app_alias('fuck')
+        assert 'FUCK () {' in shell.app_alias('FUCK')
         assert 'thefuck' in shell.app_alias('fuck')
         assert 'PYTHONIOENCODING' in shell.app_alias('fuck')
 
     def test_app_alias_variables_correctly_set(self, shell):
         alias = shell.app_alias('fuck')
-        assert "alias fuck='TF_CMD=$(TF_ALIAS" in alias
-        assert '$(TF_ALIAS=fuck PYTHONIOENCODING' in alias
-        assert 'PYTHONIOENCODING=utf-8 TF_SHELL_ALIASES' in alias
-        assert 'ALIASES=$(alias) thefuck' in alias
+        assert "fuck () {" in alias
+        assert "TF_ALIAS=fuck" in alias
+        assert 'PYTHONIOENCODING=utf-8' in alias
+        assert 'TF_SHELL_ALIASES=$(alias)' in alias
 
     def test_get_history(self, history_lines, shell):
         history_lines([': 1432613911:0;ls', ': 1432613916:0;rm'])
         assert list(shell.get_history()) == ['ls', 'rm']
+
+    def test_how_to_configure(self, shell, config_exists):
+        config_exists.return_value = True
+        assert shell.how_to_configure().can_configure_automatically
+
+    def test_how_to_configure_when_config_not_found(self, shell,
+                                                    config_exists):
+        config_exists.return_value = False
+        assert not shell.how_to_configure().can_configure_automatically

tests/specific/test_npm.py

@@ -0,0 +1,26 @@
+from io import BytesIO
+
+import pytest
+from thefuck.specific.npm import get_scripts
+
+run_script_stdout = b'''
+Lifecycle scripts included in code-view-web:
+  test
+    jest
+
+available via `npm run-script`:
+  build
+    cp node_modules/ace-builds/src-min/ -a resources/ace/ && webpack --progress --colors -p --config ./webpack.production.config.js
+  develop
+    cp node_modules/ace-builds/src/ -a resources/ace/ && webpack-dev-server --progress --colors
+  watch-test
+    jest --verbose --watch
+
+'''
+
+
+@pytest.mark.usefixtures('no_memoize')
+def test_get_scripts(mocker):
+    patch = mocker.patch('thefuck.specific.npm.Popen')
+    patch.return_value.stdout = BytesIO(run_script_stdout)
+    assert get_scripts() == ['build', 'develop', 'watch-test']

tests/test_argument_parser.py

@@ -0,0 +1,29 @@
+import pytest
+from thefuck.argument_parser import Parser
+from thefuck.const import ARGUMENT_PLACEHOLDER
+
+
+def _args(**override):
+    args = {'alias': None, 'command': [], 'yes': False,
+            'help': False, 'version': False, 'debug': False,
+            'force_command': None, 'repeat': False}
+    args.update(override)
+    return args
+
+
+@pytest.mark.parametrize('argv, result', [
+    (['thefuck'], _args()),
+    (['thefuck', '-a'], _args(alias='fuck')),
+    (['thefuck', '-a', 'fix'], _args(alias='fix')),
+    (['thefuck', 'git', 'branch', ARGUMENT_PLACEHOLDER, '-y'],
+     _args(command=['git', 'branch'], yes=True)),
+    (['thefuck', 'git', 'branch', '-a', ARGUMENT_PLACEHOLDER, '-y'],
+     _args(command=['git', 'branch', '-a'], yes=True)),
+    (['thefuck', ARGUMENT_PLACEHOLDER, '-v'], _args(version=True)),
+    (['thefuck', ARGUMENT_PLACEHOLDER, '--help'], _args(help=True)),
+    (['thefuck', 'git', 'branch', '-a', ARGUMENT_PLACEHOLDER, '-y', '-d'],
+     _args(command=['git', 'branch', '-a'], yes=True, debug=True)),
+    (['thefuck', 'git', 'branch', '-a', ARGUMENT_PLACEHOLDER, '-r', '-d'],
+     _args(command=['git', 'branch', '-a'], repeat=True, debug=True))])
+def test_parse(argv, result):
+    assert vars(Parser().parse(argv)) == result

tests/test_conf.py

@@ -1,5 +1,6 @@
 import pytest
 import six
+import os
 from mock import Mock
 from thefuck import const
 
@@ -9,14 +10,6 @@ def load_source(mocker):
     return mocker.patch('thefuck.conf.load_source')
 
 
-@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, settings):
     load_source.return_value = object()
     settings.init()
@@ -24,7 +17,6 @@ def test_settings_defaults(load_source, settings):
         assert getattr(settings, key) == val
 
 
-@pytest.mark.usefixture('environ')
 class TestSettingsFromFile(object):
     def test_from_file(self, load_source, settings):
         load_source.return_value = Mock(rules=['test'],
@@ -53,13 +45,15 @@ class TestSettingsFromFile(object):
 
 @pytest.mark.usefixture('load_source')
 class TestSettingsFromEnv(object):
-    def test_from_env(self, environ, settings):
-        environ.update({'THEFUCK_RULES': 'bash:lisp',
-                        'THEFUCK_EXCLUDE_RULES': 'git:vim',
-                        'THEFUCK_WAIT_COMMAND': '55',
-                        'THEFUCK_REQUIRE_CONFIRMATION': 'true',
-                        'THEFUCK_NO_COLORS': 'false',
-                        'THEFUCK_PRIORITY': 'bash=10:lisp=wrong:vim=15'})
+    def test_from_env(self, os_environ, settings):
+        os_environ.update({'THEFUCK_RULES': 'bash:lisp',
+                           'THEFUCK_EXCLUDE_RULES': 'git:vim',
+                           'THEFUCK_WAIT_COMMAND': '55',
+                           'THEFUCK_REQUIRE_CONFIRMATION': 'true',
+                           'THEFUCK_NO_COLORS': 'false',
+                           'THEFUCK_PRIORITY': 'bash=10:lisp=wrong:vim=15',
+                           'THEFUCK_WAIT_SLOW_COMMAND': '999',
+                           'THEFUCK_SLOW_COMMANDS': 'lein:react-native:./gradlew'})
         settings.init()
         assert settings.rules == ['bash', 'lisp']
         assert settings.exclude_rules == ['git', 'vim']
@@ -67,13 +61,22 @@ class TestSettingsFromEnv(object):
         assert settings.require_confirmation is True
         assert settings.no_colors is False
         assert settings.priority == {'bash': 10, 'vim': 15}
+        assert settings.wait_slow_command == 999
+        assert settings.slow_commands == ['lein', 'react-native', './gradlew']
 
-    def test_from_env_with_DEFAULT(self, environ, settings):
-        environ.update({'THEFUCK_RULES': 'DEFAULT_RULES:bash:lisp'})
+    def test_from_env_with_DEFAULT(self, os_environ, settings):
+        os_environ.update({'THEFUCK_RULES': 'DEFAULT_RULES:bash:lisp'})
         settings.init()
         assert settings.rules == const.DEFAULT_RULES + ['bash', 'lisp']
 
 
+def test_settings_from_args(settings):
+    settings.init(Mock(yes=True, debug=True, repeat=True))
+    assert not settings.require_confirmation
+    assert settings.debug
+    assert settings.repeat
+
+
 class TestInitializeSettingsFile(object):
     def test_ignore_if_exists(self, settings):
         settings_path_mock = Mock(is_file=Mock(return_value=True), open=Mock())
@@ -97,3 +100,22 @@ class TestInitializeSettingsFile(object):
         for setting in const.DEFAULT_SETTINGS.items():
             assert '# {} = {}\n'.format(*setting) in settings_file_contents
         settings_file.close()
+
+
+@pytest.mark.parametrize('legacy_dir_exists, xdg_config_home, result', [
+    (False, '~/.config', '~/.config/thefuck'),
+    (False, '/user/test/config/', '/user/test/config/thefuck'),
+    (True, '~/.config', '~/.thefuck'),
+    (True, '/user/test/config/', '~/.thefuck')])
+def test_get_user_dir_path(mocker, os_environ, settings, legacy_dir_exists,
+                           xdg_config_home, result):
+    mocker.patch('thefuck.conf.Path.is_dir',
+                 return_value=legacy_dir_exists)
+
+    if xdg_config_home is not None:
+        os_environ['XDG_CONFIG_HOME'] = xdg_config_home
+    else:
+        os_environ.pop('XDG_CONFIG_HOME', None)
+
+    path = settings._get_user_dir_path().as_posix()
+    assert path == os.path.expanduser(result)

tests/test_corrector.py

@@ -1,13 +1,8 @@
 # -*- coding: utf-8 -*-
 
 import pytest
-try:
-    from pathlib import Path
-    pathlib_name = 'pathlib'
-except ImportError:
-    from pathlib2 import Path
-    pathlib_name = 'pathlib2'
 from thefuck import corrector, const
+from thefuck.system import Path
 from tests.utils import Rule, Command, CorrectedCommand
 from thefuck.corrector import get_corrected_commands, organize_commands
 
@@ -16,7 +11,7 @@ class TestGetRules(object):
     @pytest.fixture
     def glob(self, mocker):
         results = {}
-        mocker.patch(pathlib_name + '.Path.glob',
+        mocker.patch('thefuck.system.Path.glob',
                      new_callable=lambda: lambda *_: results.pop('value', []))
         return lambda value: results.update({'value': value})
 
@@ -52,8 +47,8 @@ def test_get_corrected_commands(mocker):
                   get_new_command=lambda x: [x.script + '@', x.script + ';'],
                   priority=60)]
     mocker.patch('thefuck.corrector.get_rules', return_value=rules)
-    assert [cmd.script for cmd in get_corrected_commands(command)] \
-           == ['test!', 'test@', 'test;']
+    assert ([cmd.script for cmd in get_corrected_commands(command)]
+            == ['test!', 'test@', 'test;'])
 
 
 def test_organize_commands():

tests/test_not_configured.py

@@ -0,0 +1,140 @@
+import pytest
+import json
+from six import StringIO
+from mock import MagicMock
+from thefuck.shells.generic import ShellConfiguration
+from thefuck.not_configured import main
+
+
+@pytest.fixture(autouse=True)
+def usage_tracker(mocker):
+    return mocker.patch(
+        'thefuck.not_configured._get_not_configured_usage_tracker_path',
+        new_callable=MagicMock)
+
+
+@pytest.fixture(autouse=True)
+def usage_tracker_io(usage_tracker):
+    io = StringIO()
+    usage_tracker.return_value \
+                 .open.return_value \
+                 .__enter__.return_value = io
+    return io
+
+
+@pytest.fixture(autouse=True)
+def usage_tracker_exists(usage_tracker):
+    usage_tracker.return_value \
+                 .exists.return_value = True
+    return usage_tracker.return_value.exists
+
+
+def _assert_tracker_updated(usage_tracker_io, pid):
+    usage_tracker_io.seek(0)
+    info = json.load(usage_tracker_io)
+    assert info['pid'] == pid
+
+
+def _change_tracker(usage_tracker_io, pid):
+    usage_tracker_io.truncate(0)
+    info = {'pid': pid, 'time': 0}
+    json.dump(info, usage_tracker_io)
+    usage_tracker_io.seek(0)
+
+
+@pytest.fixture(autouse=True)
+def shell_pid(mocker):
+    return mocker.patch('thefuck.not_configured._get_shell_pid',
+                        new_callable=MagicMock)
+
+
+@pytest.fixture(autouse=True)
+def shell(mocker):
+    shell = mocker.patch('thefuck.not_configured.shell',
+                         new_callable=MagicMock)
+    shell.get_history.return_value = []
+    shell.how_to_configure.return_value = ShellConfiguration(
+        content='eval $(thefuck --alias)',
+        path='/tmp/.bashrc',
+        reload='bash',
+        can_configure_automatically=True)
+    return shell
+
+
+@pytest.fixture(autouse=True)
+def shell_config(mocker):
+    path_mock = mocker.patch('thefuck.not_configured.Path',
+                             new_callable=MagicMock)
+    return path_mock.return_value \
+        .expanduser.return_value \
+        .open.return_value \
+        .__enter__.return_value
+
+
+@pytest.fixture(autouse=True)
+def logs(mocker):
+    return mocker.patch('thefuck.not_configured.logs',
+                        new_callable=MagicMock)
+
+
+def test_for_generic_shell(shell, logs):
+    shell.how_to_configure.return_value = None
+    main()
+    logs.how_to_configure_alias.assert_called_once()
+
+
+def test_on_first_run(usage_tracker_io, usage_tracker_exists, shell_pid, logs):
+    shell_pid.return_value = 12
+    main()
+    usage_tracker_exists.return_value = False
+    _assert_tracker_updated(usage_tracker_io, 12)
+    logs.how_to_configure_alias.assert_called_once()
+
+
+def test_on_run_after_other_commands(usage_tracker_io, shell_pid, shell, logs):
+    shell_pid.return_value = 12
+    shell.get_history.return_value = ['fuck', 'ls']
+    _change_tracker(usage_tracker_io, 12)
+    main()
+    logs.how_to_configure_alias.assert_called_once()
+
+
+def test_on_first_run_from_current_shell(usage_tracker_io, shell_pid,
+                                         shell, logs):
+    shell.get_history.return_value = ['fuck']
+    shell_pid.return_value = 12
+    main()
+    _assert_tracker_updated(usage_tracker_io, 12)
+    logs.how_to_configure_alias.assert_called_once()
+
+
+def test_when_cant_configure_automatically(shell_pid, shell, logs):
+    shell_pid.return_value = 12
+    shell.how_to_configure.return_value = ShellConfiguration(
+        content='eval $(thefuck --alias)',
+        path='/tmp/.bashrc',
+        reload='bash',
+        can_configure_automatically=False)
+    main()
+    logs.how_to_configure_alias.assert_called_once()
+
+
+def test_when_already_configured(usage_tracker_io, shell_pid,
+                                 shell, shell_config, logs):
+    shell.get_history.return_value = ['fuck']
+    shell_pid.return_value = 12
+    _change_tracker(usage_tracker_io, 12)
+    shell_config.read.return_value = 'eval $(thefuck --alias)'
+    main()
+    logs.already_configured.assert_called_once()
+
+
+def test_when_successfully_configured(usage_tracker_io, shell_pid,
+                                      shell, shell_config, logs):
+    shell.get_history.return_value = ['fuck']
+    shell_pid.return_value = 12
+    _change_tracker(usage_tracker_io, 12)
+    shell_config.read.return_value = ''
+    main()
+    shell_config.write.assert_any_call('eval $(thefuck --alias)')
+    logs.configured_successfully.assert_called_once()

tests/test_types.py

@@ -3,23 +3,20 @@
 import os
 from subprocess import PIPE
 from mock import Mock
-try:
-    from pathlib import Path
-except ImportError:
-    from pathlib2 import Path
 import pytest
 from tests.utils import CorrectedCommand, Rule, Command
 from thefuck import const
 from thefuck.exceptions import EmptyCommand
+from thefuck.system import Path
 
 
 class TestCorrectedCommand(object):
 
     def test_equality(self):
-        assert CorrectedCommand('ls', None, 100) == \
-               CorrectedCommand('ls', None, 200)
-        assert CorrectedCommand('ls', None, 100) != \
-               CorrectedCommand('ls', lambda *_: _, 100)
+        assert (CorrectedCommand('ls', None, 100) ==
+                CorrectedCommand('ls', None, 200))
+        assert (CorrectedCommand('ls', None, 100) !=
+                CorrectedCommand('ls', lambda *_: _, 100))
 
     def test_hashable(self):
         assert {CorrectedCommand('ls', None, 100),
@@ -31,6 +28,20 @@ class TestCorrectedCommand(object):
         assert u'{}'.format(CorrectedCommand(u'echo café', None, 100)) == \
                u'CorrectedCommand(script=echo café, side_effect=None, priority=100)'
 
+    @pytest.mark.parametrize('script, printed, override_settings', [
+        ('git branch', 'git branch', {'repeat': False, 'debug': False}),
+        ('git brunch',
+         "git brunch || fuck --repeat --force-command 'git brunch'",
+         {'repeat': True, 'debug': False}),
+        ('git brunch',
+         "git brunch || fuck --repeat --debug --force-command 'git brunch'",
+         {'repeat': True, 'debug': True})])
+    def test_run(self, capsys, settings, script, printed, override_settings):
+        settings.update(override_settings)
+        CorrectedCommand(script, None, 1000).run(Command())
+        out, _ = capsys.readouterr()
+        assert out[:-1] == printed
+
 
 class TestRule(object):
     def test_from_path(self, mocker):
@@ -44,8 +55,8 @@ class TestRule(object):
                               priority=900,
                               requires_output=True))
         rule_path = os.path.join(os.sep, 'rules', 'bash.py')
-        assert Rule.from_path(Path(rule_path)) \
-               == Rule('bash', match, get_new_command, priority=900)
+        assert (Rule.from_path(Path(rule_path))
+                == Rule('bash', match, get_new_command, priority=900))
         load_source.assert_called_once_with('bash', rule_path)
 
     @pytest.mark.parametrize('rules, exclude_rules, rule, is_enabled', [
@@ -82,15 +93,15 @@ class TestRule(object):
     def test_get_corrected_commands_with_rule_returns_list(self):
         rule = Rule(get_new_command=lambda x: [x.script + '!', x.script + '@'],
                     priority=100)
-        assert list(rule.get_corrected_commands(Command(script='test'))) \
-               == [CorrectedCommand(script='test!', priority=100),
-                   CorrectedCommand(script='test@', priority=200)]
+        assert (list(rule.get_corrected_commands(Command(script='test')))
+                == [CorrectedCommand(script='test!', priority=100),
+                    CorrectedCommand(script='test@', priority=200)])
 
     def test_get_corrected_commands_with_rule_returns_command(self):
         rule = Rule(get_new_command=lambda x: x.script + '!',
                     priority=100)
-        assert list(rule.get_corrected_commands(Command(script='test'))) \
-               == [CorrectedCommand(script='test!', priority=100)]
+        assert (list(rule.get_corrected_commands(Command(script='test')))
+                == [CorrectedCommand(script='test!', priority=100)])
 
 
 class TestCommand(object):
@@ -104,11 +115,10 @@ class TestCommand(object):
 
     @pytest.fixture(autouse=True)
     def prepare(self, monkeypatch):
-        monkeypatch.setattr('thefuck.types.os.environ', {})
         monkeypatch.setattr('thefuck.types.Command._wait_output',
                             staticmethod(lambda *_: True))
 
-    def test_from_script_calls(self, Popen, settings):
+    def test_from_script_calls(self, Popen, settings, os_environ):
         settings.env = {}
         assert Command.from_raw_script(
             ['apt-get', 'search', 'vim']) == Command(
@@ -118,7 +128,7 @@ class TestCommand(object):
                                       stdin=PIPE,
                                       stdout=PIPE,
                                       stderr=PIPE,
-                                      env={})
+                                      env=os_environ)
 
     @pytest.mark.parametrize('script, result', [
         ([''], None),

tests/test_ui.py

@@ -30,11 +30,11 @@ def test_read_actions(patch_get_key):
         const.KEY_DOWN, 'j',
         # Ctrl+C:
         const.KEY_CTRL_C, 'q'])
-    assert list(islice(ui.read_actions(), 8)) \
-           == [const.ACTION_SELECT, const.ACTION_SELECT,
-               const.ACTION_PREVIOUS, const.ACTION_PREVIOUS,
-               const.ACTION_NEXT, const.ACTION_NEXT,
-               const.ACTION_ABORT, const.ACTION_ABORT]
+    assert (list(islice(ui.read_actions(), 8))
+            == [const.ACTION_SELECT, const.ACTION_SELECT,
+                const.ACTION_PREVIOUS, const.ACTION_PREVIOUS,
+                const.ACTION_NEXT, const.ACTION_NEXT,
+                const.ACTION_ABORT, const.ACTION_ABORT])
 
 
 def test_command_selector():
@@ -74,8 +74,8 @@ class TestSelectCommand(object):
     def test_without_confirmation_with_side_effects(
             self, capsys, commands_with_side_effect, settings):
         settings.require_confirmation = False
-        assert ui.select_command(iter(commands_with_side_effect)) \
-               == commands_with_side_effect[0]
+        assert (ui.select_command(iter(commands_with_side_effect))
+                == commands_with_side_effect[0])
         assert capsys.readouterr() == ('', 'ls (+side effect)\n')
 
     def test_with_confirmation(self, capsys, patch_get_key, commands):
@@ -91,8 +91,8 @@ class TestSelectCommand(object):
     def test_with_confirmation_with_side_effct(self, capsys, patch_get_key,
                                                commands_with_side_effect):
         patch_get_key(['\n'])
-        assert ui.select_command(iter(commands_with_side_effect)) \
-               == commands_with_side_effect[0]
+        assert (ui.select_command(iter(commands_with_side_effect))
+                == commands_with_side_effect[0])
         assert capsys.readouterr() == ('', u'\x1b[1K\rls (+side effect) [enter/↑/↓/ctrl+c]\n')
 
     def test_with_confirmation_select_second(self, capsys, patch_get_key, commands):

tests/test_utils.py

@@ -6,7 +6,7 @@ from mock import Mock
 import six
 from thefuck.utils import default_settings, \
     memoize, get_closest, get_all_executables, replace_argument, \
-    get_all_matched_commands, is_app, for_app, cache, compatibility_call, \
+    get_all_matched_commands, is_app, for_app, cache, \
     get_valid_history_without_current
 from tests.utils import Command
 
@@ -18,8 +18,7 @@ from tests.utils import Command
 def test_default_settings(settings, override, old, new):
     settings.clear()
     settings.update(old)
-    fn = lambda _: _
-    default_settings(override)(fn)(None)
+    default_settings(override)(lambda _: _)(None)
     assert settings == new
 
 
@@ -188,56 +187,6 @@ class TestCache(object):
         assert shelve == {key: {'etag': '0', 'value': 'test'}}
 
 
-class TestCompatibilityCall(object):
-    def test_match(self):
-        def match(command):
-            assert command == Command()
-            return True
-
-        assert compatibility_call(match, Command())
-
-    def test_old_match(self, settings):
-        def match(command, _settings):
-            assert command == Command()
-            assert settings == _settings
-            return True
-
-        with pytest.warns(UserWarning):
-            assert compatibility_call(match, Command())
-
-    def test_get_new_command(self):
-        def get_new_command(command):
-            assert command == Command()
-            return True
-
-        assert compatibility_call(get_new_command, Command())
-
-    def test_old_get_new_command(self, settings):
-        def get_new_command(command, _settings):
-            assert command == Command()
-            assert settings == _settings
-            return True
-
-        with pytest.warns(UserWarning):
-            assert compatibility_call(get_new_command, Command())
-
-    def test_side_effect(self):
-        def side_effect(command, new_command):
-            assert command == Command() == new_command
-            return True
-
-        assert compatibility_call(side_effect, Command(), Command())
-
-    def test_old_side_effect(self, settings):
-        def side_effect(command, new_command, _settings):
-            assert command == Command() == new_command
-            assert settings == _settings
-            return True
-
-        with pytest.warns(UserWarning):
-            assert compatibility_call(side_effect, Command(), Command())
-
-
 class TestGetValidHistoryWithoutCurrent(object):
     @pytest.yield_fixture(autouse=True)
     def fail_on_warning(self):
@@ -257,8 +206,7 @@ class TestGetValidHistoryWithoutCurrent(object):
                             return_value='fuck')
 
     @pytest.fixture(autouse=True)
-    def bins(self, mocker, monkeypatch):
-        monkeypatch.setattr('thefuck.conf.os.environ', {'PATH': 'path'})
+    def bins(self, mocker):
         callables = list()
         for name in ['diff', 'ls', 'café']:
             bin_mock = mocker.Mock(name=name)

thefuck/argument_parser.py

@@ -0,0 +1,84 @@
+import sys
+from argparse import ArgumentParser, SUPPRESS
+from .const import ARGUMENT_PLACEHOLDER
+from .utils import get_alias
+
+
+class Parser(object):
+    """Argument parser that can handle arguments with our special
+    placeholder.
+
+    """
+
+    def __init__(self):
+        self._parser = ArgumentParser(prog='thefuck', add_help=False)
+        self._add_arguments()
+
+    def _add_arguments(self):
+        """Adds arguments to parser."""
+        self._parser.add_argument(
+            '-v', '--version',
+            action='store_true',
+            help="show program's version number and exit")
+        self._parser.add_argument(
+            '-a', '--alias',
+            nargs='?',
+            const=get_alias(),
+            help='[custom-alias-name] prints alias for current shell')
+        self._parser.add_argument(
+            '-h', '--help',
+            action='store_true',
+            help='show this help message and exit')
+        self._add_conflicting_arguments()
+        self._parser.add_argument(
+            '-d', '--debug',
+            action='store_true',
+            help='enable debug output')
+        self._parser.add_argument(
+            '--force-command',
+            action='store',
+            help=SUPPRESS)
+        self._parser.add_argument(
+            'command',
+            nargs='*',
+            help='command that should be fixed')
+
+    def _add_conflicting_arguments(self):
+        """It's too dangerous to use `-y` and `-r` together."""
+        group = self._parser.add_mutually_exclusive_group()
+        group.add_argument(
+            '-y', '--yes',
+            action='store_true',
+            help='execute fixed command without confirmation')
+        group.add_argument(
+            '-r', '--repeat',
+            action='store_true',
+            help='repeat on failure')
+
+    def _prepare_arguments(self, argv):
+        """Prepares arguments by:
+
+        - removing placeholder and moving arguments after it to beginning,
+          we need this to distinguish arguments from `command` with ours;
+
+        - adding `--` before `command`, so our parse would ignore arguments
+          of `command`.
+
+        """
+        if ARGUMENT_PLACEHOLDER in argv:
+            index = argv.index(ARGUMENT_PLACEHOLDER)
+            return argv[index + 1:] + ['--'] + argv[:index]
+        elif argv and not argv[0].startswith('-') and argv[0] != '--':
+            return ['--'] + argv
+        else:
+            return argv
+
+    def parse(self, argv):
+        arguments = self._prepare_arguments(argv[1:])
+        return self._parser.parse_args(arguments)
+
+    def print_usage(self):
+        self._parser.print_usage(sys.stderr)
+
+    def print_help(self):
+        self._parser.print_help(sys.stderr)

thefuck/conf.py

@@ -1,12 +1,10 @@
 from imp import load_source
 import os
 import sys
-try:
-    from pathlib import Path
-except ImportError:
-    from pathlib2 import Path
+from warnings import warn
 from six import text_type
 from . import const
+from .system import Path
 
 
 class Settings(dict):
@@ -16,7 +14,7 @@ class Settings(dict):
     def __setattr__(self, key, value):
         self[key] = value
 
-    def init(self):
+    def init(self, args=None):
         """Fills `settings` with values from `settings.py` and env."""
         from .logs import exception
 
@@ -33,6 +31,8 @@ class Settings(dict):
         except Exception:
             exception("Can't load settings from env", sys.exc_info())
 
+        self.update(self._settings_from_args(args))
+
     def _init_settings_file(self):
         settings_path = self.user_dir.joinpath('settings.py')
         if not settings_path.is_file():
@@ -42,15 +42,18 @@ class Settings(dict):
                     settings_file.write(u'# {} = {}\n'.format(*setting))
 
     def _get_user_dir_path(self):
-        # for backward compatibility, use `~/.thefuck` if it exists
-        legacy_user_dir = Path(os.path.expanduser('~/.thefuck'))
+        """Returns Path object representing the user config resource"""
+        xdg_config_home = os.environ.get('XDG_CONFIG_HOME', '~/.config')
+        user_dir = Path(xdg_config_home, 'thefuck').expanduser()
+        legacy_user_dir = Path('~', '.thefuck').expanduser()
 
+        # For backward compatibility use legacy '~/.thefuck' if it exists:
         if legacy_user_dir.is_dir():
+            warn(u'Config path {} is deprecated. Please move to {}'.format(
+                legacy_user_dir, user_dir))
             return legacy_user_dir
         else:
-            default_xdg_config_dir = os.path.expanduser("~/.config")
-            xdg_config_dir = os.getenv("XDG_CONFIG_HOME", default_xdg_config_dir)
-            return Path(os.path.join(xdg_config_dir, 'thefuck'))
+            return user_dir
 
     def _setup_user_dir(self):
         """Returns user config dir, create it when it doesn't exist."""
@@ -92,13 +95,13 @@ class Settings(dict):
             return self._rules_from_env(val)
         elif attr == 'priority':
             return dict(self._priority_from_env(val))
-        elif attr == 'wait_command':
+        elif attr in ('wait_command', 'history_limit', 'wait_slow_command'):
             return int(val)
         elif attr in ('require_confirmation', 'no_colors', 'debug',
                       'alter_history'):
             return val.lower() == 'true'
-        elif attr == 'history_limit':
-            return int(val)
+        elif attr == 'slow_commands':
+            return val.split(':')
         else:
             return val
 
@@ -108,5 +111,19 @@ class Settings(dict):
                 for env, attr in const.ENV_TO_ATTR.items()
                 if env in os.environ}
 
+    def _settings_from_args(self, args):
+        """Loads settings from args."""
+        if not args:
+            return {}
+
+        from_args = {}
+        if args.yes:
+            from_args['require_confirmation'] = not args.yes
+        if args.debug:
+            from_args['debug'] = args.debug
+        if args.repeat:
+            from_args['repeat'] = args.repeat
+        return from_args
+
 
 settings = Settings(const.DEFAULT_SETTINGS)

thefuck/const.py

@@ -31,6 +31,10 @@ DEFAULT_SETTINGS = {'rules': DEFAULT_RULES,
                     'priority': {},
                     'history_limit': None,
                     'alter_history': True,
+                    'wait_slow_command': 15,
+                    'slow_commands': ['lein', 'react-native', 'gradle',
+                                      './gradlew', 'vagrant'],
+                    'repeat': False,
                     'env': {'LC_ALL': 'C', 'LANG': 'C', 'GIT_TRACE': '1'}}
 
 ENV_TO_ATTR = {'THEFUCK_RULES': 'rules',
@@ -41,7 +45,10 @@ ENV_TO_ATTR = {'THEFUCK_RULES': 'rules',
                'THEFUCK_DEBUG': 'debug',
                'THEFUCK_PRIORITY': 'priority',
                'THEFUCK_HISTORY_LIMIT': 'history_limit',
-               'THEFUCK_ALTER_HISTORY': 'alter_history'}
+               'THEFUCK_ALTER_HISTORY': 'alter_history',
+               'THEFUCK_WAIT_SLOW_COMMAND': 'wait_slow_command',
+               'THEFUCK_SLOW_COMMANDS': 'slow_commands',
+               'THEFUCK_REPEAT': 'repeat'}
 
 SETTINGS_HEADER = u"""# The Fuck settings file
 #
@@ -54,3 +61,7 @@ SETTINGS_HEADER = u"""# The Fuck settings file
 #
 
 """
+
+ARGUMENT_PLACEHOLDER = 'THEFUCK_ARGUMENT_PLACEHOLDER'
+
+CONFIGURATION_TIMEOUT = 60