Bump to 3.15

# Conflicts:
#	thefuck/system/unix.py
#	thefuck/system/win32.py

.travis.yml

@@ -42,9 +42,10 @@ install:
   - 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 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

@@ -106,13 +106,13 @@ On Ubuntu you can install `The Fuck` with:
 ```bash
 sudo apt update
 sudo apt install python3-dev python3-pip
-sudo -H pip3 install thefuck
+pip3 install --user thefuck
 ```
 
 On other systems you can install `The Fuck` with `pip`:
 
 ```bash
-sudo -H pip install thefuck
+pip install --user thefuck
 ```
 
 [Or using an OS package manager (OS X, Ubuntu, Arch).](https://github.com/nvbn/thefuck/wiki/Installation)
@@ -120,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)
@@ -130,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 -H pip install thefuck --upgrade
+pip install --user thefuck --upgrade
 ```
 
 **Aliases changed in 1.34.**
@@ -164,7 +169,9 @@ using the matched rule and runs it. Rules enabled by default are as follows:
 * `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;
@@ -184,10 +191,12 @@ using the matched rule and runs it. Rules enabled by default are as follows:
 * `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;
@@ -199,6 +208,7 @@ using the matched rule and runs it. Rules enabled by default are as follows:
 * `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;
@@ -210,6 +220,7 @@ using the matched rule and runs it. Rules enabled by default are as follows:
 * `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`;
@@ -224,13 +235,16 @@ using the matched rule and runs it. Rules enabled by default are as follows:
 * `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`;
@@ -242,6 +256,9 @@ using the matched rule and runs it. Rules enabled by default are as follows:
 * `vagrant_up` &ndash; starts up the vagrant instance;
 * `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_help` &ndash; makes it easier to open `yarn` documentation;
 
 Enabled by default only on specific platforms:
 
@@ -379,6 +396,12 @@ pip install -r requirements.txt
 python setup.py develop
 ```
 
+Run code style checks:
+
+```bash
+flake8
+```
+
 Run unit tests:
 
 ```bash

appveyor.yml

@@ -20,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

@@ -29,7 +29,7 @@ elif (3, 0) < version < (3, 3):
           ' ({}.{} detected).'.format(*version))
     sys.exit(-1)
 
-VERSION = '3.13'
+VERSION = '3.15'
 
 install_requires = ['psutil', 'colorama', 'six', 'decorator']
 extras_require = {':python_version<"3.4"': ['pathlib2'],
@@ -51,4 +51,4 @@ setup(name='thefuck',
       extras_require=extras_require,
       entry_points={'console_scripts': [
           'thefuck = thefuck.main:main',
-          'fuck = thefuck.main:how_to_configure_alias']})
+          'fuck = thefuck.not_configured:main']})

tests/rules/test_apt_get.py

@@ -7,6 +7,8 @@ from tests.utils import Command
     (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')])])
 def test_match(mocker, command, packages):
     mocker.patch('thefuck.rules.apt_get.which', return_value=None)

tests/rules/test_brew_link.py

@@ -6,15 +6,15 @@ 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")
+            "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
@@ -29,7 +29,7 @@ def test_match(stderr, script):
 
 @pytest.mark.parametrize('script', ['brew link coreutils'])
 def test_not_match(script):
-    stderr=''
+    stderr = ''
     assert not match(Command(script=script, stderr=stderr))
 
 

tests/rules/test_brew_uninstall.py

@@ -22,7 +22,7 @@ def test_match(stdout, script):
 
 @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'
+    stdout = 'Uninstalling /usr/local/Cellar/gnuplot/5.0.4_1... (44 files, 2.3M)\n'
     assert not match(Command(script=script, stdout=stdout))
 
 

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_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,6 +33,7 @@ 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)

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

@@ -45,5 +45,5 @@ def test_not_match(command):
      'fab prepare_extension:version=2016 deploy:beta=true -H the.fuck'),
 ])
 def test_get_new_command(script, result):
-    command = Command(script, stdout,stderr)
+    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_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_not_command.py

@@ -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

@@ -15,5 +15,5 @@ def test_match(stderr):
 
 
 def test_get_new_command(stderr):
-    assert get_new_command(Command('git pull', stderr=stderr)) \
-           == "git stash && git pull && git stash pop"
+    assert (get_new_command(Command('git pull', stderr=stderr))
+            == "git stash && git pull && git stash pop")

tests/rules/test_git_pull_unstaged_changes.py

@@ -15,5 +15,5 @@ def test_match(stderr):
 
 
 def test_get_new_command(stderr):
-    assert get_new_command(Command('git pull', stderr=stderr)) \
-           == "git stash && git pull && git stash pop"
+    assert (get_new_command(Command('git pull', stderr=stderr))
+            == "git stash && git pull && git stash pop")

tests/rules/test_git_push_pull.py

@@ -39,12 +39,7 @@ 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)])
-def test_match(command):
-    assert match(command)
-
-
-@pytest.mark.parametrize('command', [
+    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)])
@@ -68,12 +63,7 @@ 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')])
-def test_get_new_command(command, output):
-    assert get_new_command(command) == output
-
-
-@pytest.mark.parametrize('command, output', [
+     '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'),

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_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

@@ -14,5 +14,5 @@ def test_match(stderr):
 
 
 def test_get_new_command(stderr):
-    assert get_new_command(Command('git stash pop', stderr=stderr)) \
-           == "git add . && git stash pop && git reset ."
+    assert (get_new_command(Command('git stash pop', stderr=stderr))
+            == "git add . && 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_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_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_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_missing_space_before_subcommand.py

@@ -0,0 +1,39 @@
+import pytest
+from thefuck.rules.missing_space_before_subcommand import (
+    match, get_new_command)
+from tests.utils import Command
+
+
+@pytest.fixture(autouse=True)
+def which(mocker):
+    return mocker.patch('thefuck.rules.missing_space_before_subcommand.which',
+                        return_value=None)
+
+
+@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, which_result', [
+    ('git branch', '/usr/bin/git'),
+    ('vimfile', None)])
+def test_not_match(script, which_result, which):
+    which.return_value = which_result
+    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_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_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_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_yarn_alias.py

@@ -0,0 +1,22 @@
+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_list = 'error Did you mean `yarn list`?'
+
+
+@pytest.mark.parametrize('command', [
+    Command(script='yarn rm', stderr=stderr_remove),
+    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 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,111 @@
+# -*- 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')])
+def test_get_new_command(command, result):
+    assert get_new_command(command)[0] == result

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, new_command', [
+    (Command('yarn help clean', stdout=stdout_clean),
+     open_command('https://yarnpkg.com/en/docs/cli/clean'))])
+def test_get_new_command(command, new_command):
+    assert get_new_command(command) == new_command

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

@@ -61,3 +61,12 @@ class TestBash(object):
         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

@@ -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

@@ -37,3 +37,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

@@ -48,3 +48,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

@@ -55,3 +55,12 @@ class TestZsh(object):
     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/test_corrector.py

@@ -47,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,125 @@
+import pytest
+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)
+
+
+def _assert_tracker_updated(usage_tracker, pid):
+    usage_tracker.return_value \
+        .open.return_value \
+        .__enter__.return_value \
+        .write.assert_called_once_with(str(pid))
+
+
+def _change_tracker(usage_tracker, pid):
+    usage_tracker.return_value.exists.return_value = True
+    usage_tracker.return_value \
+        .open.return_value \
+        .__enter__.return_value \
+        .read.return_value = str(pid)
+
+
+@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, shell_pid, logs):
+    shell_pid.return_value = 12
+    usage_tracker.return_value.exists.return_value = False
+    main()
+    _assert_tracker_updated(usage_tracker, 12)
+    logs.how_to_configure_alias.assert_called_once()
+
+
+def test_on_run_after_other_commands(usage_tracker, shell_pid, shell, logs):
+    shell_pid.return_value = 12
+    shell.get_history.return_value = ['fuck', 'ls']
+    _change_tracker(usage_tracker, 12)
+    main()
+    logs.how_to_configure_alias.assert_called_once()
+
+
+def test_on_first_run_from_current_shell(usage_tracker, shell_pid,
+                                         shell, logs):
+    shell.get_history.return_value = ['fuck']
+    shell_pid.return_value = 12
+    _change_tracker(usage_tracker, 55)
+    main()
+    _assert_tracker_updated(usage_tracker, 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, shell_pid,
+                                 shell, shell_config, logs):
+    shell.get_history.return_value = ['fuck']
+    shell_pid.return_value = 12
+    _change_tracker(usage_tracker, 12)
+    shell_config.read.return_value = 'eval $(thefuck --alias)'
+    main()
+    logs.already_configured.assert_called_once()
+
+
+def test_when_successfuly_configured(usage_tracker, shell_pid,
+                                     shell, shell_config, logs):
+    shell.get_history.return_value = ['fuck']
+    shell_pid.return_value = 12
+    _change_tracker(usage_tracker, 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

@@ -13,10 +13,10 @@ 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),
@@ -41,8 +41,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', [
@@ -79,15 +79,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):

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

@@ -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
 
 

thefuck/const.py

@@ -33,7 +33,7 @@ DEFAULT_SETTINGS = {'rules': DEFAULT_RULES,
                     'alter_history': True,
                     'wait_slow_command': 15,
                     'slow_commands': ['lein', 'react-native', 'gradle',
-                                      './gradlew'],
+                                      './gradlew', 'vagrant'],
                     'env': {'LC_ALL': 'C', 'LANG': 'C', 'GIT_TRACE': '1'}}
 
 ENV_TO_ATTR = {'THEFUCK_RULES': 'rules',

thefuck/logs.py

@@ -80,16 +80,44 @@ def debug_time(msg):
 
 
 def how_to_configure_alias(configuration_details):
-    print("Seems like {bold}fuck{reset} alias isn't configured!".format(
+    print(u"Seems like {bold}fuck{reset} alias isn't configured!".format(
         bold=color(colorama.Style.BRIGHT),
         reset=color(colorama.Style.RESET_ALL)))
+
     if configuration_details:
-        content, path = configuration_details
         print(
-            "Please put {bold}{content}{reset} in your "
-            "{bold}{path}{reset}.".format(
+            u"Please put {bold}{content}{reset} in your "
+            u"{bold}{path}{reset} and apply "
+            u"changes with {bold}{reload}{reset} or restart your shell.".format(
                 bold=color(colorama.Style.BRIGHT),
                 reset=color(colorama.Style.RESET_ALL),
-                path=path,
-                content=content))
-    print('More details - https://github.com/nvbn/thefuck#manual-installation')
+                **configuration_details._asdict()))
+
+        if configuration_details.can_configure_automatically:
+            print(
+                u"Or run {bold}fuck{reset} second time for configuring"
+                u" it automatically.".format(
+                    bold=color(colorama.Style.BRIGHT),
+                    reset=color(colorama.Style.RESET_ALL)))
+
+    print(u'More details - https://github.com/nvbn/thefuck#manual-installation')
+
+
+def already_configured(configuration_details):
+    print(
+        u"Seems like {bold}fuck{reset} alias already configured!\n"
+        u"For applying changes run {bold}{reload}{reset}"
+        u" or restart your shell.".format(
+            bold=color(colorama.Style.BRIGHT),
+            reset=color(colorama.Style.RESET_ALL),
+            reload=configuration_details.reload))
+
+
+def configured_successfully(configuration_details):
+    print(
+        u"{bold}fuck{reset} alias configured successfully!\n"
+        u"For applying changes run {bold}{reload}{reset}"
+        u" or restart your shell.".format(
+            bold=color(colorama.Style.BRIGHT),
+            reset=color(colorama.Style.RESET_ALL),
+            reload=configuration_details.reload))

thefuck/main.py

@@ -3,16 +3,16 @@ from .system import init_output
 
 init_output()
 
-from argparse import ArgumentParser
-from pprint import pformat
-import sys
-from . import logs, types
-from .shells import shell
-from .conf import settings
-from .corrector import get_corrected_commands
-from .exceptions import EmptyCommand
-from .utils import get_installation_info, get_alias
-from .ui import select_command
+from argparse import ArgumentParser  # noqa: E402
+from pprint import pformat  # noqa: E402
+import sys  # noqa: E402
+from . import logs, types  # noqa: E402
+from .shells import shell  # noqa: E402
+from .conf import settings  # noqa: E402
+from .corrector import get_corrected_commands  # noqa: E402
+from .exceptions import EmptyCommand  # noqa: E402
+from .utils import get_installation_info, get_alias  # noqa: E402
+from .ui import select_command  # noqa: E402
 
 
 def fix_command():
@@ -46,24 +46,13 @@ def print_alias():
     print(shell.app_alias(alias))
 
 
-def how_to_configure_alias():
-    """Shows useful information about how-to configure alias.
-
-    It'll be only visible when user type fuck and when alias isn't configured.
-
-    """
-    settings.init()
-    logs.how_to_configure_alias(shell.how_to_configure())
-
-
 def main():
     parser = ArgumentParser(prog='thefuck')
     version = get_installation_info().version
-    parser.add_argument(
-            '-v', '--version',
-            action='version',
-            version='The Fuck {} using Python {}'.format(
-                    version, sys.version.split()[0]))
+    parser.add_argument('-v', '--version',
+                        action='version',
+                        version='The Fuck {} using Python {}'.format(
+                            version, sys.version.split()[0]))
     parser.add_argument('-a', '--alias',
                         action='store_true',
                         help='[custom-alias-name] prints alias for current shell')

thefuck/not_configured.py

@@ -0,0 +1,87 @@
+# Initialize output before importing any module, that can use colorama.
+from .system import init_output
+
+init_output()
+
+import os  # noqa: E402
+from psutil import Process  # noqa: E402
+import six  # noqa: E402
+from . import logs  # noqa: E402
+from .shells import shell  # noqa: E402
+from .conf import settings  # noqa: E402
+from .system import Path  # noqa: E402
+from .utils import get_cache_dir  # noqa: E402
+
+
+def _get_shell_pid():
+    """Returns parent process pid."""
+    proc = Process(os.getpid())
+
+    try:
+        return proc.parent().pid
+    except TypeError:
+        return proc.parent.pid
+
+
+def _get_not_configured_usage_tracker_path():
+    """Returns path of special file where we store latest shell pid."""
+    return Path(get_cache_dir()).joinpath('thefuck.last_not_configured_run')
+
+
+def _record_first_run():
+    """Records shell pid to tracker file."""
+    with _get_not_configured_usage_tracker_path().open('w') as tracker:
+        tracker.write(six.text_type(_get_shell_pid()))
+
+
+def _is_second_run():
+    """Returns `True` when we know that `fuck` called second time."""
+    tracker_path = _get_not_configured_usage_tracker_path()
+    if not tracker_path.exists() or not shell.get_history()[-1] == 'fuck':
+        return False
+
+    current_pid = _get_shell_pid()
+    with tracker_path.open('r') as tracker:
+        return tracker.read() == six.text_type(current_pid)
+
+
+def _is_already_configured(configuration_details):
+    """Returns `True` when alias already in shell config."""
+    path = Path(configuration_details.path).expanduser()
+    with path.open('r') as shell_config:
+        return configuration_details.content in shell_config.read()
+
+
+def _configure(configuration_details):
+    """Adds alias to shell config."""
+    path = Path(configuration_details.path).expanduser()
+    with path.open('a') as shell_config:
+        shell_config.write(u'\n')
+        shell_config.write(configuration_details.content)
+        shell_config.write(u'\n')
+
+
+def main():
+    """Shows useful information about how-to configure alias on a first run
+    and configure automatically on a second.
+
+    It'll be only visible when user type fuck and when alias isn't configured.
+
+    """
+    settings.init()
+    configuration_details = shell.how_to_configure()
+    if (
+        configuration_details and
+        configuration_details.can_configure_automatically
+    ):
+        if _is_already_configured(configuration_details):
+            logs.already_configured(configuration_details)
+            return
+        elif _is_second_run():
+            _configure(configuration_details)
+            logs.configured_successfully(configuration_details)
+            return
+        else:
+            _record_first_run()
+
+    logs.how_to_configure_alias(configuration_details)

thefuck/rules/apt_get.py

@@ -29,7 +29,7 @@ def get_package(executable):
 
 
 def match(command):
-    if 'not found' in command.stderr:
+    if 'not found' in command.stderr or 'not installed' in command.stderr:
         executable = _get_executable(command)
         return not which(executable) and get_package(executable)
     else:

thefuck/rules/brew_unknown_command.py

@@ -54,8 +54,8 @@ def _brew_commands():
     brew_path_prefix = get_brew_path_prefix()
     if brew_path_prefix:
         try:
-            return _get_brew_commands(brew_path_prefix) \
-                   + _get_brew_tap_specific_commands(brew_path_prefix)
+            return (_get_brew_commands(brew_path_prefix)
+                    + _get_brew_tap_specific_commands(brew_path_prefix))
         except OSError:
             pass
 

thefuck/rules/dirty_unzip.py

@@ -39,7 +39,7 @@ def match(command):
 
 def get_new_command(command):
     return u'{} -d {}'.format(
-            command.script, shell.quote(_zip_file(command)[:-4]))
+        command.script, shell.quote(_zip_file(command)[:-4]))
 
 
 def side_effect(old_cmd, command):

thefuck/rules/dry.py

@@ -9,6 +9,7 @@ def match(command):
 def get_new_command(command):
     return ' '.join(command.script_parts[1:])
 
+
 # it should be rare enough to actually have to type twice the same word, so
 # this rule can have a higher priority to come before things like "cd cd foo"
 priority = 900

thefuck/rules/fix_file.py

@@ -40,6 +40,8 @@ def _make_pattern(pattern):
                      .replace('{line}', '(?P<line>[0-9]+)') \
                      .replace('{col}', '(?P<col>[0-9]+)')
     return re.compile(pattern, re.MULTILINE)
+
+
 patterns = [_make_pattern(p).search for p in patterns]
 
 

thefuck/rules/gem_unknown_command.py

@@ -0,0 +1,32 @@
+import re
+import subprocess
+from thefuck.utils import for_app, eager, replace_command
+
+
+@for_app('gem')
+def match(command):
+    return ('ERROR:  While executing gem ... (Gem::CommandLineError)'
+            in command.stderr
+            and 'Unknown command' in command.stderr)
+
+
+def _get_unknown_command(command):
+    return re.findall(r'Unknown command (.*)$', command.stderr)[0]
+
+
+@eager
+def _get_all_commands():
+    proc = subprocess.Popen(['gem', 'help', 'commands'],
+                            stdout=subprocess.PIPE)
+
+    for line in proc.stdout.readlines():
+        line = line.decode()
+
+        if line.startswith('    '):
+            yield line.strip().split(' ')[0]
+
+
+def get_new_command(command):
+    unknown_command = _get_unknown_command(command)
+    all_commands = _get_all_commands()
+    return replace_command(command, unknown_command, all_commands)

thefuck/rules/git_add_force.py

@@ -0,0 +1,13 @@
+from thefuck.utils import replace_argument
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return ('add' in command.script_parts
+            and 'Use -f if you really want to add them.' in command.stderr)
+
+
+@git_support
+def get_new_command(command):
+    return replace_argument(command.script, 'add', 'add --force')

thefuck/rules/git_fix_stash.py

@@ -11,6 +11,7 @@ def match(command):
     else:
         return False
 
+
 # git's output here is too complicated to be parsed (see the test file)
 stash_commands = (
     'apply',

thefuck/rules/git_pull_uncommitted_changes.py

@@ -6,7 +6,7 @@ from thefuck.specific.git import git_support
 def match(command):
     return ('pull' in command.script
             and ('You have unstaged changes' in command.stderr
-            or 'contains uncommitted changes' in command.stderr))
+                 or 'contains uncommitted changes' in command.stderr))
 
 
 @git_support

thefuck/rules/git_rm_staged.py

@@ -0,0 +1,19 @@
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return (' rm ' in command.script and
+            'error: the following file has changes staged in the index' in command.stderr and
+            'use --cached to keep the file, or -f to force removal' in command.stderr)
+
+
+@git_support
+def get_new_command(command):
+    command_parts = command.script_parts[:]
+    index = command_parts.index('rm') + 1
+    command_parts.insert(index, '--cached')
+    command_list = [u' '.join(command_parts)]
+    command_parts[index] = '-f'
+    command_list.append(u' '.join(command_parts))
+    return command_list

thefuck/rules/git_tag_force.py

@@ -0,0 +1,13 @@
+from thefuck.utils import replace_argument
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return ('tag' in command.script_parts
+            and 'already exists' in command.stderr)
+
+
+@git_support
+def get_new_command(command):
+    return replace_argument(command.script, 'tag', 'tag --force')

thefuck/rules/hostscli.py

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

thefuck/rules/ifconfig_device_not_found.py

@@ -1,6 +1,6 @@
 import subprocess
 from thefuck.utils import for_app, replace_command, eager
-import sys
+
 
 @for_app('ifconfig')
 def match(command):
@@ -21,5 +21,3 @@ def get_new_command(command):
     interface = command.stderr.split(' ')[0][:-1]
     possible_interfaces = _get_possible_interfaces()
     return replace_command(command, interface, possible_interfaces)
-
-

thefuck/rules/man_no_space.py

@@ -6,4 +6,5 @@ def match(command):
 def get_new_command(command):
     return u'man {}'.format(command.script[3:])
 
+
 priority = 2000

thefuck/rules/missing_space_before_subcommand.py

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

thefuck/rules/pacman.py

@@ -13,4 +13,5 @@ def get_new_command(command):
     return [formatme.format(pacman, package, command.script)
             for package in packages]
 
+
 enabled_by_default, pacman = archlinux_env()

thefuck/rules/path_from_history.py

@@ -0,0 +1,53 @@
+from collections import Counter
+import re
+from thefuck.system import Path
+from thefuck.utils import (get_valid_history_without_current,
+                           memoize, replace_argument)
+from thefuck.shells import shell
+
+
+patterns = [r'no such file or directory: (.*)$',
+            r"cannot access '(.*)': No such file or directory",
+            r': (.*): No such file or directory',
+            r"can't cd to (.*)$"]
+
+
+@memoize
+def _get_destination(command):
+    for pattern in patterns:
+        found = re.findall(pattern, command.stderr)
+        if found:
+            if found[0] in command.script_parts:
+                return found[0]
+
+
+def match(command):
+    return bool(_get_destination(command))
+
+
+def _get_all_absolute_paths_from_history(command):
+    counter = Counter()
+
+    for line in get_valid_history_without_current(command):
+        splitted = shell.split_command(line)
+
+        for param in splitted[1:]:
+            if param.startswith('/') or param.startswith('~'):
+                if param.endswith('/'):
+                    param = param[:-1]
+
+                counter[param] += 1
+
+    return (path for path, _ in counter.most_common(None))
+
+
+def get_new_command(command):
+    destination = _get_destination(command)
+    paths = _get_all_absolute_paths_from_history(command)
+
+    return [replace_argument(command.script, destination, path)
+            for path in paths if path.endswith(destination)
+            and Path(path).expanduser().exists()]
+
+
+priority = 800

thefuck/rules/scm_correction.py

@@ -0,0 +1,32 @@
+from thefuck.utils import for_app, memoize
+from thefuck.system import Path
+
+path_to_scm = {
+    '.git': 'git',
+    '.hg': 'hg',
+}
+
+wrong_scm_patterns = {
+    'git': 'fatal: Not a git repository',
+    'hg': 'abort: no repository found',
+}
+
+
+@memoize
+def _get_actual_scm():
+    for path, scm in path_to_scm.items():
+        if Path(path).is_dir():
+            return scm
+
+
+@for_app(*wrong_scm_patterns.keys())
+def match(command):
+    scm = command.script_parts[0]
+    pattern = wrong_scm_patterns[scm]
+
+    return pattern in command.stderr and _get_actual_scm()
+
+
+def get_new_command(command):
+    scm = _get_actual_scm()
+    return u' '.join([scm] + command.script_parts[1:])

thefuck/rules/sudo.py

@@ -20,7 +20,8 @@ patterns = ['permission denied',
             'authentication is required',
             'edspermissionerror',
             'you don\'t have write permissions',
-            'use `sudo`']
+            'use `sudo`',
+            'SudoRequiredError']
 
 
 def match(command):

thefuck/rules/sudo_command_from_user_path.py

@@ -0,0 +1,21 @@
+import re
+from thefuck.utils import for_app, which, replace_argument
+
+
+def _get_command_name(command):
+    found = re.findall(r'sudo: (.*): command not found', command.stderr)
+    if found:
+        return found[0]
+
+
+@for_app('sudo')
+def match(command):
+    if 'command not found' in command.stderr:
+        command_name = _get_command_name(command)
+        return which(command_name)
+
+
+def get_new_command(command):
+    command_name = _get_command_name(command)
+    return replace_argument(command.script, command_name,
+                            u'env "PATH=$PATH" {}'.format(command_name))

thefuck/rules/switch_lang.py

@@ -33,8 +33,8 @@ def match(command):
     if 'not found' not in command.stderr:
         return False
     matched_layout = _get_matched_layout(command)
-    return matched_layout and \
-           _switch_command(command, matched_layout) != get_alias()
+    return (matched_layout and
+            _switch_command(command, matched_layout) != get_alias())
 
 
 def get_new_command(command):

thefuck/rules/unknown_command.py

@@ -3,8 +3,8 @@ from thefuck.utils import replace_command
 
 
 def match(command):
-    return (re.search(r"([^:]*): Unknown command.*", command.stderr) != None
-            and re.search(r"Did you mean ([^?]*)?", command.stderr) != None)
+    return (re.search(r"([^:]*): Unknown command.*", command.stderr) is not None
+            and re.search(r"Did you mean ([^?]*)?", command.stderr) is not None)
 
 
 def get_new_command(command):

thefuck/rules/vagrant_up.py

@@ -13,8 +13,9 @@ def get_new_command(command):
     if len(cmds) >= 3:
         machine = cmds[2]
 
-    startAllInstances = shell.and_("vagrant up", command.script)
+    start_all_instances = shell.and_(u"vagrant up", command.script)
     if machine is None:
-        return startAllInstances
+        return start_all_instances
     else:
-        return [shell.and_("vagrant up " + machine, command.script), startAllInstances]
+        return [shell.and_(u"vagrant up {}".format(machine), command.script),
+                start_all_instances]

thefuck/rules/workon_doesnt_exists.py

@@ -26,7 +26,7 @@ def get_new_command(command):
 
     available = _get_all_environments()
     if available:
-        return replace_command(command, misspelled_env, available) \
-               + [create_new]
+        return (replace_command(command, misspelled_env, available)
+                + [create_new])
     else:
         return create_new

thefuck/rules/yarn_alias.py

@@ -0,0 +1,14 @@
+import re
+from thefuck.utils import replace_argument, for_app
+
+
+@for_app('yarn', at_least=1)
+def match(command):
+    return ('Did you mean' in command.stderr)
+
+
+def get_new_command(command):
+    broken = command.script_parts[1]
+    fix = re.findall(r'Did you mean `yarn ([^`]*)`', command.stderr)[0]
+
+    return replace_argument(command.script, broken, fix)

thefuck/rules/yarn_command_not_found.py

@@ -0,0 +1,31 @@
+import re
+from subprocess import Popen, PIPE
+from thefuck.utils import for_app, eager, replace_command
+
+regex = re.compile(r'error Command "(.*)" not found.')
+
+
+@for_app('yarn')
+def match(command):
+    return regex.findall(command.stderr)
+
+
+@eager
+def _get_all_tasks():
+    proc = Popen(['yarn', '--help'], stdout=PIPE)
+    should_yield = False
+    for line in proc.stdout.readlines():
+        line = line.decode().strip()
+
+        if 'Commands:' in line:
+            should_yield = True
+            continue
+
+        if should_yield and '- ' in line:
+            yield line.split(' ')[-1]
+
+
+def get_new_command(command):
+    misspelled_task = regex.findall(command.stderr)[0]
+    tasks = _get_all_tasks()
+    return replace_command(command, misspelled_task, tasks)

thefuck/rules/yarn_help.py

@@ -0,0 +1,17 @@
+import re
+from thefuck.utils import for_app
+from thefuck.system import open_command
+
+
+@for_app('yarn', at_least=2)
+def match(command):
+    return (command.script_parts[1] == 'help'
+            and 'for documentation about this command.' in command.stdout)
+
+
+def get_new_command(command):
+    url = re.findall(
+        r'Visit ([^ ]*) for documentation about this command.',
+        command.stdout)[0]
+
+    return open_command(url)

thefuck/shells/bash.py

@@ -44,4 +44,8 @@ class Bash(Generic):
             config = '~/.bashrc'
         else:
             config = 'bash config'
-        return 'eval $(thefuck --alias)', config
+
+        return self._create_shell_configuration(
+            content=u'eval $(thefuck --alias)',
+            path=config,
+            reload=u'source {}'.format(config))

thefuck/shells/fish.py

@@ -67,8 +67,10 @@ class Fish(Generic):
         return u'; and '.join(commands)
 
     def how_to_configure(self):
-        return (r"eval (thefuck --alias | tr '\n' ';')",
-                '~/.config/fish/config.fish')
+        return self._create_shell_configuration(
+            content=u"eval (thefuck --alias | tr '\n' ';')",
+            path='~/.config/fish/config.fish',
+            reload='fish')
 
     def put_to_history(self, command):
         try:

thefuck/shells/generic.py

@@ -2,8 +2,14 @@ import io
 import os
 import shlex
 import six
+from collections import namedtuple
 from ..utils import memoize
 from ..conf import settings
+from ..system import Path
+
+
+ShellConfiguration = namedtuple('ShellConfiguration', (
+    'content', 'path', 'reload', 'can_configure_automatically'))
 
 
 class Generic(object):
@@ -66,7 +72,12 @@ class Generic(object):
     def split_command(self, command):
         """Split the command using shell-like syntax."""
         encoded = self.encode_utf8(command)
-        splitted = shlex.split(encoded)
+
+        try:
+            splitted = shlex.split(encoded)
+        except ValueError:
+            splitted = encoded.split(' ')
+
         return self.decode_utf8(splitted)
 
     def encode_utf8(self, command):
@@ -99,3 +110,22 @@ class Generic(object):
         all shells support it (Fish).
 
         """
+
+    def get_builtin_commands(self):
+        """Returns shells builtin commands."""
+        return ['alias', 'bg', 'bind', 'break', 'builtin', 'case', 'cd',
+                'command', 'compgen', 'complete', 'continue', 'declare',
+                'dirs', 'disown', 'echo', 'enable', 'eval', 'exec', 'exit',
+                'export', 'fc', 'fg', 'getopts', 'hash', 'help', 'history',
+                'if', 'jobs', 'kill', 'let', 'local', 'logout', 'popd',
+                'printf', 'pushd', 'pwd', 'read', 'readonly', 'return', 'set',
+                'shift', 'shopt', 'source', 'suspend', 'test', 'times', 'trap',
+                'type', 'typeset', 'ulimit', 'umask', 'unalias', 'unset',
+                'until', 'wait', 'while']
+
+    def _create_shell_configuration(self, content, path, reload):
+        return ShellConfiguration(
+            content=content,
+            path=path,
+            reload=reload,
+            can_configure_automatically=Path(path).expanduser().exists())

thefuck/shells/powershell.py

@@ -1,13 +1,16 @@
-from .generic import Generic
+from .generic import Generic, ShellConfiguration
 
 
 class Powershell(Generic):
     def app_alias(self, fuck):
-        return 'function ' + fuck + ' { \n' \
-               '    $fuck = $(thefuck (Get-History -Count 1).CommandLine);\n' \
-               '    if (-not [string]::IsNullOrWhiteSpace($fuck)) {\n' \
-               '        if ($fuck.StartsWith("echo")) { $fuck = $fuck.Substring(5); }\n' \
-               '        else { iex "$fuck"; }\n' \
+        return 'function ' + fuck + ' {\n' \
+               '    $history = (Get-History -Count 1).CommandLine;\n' \
+               '    if (-not [string]::IsNullOrWhiteSpace($history)) {\n' \
+               '        $fuck = $(thefuck $history);\n' \
+               '        if (-not [string]::IsNullOrWhiteSpace($fuck)) {\n' \
+               '            if ($fuck.StartsWith("echo")) { $fuck = $fuck.Substring(5); }\n' \
+               '            else { iex "$fuck"; }\n' \
+               '        }\n' \
                '    }\n' \
                '}\n'
 
@@ -15,4 +18,8 @@ class Powershell(Generic):
         return u' -and '.join('({0})'.format(c) for c in commands)
 
     def how_to_configure(self):
-        return 'iex "thefuck --alias"', '$profile'
+        return ShellConfiguration(
+            content=u'iex "thefuck --alias"',
+            path='$profile',
+            reload='& $profile',
+            can_configure_automatically=False)

thefuck/shells/tcsh.py

@@ -19,9 +19,9 @@ class Tcsh(Generic):
     def get_aliases(self):
         proc = Popen(['tcsh', '-ic', 'alias'], stdout=PIPE, stderr=DEVNULL)
         return dict(
-                self._parse_alias(alias)
-                for alias in proc.stdout.read().decode('utf-8').split('\n')
-                if alias and '\t' in alias)
+            self._parse_alias(alias)
+            for alias in proc.stdout.read().decode('utf-8').split('\n')
+            if alias and '\t' in alias)
 
     def _get_history_file_name(self):
         return os.environ.get("HISTFILE",
@@ -31,4 +31,7 @@ class Tcsh(Generic):
         return u'#+{}\n{}\n'.format(int(time()), command_script)
 
     def how_to_configure(self):
-        return 'eval `thefuck --alias`', '~/.tcshrc'
+        return self._create_shell_configuration(
+            content=u'eval `thefuck --alias`',
+            path='~/.tcshrc',
+            reload='tcsh')

thefuck/shells/zsh.py

@@ -45,4 +45,7 @@ class Zsh(Generic):
             return ''
 
     def how_to_configure(self):
-        return 'eval $(thefuck --alias)', '~/.zshrc'
+        return self._create_shell_configuration(
+            content=u'eval $(thefuck --alias)',
+            path='~/.zshrc',
+            reload='source ~/.zshrc')

thefuck/specific/archlinux.py

@@ -24,8 +24,11 @@ def get_pkgfile(command):
         ).splitlines()
 
         return [package.split()[0] for package in packages]
-    except subprocess.CalledProcessError:
-        return None
+    except subprocess.CalledProcessError as err:
+        if err.returncode == 1 and err.output == "":
+            return []
+        else:
+            raise err
 
 
 def archlinux_env():

thefuck/system/__init__.py

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

thefuck/system/unix.py

@@ -3,6 +3,7 @@ import sys
 import tty
 import termios
 import colorama
+from distutils.spawn import find_executable
 from .. import const
 
 init_output = colorama.init
@@ -35,6 +36,13 @@ def get_key():
 
     return ch
 
+
+def open_command(arg):
+    if find_executable('xdg-open'):
+        return 'xdg-open ' + arg
+    return 'open ' + arg
+
+
 try:
     from pathlib import Path
 except ImportError:
@@ -44,5 +52,6 @@ except ImportError:
 def _expanduser(self):
     return self.__class__(os.path.expanduser(str(self)))
 
+
 if not hasattr(Path, 'expanduser'):
     Path.expanduser = _expanduser

thefuck/system/win32.py

@@ -23,9 +23,15 @@ def get_key():
     if ch == b'P':
         return const.KEY_DOWN
 
-    encoding = sys.stdout.encoding or os.environ.get('PYTHONIOENCODING', 'utf-8')
+    encoding = (sys.stdout.encoding
+                or os.environ.get('PYTHONIOENCODING', 'utf-8'))
     return ch.decode(encoding)
 
+
+def open_command(arg):
+    return 'cmd /c start ' + arg
+
+
 try:
     from pathlib import Path
 except ImportError:
@@ -35,5 +41,6 @@ except ImportError:
 def _expanduser(self):
     return self.__class__(os.path.expanduser(str(self)))
 
+
 # pathlib's expanduser fails on windows, see http://bugs.python.org/issue19776
 Path.expanduser = _expanduser

thefuck/types.py

@@ -40,8 +40,8 @@ class Command(object):
 
     def __eq__(self, other):
         if isinstance(other, Command):
-            return (self.script, self.stdout, self.stderr) \
-                   == (other.script, other.stdout, other.stderr)
+            return ((self.script, self.stdout, self.stderr)
+                    == (other.script, other.stdout, other.stderr))
         else:
             return False
 
@@ -159,12 +159,12 @@ class Rule(object):
 
     def __eq__(self, other):
         if isinstance(other, Rule):
-            return (self.name, self.match, self.get_new_command,
-                    self.enabled_by_default, self.side_effect,
-                    self.priority, self.requires_output) \
-                   == (other.name, other.match, other.get_new_command,
-                       other.enabled_by_default, other.side_effect,
-                       other.priority, other.requires_output)
+            return ((self.name, self.match, self.get_new_command,
+                     self.enabled_by_default, self.side_effect,
+                     self.priority, self.requires_output)
+                    == (other.name, other.match, other.get_new_command,
+                        other.enabled_by_default, other.side_effect,
+                        other.priority, other.requires_output))
         else:
             return False
 
@@ -172,9 +172,9 @@ class Rule(object):
         return 'Rule(name={}, match={}, get_new_command={}, ' \
                'enabled_by_default={}, side_effect={}, ' \
                'priority={}, requires_output)'.format(
-            self.name, self.match, self.get_new_command,
-            self.enabled_by_default, self.side_effect,
-            self.priority, self.requires_output)
+                   self.name, self.match, self.get_new_command,
+                   self.enabled_by_default, self.side_effect,
+                   self.priority, self.requires_output)
 
     @classmethod
     def from_path(cls, path):