Bump to 3.10

Fix functional tests on travis-ci

.travis.yml

@@ -5,17 +5,13 @@ python:
   - "3.4"
   - "3.3"
   - "2.7"
+services:
+  - docker
 addons:
   apt:
-    sources:
-      - fish-shell/release-2
     packages:
-      - bash
-      - zsh
-      - fish
-      - tcsh
-      - pandoc
-      - git
+      - python-commandnotfound
+      - python3-commandnotfound
 install:
   - pip install -U pip
   - pip install -U coveralls
@@ -24,5 +20,8 @@ install:
   - rm -rf build
 script:
   - export COVERAGE_PYTHON_VERSION=python-${TRAVIS_PYTHON_VERSION:0:1}
-  - coverage run --source=thefuck,tests -m py.test -v --capture=sys --run-without-docker --enable-functional
-after_success: coveralls
+  - export RUN_TESTS="coverage run --source=thefuck,tests -m py.test -v --capture=sys"
+  - if [[ $TRAVIS_PYTHON_VERSION == 3.5 ]]; then $RUN_TESTS --enable-functional; fi
+  - if [[ $TRAVIS_PYTHON_VERSION != 3.5 ]]; then $RUN_TESTS; fi
+after_success:
+  - coveralls

README.md

@@ -1,10 +1,10 @@
-# The Fuck [![Build Status](https://travis-ci.org/nvbn/thefuck.svg?branch=master)](https://travis-ci.org/nvbn/thefuck) 
+# The Fuck [![Version][version-badge]][version-link] [![Build Status][travis-badge]][travis-link] [![Windows Build Status][appveyor-badge]][appveyor-link] [![Coverage][coverage-badge]][coverage-link] [![MIT License][license-badge]](LICENSE.md)
 
 Magnificent app which corrects your previous console command,
 inspired by a [@liamosaur](https://twitter.com/liamosaur/)
 [tweet](https://twitter.com/liamosaur/status/506975850596536320).
 
-[![gif with examples](https://raw.githubusercontent.com/nvbn/thefuck/master/example.gif)](https://raw.githubusercontent.com/nvbn/thefuck/master/example.gif)
+[![gif with examples][examples-link]][examples-link]
 
 Few more examples:
 
@@ -52,7 +52,7 @@ Python 3.4.2 (default, Oct  8 2014, 13:08:17)
 git: 'brnch' is not a git command. See 'git --help'.
 
 Did you mean this?
-	branch
+    branch
 
 ➜ fuck
 git branch [enter/↑/↓/ctrl+c]
@@ -94,20 +94,26 @@ Reading package lists... Done
 - pip
 - python-dev
 
-## Installation [*experimental*]
+## Installation
+
+On OS X you can install `The Fuck` with [Homebrew][homebrew]:
 
-On Ubuntu and OS X you can install `The Fuck` with installation script:
- 
 ```bash
-wget -O - https://raw.githubusercontent.com/nvbn/thefuck/master/install.sh | sh - && $0
+brew install thefuck
 ```
 
-## Manual installation
+On Ubuntu you can install `The Fuck` with:
+ 
+```bash
+sudo apt update
+sudo apt install python3-dev python3-pip
+sudo -H pip3 install thefuck
+```
 
-Install `The Fuck` with `pip`:
+On other systems you can install `The Fuck` with `pip`:
 
 ```bash
-sudo pip install thefuck
+sudo -H pip install thefuck
 ```
 
 [Or using an OS package manager (OS X, Ubuntu, Arch).](https://github.com/nvbn/thefuck/wiki/Installation)
@@ -144,6 +150,7 @@ using the matched rule and runs it. Rules enabled by default are as follows:
 * `cd_correction` – spellchecks and correct failed cd commands;
 * `cd_mkdir` – creates directories before cd'ing into them;
 * `cd_parent` – changes `cd..` to `cd ..`;
+* `chmod_x` – add execution bit;
 * `composer_not_command` – fixes composer command name;
 * `cp_omitting_directory` – adds `-a` when you `cp` directory;
 * `cpp11` – adds missing `-std=c++11` to `g++` or `clang++`;
@@ -155,17 +162,22 @@ using the matched rule and runs it. Rules enabled by default are as follows:
 * `dry` – fixes repetitions like `git git push`;
 * `fix_alt_space` – replaces Alt+Space with Space character;
 * `fix_file` – opens a file with an error in your `$EDITOR`;
-* `git_add` – fixes *"Did you forget to 'git add'?"*;
+* `git_add` – fixes *"pathspec 'foo' did not match any file(s) known to git."*;
 * `git_branch_delete` – changes `git branch -d` to `git branch -D`;
+* `git_branch_exists` – offers `git branch -d foo`, `git branch -D foo` or `git checkout foo` when creating a branch that already exists;
 * `git_branch_list` – catches `git branch list` in place of `git branch` and removes created branch;
 * `git_checkout` – fixes branch name or creates new branch;
 * `git_diff_staged` – adds `--staged` to previous `git diff` with unexpected output;
 * `git_fix_stash` – fixes `git stash` commands (misspelled subcommand and missing `save`);
+* `git_help_aliased` &ndash; fixes `git help <alias>` commands replacing <alias> with the aliased command;
 * `git_not_command` &ndash; fixes wrong git commands like `git brnch`;
 * `git_pull` &ndash; sets upstream before executing previous `git pull`;
 * `git_pull_clone` &ndash; clones instead of pulling when the repo does not exist;
 * `git_push` &ndash; adds `--set-upstream origin $branch` to previous failed `git push`;
 * `git_push_pull` &ndash; runs `git pull` when `push` was rejected;
+* `git_rebase_no_changes` &ndash; runs `git rebase --skip` instead of `git rebase --continue` when there are no changes;
+* `git_rm_recursive` &ndash; adds `-r` when you try to `rm` a directory;
+* `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_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;
@@ -179,6 +191,7 @@ using the matched rule and runs it. Rules enabled by default are as follows:
 * `javac` &ndash; appends missing `.java` when compiling Java files;
 * `lein_not_task` &ndash; fixes wrong `lein` tasks like `lein rpl`;
 * `ln_no_hard_link` &ndash; catches hard link creation on directories, suggest symbolic link;
+* `ln_s_order` &ndash; fixes `ln -s` arguments order;
 * `ls_lah` &ndash; adds `-lah` to `ls`;
 * `man` &ndash; changes manual section;
 * `man_no_space` &ndash; fixes man commands without spaces, for example `mandiff`;
@@ -217,6 +230,7 @@ Enabled by default only on specific platforms:
 * `apt_invalid_operation` &ndash; fixes invalid `apt` and `apt-get` calls, like `apt-get isntall vim`;
 * `brew_install` &ndash; fixes formula name for `brew install`;
 * `brew_unknown_command` &ndash; fixes wrong brew commands, for example `brew docto/brew doctor`;
+* `brew_update_formula` &ndash; turns `brew update <formula>` into `brew upgrade <formula>`;
 * `brew_upgrade` &ndash; appends `--all` to `brew upgrade` as per Homebrew's new behaviour;
 * `pacman` &ndash; installs app with `pacman` if it is not installed (uses `yaourt` if available);
 * `pacman_not_found` &ndash; fixes package name with `pacman` or `yaourt`.
@@ -303,7 +317,7 @@ debug = False
 Or via environment variables:
 
 * `THEFUCK_RULES` &ndash; list of enabled rules, like `DEFAULT_RULES:rm_root` or `sudo:no_command`;
-* `THEFUCK_EXCLUDE_RULES` &ndash; list of disabled rules, like `git_pull:git_push`; 
+* `THEFUCK_EXCLUDE_RULES` &ndash; list of disabled rules, like `git_pull:git_push`;
 * `THEFUCK_REQUIRE_CONFIRMATION` &ndash; require confirmation before running new command, `true/false`;
 * `THEFUCK_WAIT_COMMAND` &ndash; max amount of time in seconds for getting previous command output;
 * `THEFUCK_NO_COLORS` &ndash; disable colored output, `true/false`;
@@ -355,3 +369,16 @@ sudo apt-get install pandoc
 
 ## License MIT
 Project License can be found [here](LICENSE.md).
+
+
+[version-badge]:   https://img.shields.io/pypi/v/thefuck.svg?label=version
+[version-link]:    https://pypi.python.org/pypi/thefuck/
+[travis-badge]:    https://img.shields.io/travis/nvbn/thefuck.svg
+[travis-link]:     https://travis-ci.org/nvbn/thefuck
+[appveyor-badge]:  https://img.shields.io/appveyor/ci/nvbn/thefuck.svg?label=windows%20build
+[appveyor-link]:   https://ci.appveyor.com/project/nvbn/thefuck
+[coverage-badge]:  https://img.shields.io/coveralls/nvbn/thefuck.svg
+[coverage-link]:   https://coveralls.io/github/nvbn/thefuck
+[license-badge]:   https://img.shields.io/badge/license-MIT-007EC7.svg
+[examples-link]:   https://raw.githubusercontent.com/nvbn/thefuck/master/example.gif
+[homebrew]:        http://brew.sh/

appveyor.yml

@@ -0,0 +1,22 @@
+build: false
+
+environment:
+  matrix:
+    - PYTHON: "C:/Python27"
+    - PYTHON: "C:/Python33"
+    - PYTHON: "C:/Python34"
+    - PYTHON: "C:/Python35"
+
+init:
+  - "ECHO %PYTHON%"
+  - ps: "ls C:/Python*"
+
+install:
+  - ps: (new-object net.webclient).DownloadFile('https://bootstrap.pypa.io/get-pip.py', 'C:/get-pip.py')
+  - "%PYTHON%/python.exe C:/get-pip.py"
+  - "%PYTHON%/Scripts/pip.exe install -U setuptools"
+  - "%PYTHON%/python.exe setup.py develop"
+  - "%PYTHON%/Scripts/pip.exe install -U -r requirements.txt"
+
+test_script:
+  - "%PYTHON%/Scripts/py.test.exe -sv"

install.sh

@@ -1,61 +1,4 @@
 #!/bin/sh
 
-should_add_alias () {
-    [ -f $1 ] && ! grep -q thefuck $1
-}
-
-installed () {
-    hash $1 2>/dev/null
-}
-
-install_thefuck () {
-    # Install OS dependencies:
-    if installed apt-get; then
-        # Debian/Ubuntu:
-        sudo apt-get update -yy
-        sudo apt-get install -yy python-pip python-dev command-not-found python-gdbm
-
-        if [ -n "$(apt-cache search python-commandnotfound)" ]; then
-            # In case of different python versions:
-            sudo apt-get install -yy python-commandnotfound
-        fi
-    else
-        if installed brew; then
-            # OS X:
-            brew update
-            brew install python
-        else
-            # Generic way:
-            wget https://bootstrap.pypa.io/get-pip.py
-            sudo python get-pip.py
-            rm get-pip.py
-        fi
-    fi
-
-    # thefuck requires fresh versions of setuptools and pip:
-    sudo pip install -U pip setuptools
-    sudo pip install -U thefuck
-
-    # Setup aliases:
-    if should_add_alias ~/.bashrc; then
-        echo 'eval $(thefuck --alias)' >> ~/.bashrc
-    fi
-
-    if should_add_alias ~/.bash_profile; then
-        echo 'eval $(thefuck --alias)' >> ~/.bash_profile
-    fi
-
-    if should_add_alias ~/.zshrc; then
-        echo 'eval $(thefuck --alias)' >> ~/.zshrc
-    fi
-
-    if should_add_alias ~/.config/fish/config.fish; then
-        thefuck --alias >> ~/.config/fish/config.fish
-    fi
-
-    if should_add_alias ~/.tcshrc; then
-        echo 'eval `thefuck --alias`' >> ~/.tcshrc
-    fi
-}
-
-install_thefuck
+echo "Installation script is deprecated!"
+echo "For installation instruction please visit https://github.com/nvbn/thefuck"

setup.py

@@ -26,10 +26,10 @@ elif (3, 0) < version < (3, 3):
           ' ({}.{} detected).'.format(*version))
     sys.exit(-1)
 
-VERSION = '3.4'
+VERSION = '3.10'
 
 install_requires = ['psutil', 'colorama', 'six', 'decorator']
-extras_require = {':python_version<"3.4"': ['pathlib'],
+extras_require = {':python_version<"3.4"': ['pathlib2'],
                   ":sys_platform=='win32'": ['win_unicode_console']}
 
 setup(name='thefuck',

tests/conftest.py

@@ -1,4 +1,7 @@
-from pathlib import Path
+try:
+    from pathlib import Path
+except ImportError:
+    from pathlib2 import Path
 import pytest
 from thefuck import shells
 from thefuck import conf, const

tests/functional/test_fish.py

@@ -29,25 +29,25 @@ def proc(request, spawnu):
 
 
 @pytest.mark.functional
-@pytest.mark.skip_without_docker
+@pytest.mark.once_without_docker
 def test_with_confirmation(proc, TIMEOUT):
     with_confirmation(proc, TIMEOUT)
 
 
 @pytest.mark.functional
-@pytest.mark.skip_without_docker
+@pytest.mark.once_without_docker
 def test_select_command_with_arrows(proc, TIMEOUT):
     select_command_with_arrows(proc, TIMEOUT)
 
 
 @pytest.mark.functional
-@pytest.mark.skip_without_docker
+@pytest.mark.once_without_docker
 def test_refuse_with_confirmation(proc, TIMEOUT):
     refuse_with_confirmation(proc, TIMEOUT)
 
 
 @pytest.mark.functional
-@pytest.mark.skip_without_docker
+@pytest.mark.once_without_docker
 def test_without_confirmation(proc, TIMEOUT):
     without_confirmation(proc, TIMEOUT)
 

tests/functional/test_install.py

@@ -1,25 +0,0 @@
-import pytest
-from thefuck.utils import get_installation_info
-
-envs = ((u'bash', 'thefuck/ubuntu-bash', u'''
-FROM ubuntu:latest
-RUN apt-get update
-RUN apt-get install -yy bash
-'''), (u'bash', 'thefuck/generic-bash', u'''
-FROM fedora:latest
-RUN dnf install -yy python-devel sudo wget gcc
-'''))
-
-
-@pytest.mark.functional
-@pytest.mark.skip_without_docker
-@pytest.mark.parametrize('shell, tag, dockerfile', envs)
-def test_installation(spawnu, shell, TIMEOUT, tag, dockerfile):
-    proc = spawnu(tag, dockerfile, shell)
-    proc.sendline(u'cat /src/install.sh | sh - && $0')
-    proc.sendline(u'thefuck --version')
-    version = get_installation_info().version
-    assert proc.expect([TIMEOUT, u'thefuck {}'.format(version)],
-                       timeout=600)
-    proc.sendline(u'fuck')
-    assert proc.expect([TIMEOUT, u'No fucks given'])

tests/functional/test_performance.py

@@ -40,7 +40,7 @@ def plot(proc, TIMEOUT):
 
 
 @pytest.mark.functional
-@pytest.mark.skip_without_docker
+@pytest.mark.once_without_docker
 @pytest.mark.benchmark(min_rounds=10)
 def test_performance(spawnu, TIMEOUT, benchmark):
     proc = spawnu(u'thefuck/ubuntu-python3-bash-performance',

tests/functional/test_tcsh.py

@@ -25,6 +25,7 @@ def proc(request, spawnu, run_without_docker):
     if not run_without_docker:
         proc.sendline(u'pip install /src')
     proc.sendline(u'tcsh')
+    proc.sendline(u'setenv PYTHONIOENCODING utf8')
     proc.sendline(u'eval `thefuck --alias`')
     return proc
 

tests/functional/test_zsh.py

@@ -49,7 +49,7 @@ def test_select_command_with_arrows(proc, TIMEOUT):
 
 
 @pytest.mark.functional
-@pytest.mark.skip_without_docker
+@pytest.mark.once_without_docker
 def test_refuse_with_confirmation(proc, TIMEOUT):
     refuse_with_confirmation(proc, TIMEOUT)
     history_not_changed(proc, TIMEOUT)

tests/rules/test_brew_update_formula.py

@@ -0,0 +1,30 @@
+import pytest
+from tests.utils import Command
+from thefuck.rules.brew_update_formula import get_new_command, match
+
+
+@pytest.fixture
+def stderr():
+    return ("Error: This command updates brew itself, and does not take formula"
+            " names.\nUse 'brew upgrade <formula>'.")
+
+
+@pytest.fixture
+def new_command(formula):
+    return 'brew upgrade {}'.format(formula)
+
+
+@pytest.mark.parametrize('script', ['brew update foo', 'brew update bar zap'])
+def test_match(stderr, script):
+    assert match(Command(script=script, stderr=stderr))
+
+
+@pytest.mark.parametrize('script', ['brew upgrade foo', 'brew update'])
+def test_not_match(script):
+    assert not match(Command(script=script, stderr=''))
+
+
+@pytest.mark.parametrize('script, formula, ', [
+    ('brew update foo', 'foo'), ('brew update bar zap', 'bar zap')])
+def test_get_new_command(stderr, new_command, script, formula):
+    assert get_new_command(Command(script=script, stderr=stderr)) == new_command

tests/rules/test_chmod_x.py

@@ -0,0 +1,39 @@
+import pytest
+from tests.utils import Command
+from thefuck.rules.chmod_x import match, get_new_command
+
+
+@pytest.fixture
+def file_exists(mocker):
+    return mocker.patch('os.path.exists', return_value=True)
+
+
+@pytest.fixture
+def file_access(mocker):
+    return mocker.patch('os.access', return_value=False)
+
+
+@pytest.mark.usefixtures('file_exists', 'file_access')
+@pytest.mark.parametrize('script, stderr', [
+    ('./gradlew build', 'gradlew: Permission denied'),
+    ('./install.sh --help', 'install.sh: permission denied')])
+def test_match(script, stderr):
+    assert match(Command(script, stderr=stderr))
+
+
+@pytest.mark.parametrize('script, stderr, exists, callable', [
+    ('./gradlew build', 'gradlew: Permission denied', True, True),
+    ('./gradlew build', 'gradlew: Permission denied', False, False),
+    ('./gradlew build', 'gradlew: error', True, False),
+    ('gradlew build', 'gradlew: Permission denied', True, False)])
+def test_not_match(file_exists, file_access, script, stderr, exists, callable):
+    file_exists.return_value = exists
+    file_access.return_value = callable
+    assert not match(Command(script, stderr=stderr))
+
+
+@pytest.mark.parametrize('script, result', [
+    ('./gradlew build', 'chmod +x gradlew && ./gradlew build'),
+    ('./install.sh --help', 'chmod +x install.sh && ./install.sh --help')])
+def test_get_new_command(script, result):
+    assert get_new_command(Command(script)) == result

tests/rules/test_git_add.py

@@ -4,36 +4,28 @@ from tests.utils import Command
 
 
 @pytest.fixture
-def did_not_match(target, did_you_forget=True):
-    error = ("error: pathspec '{}' did not match any "
-             "file(s) known to git.".format(target))
-    if did_you_forget:
-        error = ("{}\nDid you forget to 'git add'?'".format(error))
-    return error
+def stderr(target):
+    return ("error: pathspec '{}' did not match any "
+            'file(s) known to git.'.format(target))
 
 
-@pytest.mark.parametrize('command', [
-    Command(script='git submodule update unknown',
-            stderr=did_not_match('unknown')),
-    Command(script='git commit unknown',
-            stderr=did_not_match('unknown'))])  # Older versions of Git
-def test_match(command):
-    assert match(command)
+@pytest.mark.parametrize('script, target', [
+    ('git submodule update unknown', 'unknown'),
+    ('git commit unknown', 'unknown')])
+def test_match(stderr, script, target):
+    assert match(Command(script=script, stderr=stderr))
 
 
-@pytest.mark.parametrize('command', [
-    Command(script='git submodule update known', stderr=('')),
-    Command(script='git commit known', stderr=('')),
-    Command(script='git commit unknown',  # Newer versions of Git
-            stderr=did_not_match('unknown', False))])
-def test_not_match(command):
-    assert not match(command)
+@pytest.mark.parametrize('script', [
+    'git submodule update known', 'git commit known'])
+def test_not_match(script):
+    assert not match(Command(script=script, stderr=''))
 
 
-@pytest.mark.parametrize('command, new_command', [
-    (Command('git submodule update unknown', stderr=did_not_match('unknown')),
+@pytest.mark.parametrize('script, target, new_command', [
+    ('git submodule update unknown', 'unknown',
      'git add -- unknown && git submodule update unknown'),
-    (Command('git commit unknown', stderr=did_not_match('unknown')),  # Old Git
+    ('git commit unknown', 'unknown',
      'git add -- unknown && git commit unknown')])
-def test_get_new_command(command, new_command):
-    assert get_new_command(command) == new_command
+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_branch_exists.py

@@ -0,0 +1,33 @@
+import pytest
+from thefuck.rules.git_branch_exists import match, get_new_command
+from tests.utils import Command
+
+
+@pytest.fixture
+def stderr(branch_name):
+    return "fatal: A branch named '{}' already exists.".format(branch_name)
+
+
+@pytest.fixture
+def new_command(branch_name):
+    return [cmd.format(branch_name) for cmd in [
+        'git branch -d {0} && git branch {0}',
+        'git branch -D {0} && git branch {0}', 'git checkout {0}']]
+
+
+@pytest.mark.parametrize('script, branch_name', [
+    ('git branch foo', 'foo'),
+    ('git branch bar', 'bar')])
+def test_match(stderr, script, branch_name):
+    assert match(Command(script=script, stderr=stderr))
+
+
+@pytest.mark.parametrize('script', ['git branch foo', 'git branch bar'])
+def test_not_match(script):
+    assert not match(Command(script=script, stderr=''))
+
+
+@pytest.mark.parametrize('script, branch_name, ', [
+    ('git branch foo', 'foo'), ('git branch bar', 'bar')])
+def test_get_new_command(stderr, new_command, script, branch_name):
+    assert get_new_command(Command(script=script, stderr=stderr)) == new_command

tests/rules/test_git_help_aliased.py

@@ -0,0 +1,24 @@
+import pytest
+from thefuck.rules.git_help_aliased import match, get_new_command
+from tests.utils import Command
+
+
+@pytest.mark.parametrize('script, stdout', [
+    ('git help st', "`git st' is aliased to `status'"),
+    ('git help ds', "`git ds' is aliased to `diff --staged'")])
+def test_match(script, stdout):
+    assert match(Command(script=script, stdout=stdout))
+
+
+@pytest.mark.parametrize('script, stdout', [
+    ('git help status', "GIT-STATUS(1)...Git Manual...GIT-STATUS(1)"),
+    ('git help diff', "GIT-DIFF(1)...Git Manual...GIT-DIFF(1)")])
+def test_not_match(script, stdout):
+    assert not match(Command(script=script, stdout=stdout))
+
+
+@pytest.mark.parametrize('script, stdout, new_command', [
+    ('git help st', "`git st' is aliased to `status'", 'git help status'),
+    ('git help ds', "`git ds' is aliased to `diff --staged'", 'git help diff')])
+def test_get_new_command(script, stdout, new_command):
+    assert get_new_command(Command(script=script, stdout=stdout)) == new_command

tests/rules/test_git_rebase_no_changes.py

@@ -0,0 +1,28 @@
+import pytest
+from thefuck.rules.git_rebase_no_changes import match, get_new_command
+from tests.utils import Command
+
+
+@pytest.fixture
+def stdout():
+    return '''Applying: Test commit
+No changes - did you forget to use 'git add'?
+If there is nothing left to stage, chances are that something else
+already introduced the same changes; you might want to skip this patch.
+
+When you have resolved this problem, run "git rebase --continue".
+If you prefer to skip this patch, run "git rebase --skip" instead.
+To check out the original branch and stop rebasing, run "git rebase --abort".
+
+'''
+
+
+def test_match(stdout):
+    assert match(Command('git rebase --continue', stdout=stdout))
+    assert not match(Command('git rebase --continue'))
+    assert not match(Command('git rebase --skip'))
+
+
+def test_get_new_command(stdout):
+    assert (get_new_command(Command('git rebase --continue', stdout=stdout)) ==
+            'git rebase --skip')

tests/rules/test_git_remote_seturl_add.py

@@ -0,0 +1,26 @@
+import pytest
+from thefuck.rules.git_remote_seturl_add import match, get_new_command
+from tests.utils import Command
+
+
+@pytest.mark.parametrize('command', [
+    Command(script='git remote set-url origin url', stderr="fatal: No such remote")])
+def test_match(command):
+    assert match(command)
+
+
+@pytest.mark.parametrize('command', [
+    Command('git remote set-url origin url', stderr=""),
+    Command('git remote add origin url'),
+    Command('git remote remove origin'),
+    Command('git remote prune origin'),
+    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')])
+def test_get_new_command(command, new_command):
+    assert get_new_command(command) == new_command

tests/rules/test_git_rm_recursive.py

@@ -0,0 +1,27 @@
+import pytest
+from thefuck.rules.git_rm_recursive import match, get_new_command
+from tests.utils import Command
+
+
+@pytest.fixture
+def stderr(target):
+    return "fatal: not removing '{}' recursively without -r".format(target)
+
+
+@pytest.mark.parametrize('script, target', [
+    ('git rm foo', 'foo'),
+    ('git rm foo bar', 'foo 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'])
+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 -r foo'),
+    ('git rm foo bar', 'foo bar', 'git rm -r 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_history.py

@@ -3,38 +3,23 @@ from thefuck.rules.history import match, get_new_command
 from tests.utils import Command
 
 
-@pytest.fixture
-def history(mocker):
-    return mocker.patch('thefuck.shells.shell.get_history',
-                        return_value=['le cat', 'fuck', 'ls cat',
-                                      'diff x', 'nocommand x'])
+@pytest.fixture(autouse=True)
+def history_without_current(mocker):
+    return mocker.patch(
+        'thefuck.rules.history.get_valid_history_without_current',
+        return_value=['ls cat', 'diff x'])
 
 
-@pytest.fixture
-def alias(mocker):
-    return mocker.patch('thefuck.rules.history.get_alias',
-                        return_value='fuck')
-
-
-@pytest.fixture
-def callables(mocker):
-    return mocker.patch('thefuck.rules.history.get_all_executables',
-                        return_value=['diff', 'ls'])
-
-
-@pytest.mark.usefixtures('history', 'callables', 'no_memoize', 'alias')
 @pytest.mark.parametrize('script', ['ls cet', 'daff x'])
 def test_match(script):
     assert match(Command(script=script))
 
 
-@pytest.mark.usefixtures('history', 'callables', 'no_memoize', 'alias')
 @pytest.mark.parametrize('script', ['apt-get', 'nocommand y'])
 def test_not_match(script):
     assert not match(Command(script=script))
 
 
-@pytest.mark.usefixtures('history', 'callables', 'no_memoize', 'alias')
 @pytest.mark.parametrize('script, result', [
     ('ls cet', 'ls cat'),
     ('daff x', 'diff x')])

tests/rules/test_ln_no_hard_link.py

@@ -20,7 +20,7 @@ def test_match(script, stderr):
     ("ln a b", "... hard link"),
     ("sudo ln a b", "... hard link"),
     ("a b", error)])
-def test_assert_not_match(script, stderr):
+def test_not_match(script, stderr):
     command = Command(script, stderr=stderr)
     assert not match(command)
 

tests/rules/test_ln_s_order.py

@@ -0,0 +1,41 @@
+import pytest
+from thefuck.rules.ln_s_order import match, get_new_command
+from tests.utils import Command
+
+
+@pytest.fixture
+def file_exists(mocker):
+    return mocker.patch('os.path.exists', return_value=True)
+
+
+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),
+    ('ln -s dest source', '', True),
+    ('ln -s dest source', get_stderr('source'), False)])
+def test_not_match(file_exists, script, stderr, exists):
+    file_exists.return_value = exists
+    assert not match(Command(script, stderr=stderr))
+
+
+@pytest.mark.usefixtures('file_exists')
+@pytest.mark.parametrize('script, result', [
+    ('ln -s dest source', 'ln -s source dest'),
+    ('ln dest -s source', 'ln -s source dest'),
+    ('ln dest source -s', 'ln source -s dest')])
+def test_match(script, result):
+    stderr = get_stderr('source')
+    assert get_new_command(Command(script, stderr=stderr)) == result

tests/rules/test_no_command.py

@@ -6,22 +6,37 @@ from tests.utils import Command
 @pytest.fixture(autouse=True)
 def get_all_executables(mocker):
     mocker.patch('thefuck.rules.no_command.get_all_executables',
-                 return_value=['vim', 'apt-get', 'fsck'])
+                 return_value=['vim', 'fsck', 'git', 'go'])
+
+
+@pytest.fixture(autouse=True)
+def history_without_current(mocker):
+    return mocker.patch(
+        'thefuck.rules.no_command.get_valid_history_without_current',
+        return_value=['git commit'])
 
 
 @pytest.mark.usefixtures('no_memoize')
-def test_match():
-    assert match(Command(stderr='vom: not found', script='vom file.py'))
-    assert match(Command(stderr='fucck: not found', script='fucck'))
-    assert not match(Command(stderr='qweqwe: not found', script='qweqwe'))
-    assert not match(Command(stderr='some text', script='vom file.py'))
+@pytest.mark.parametrize('script, stderr', [
+    ('vom file.py', 'vom: not found'),
+    ('fucck', 'fucck: not found'),
+    ('got commit', 'got: command not found')])
+def test_match(script, stderr):
+    assert match(Command(script, stderr=stderr))
 
 
 @pytest.mark.usefixtures('no_memoize')
-def test_get_new_command():
-    assert get_new_command(
-        Command(stderr='vom: not found',
-                script='vom file.py')) == ['vim file.py']
-    assert get_new_command(
-        Command(stderr='fucck: not found',
-                script='fucck')) == ['fsck']
+@pytest.mark.parametrize('script, stderr', [
+    ('qweqwe', 'qweqwe: not found'),
+    ('vom file.py', 'some text')])
+def test_not_match(script, stderr):
+    assert not match(Command(script, stderr=stderr))
+
+
+@pytest.mark.usefixtures('no_memoize')
+@pytest.mark.parametrize('script, result', [
+    ('vom file.py', ['vim file.py']),
+    ('fucck', ['fsck']),
+    ('got commit', ['git commit', 'go commit'])])
+def test_get_new_command(script, result):
+    assert get_new_command(Command(script)) == result

tests/rules/test_ssh_known_host.py

@@ -52,6 +52,7 @@ def test_match(ssh_error):
     assert not match(Command('ssh'))
 
 
+@pytest.mark.skipif(os.name == 'nt', reason='Skip if testing on Windows')
 def test_side_effect(ssh_error):
     errormsg, path, reset, known_hosts = ssh_error
     command = Command('ssh user@host', stderr=errormsg)

tests/shells/test_bash.py

@@ -46,6 +46,13 @@ class TestBash(object):
         assert 'TF_ALIAS=fuck' in shell.app_alias('fuck')
         assert 'PYTHONIOENCODING=utf-8' in shell.app_alias('fuck')
 
+    def test_app_alias_variables_correctly_set(self, shell):
+        alias = shell.app_alias('fuck')
+        assert "alias fuck='TF_CMD=$(TF_ALIAS" in alias
+        assert '$(TF_ALIAS=fuck PYTHONIOENCODING' in alias
+        assert 'PYTHONIOENCODING=utf-8 TF_SHELL_ALIASES' in alias
+        assert 'ALIASES=$(alias) thefuck' in alias
+
     def test_get_history(self, history_lines, shell):
         history_lines(['ls', 'rm'])
         assert list(shell.get_history()) == ['ls', 'rm']

tests/shells/test_fish.py

@@ -19,14 +19,18 @@ class TestFish(object):
         return mock
 
     @pytest.fixture
-    def environ(self, monkeypatch):
-        data = {'TF_OVERRIDDEN_ALIASES': 'cd, ls, man, open'}
-        monkeypatch.setattr('thefuck.shells.fish.os.environ', data)
-        return data
+    def os_environ(self, monkeypatch, key, value):
+        monkeypatch.setattr('os.environ', {key: value})
 
-    @pytest.mark.usefixture('environ')
-    def test_get_overridden_aliases(self, shell, environ):
-        assert shell._get_overridden_aliases() == ['cd', 'ls', 'man', 'open']
+    @pytest.mark.parametrize('key, value', [
+        ('TF_OVERRIDDEN_ALIASES', 'cut,git,sed'),  # legacy
+        ('THEFUCK_OVERRIDDEN_ALIASES', 'cut,git,sed'),
+        ('THEFUCK_OVERRIDDEN_ALIASES', 'cut, git, sed'),
+        ('THEFUCK_OVERRIDDEN_ALIASES', ' cut,\tgit,sed\n'),
+        ('THEFUCK_OVERRIDDEN_ALIASES', '\ncut,\n\ngit,\tsed\r')])
+    def test_get_overridden_aliases(self, shell, os_environ):
+        assert shell._get_overridden_aliases() == {'cd', 'cut', 'git', 'grep',
+                                                   'ls', 'man', 'open', 'sed'}
 
     @pytest.mark.parametrize('before, after', [
         ('cd', 'cd'),
@@ -70,7 +74,24 @@ class TestFish(object):
         assert 'TF_ALIAS=fuck PYTHONIOENCODING' in shell.app_alias('fuck')
         assert 'PYTHONIOENCODING=utf-8 thefuck' in shell.app_alias('fuck')
 
+    def test_app_alias_alter_history(self, settings, shell):
+        settings.alter_history = True
+        assert 'history --delete' in shell.app_alias('FUCK')
+        assert 'history --merge' in shell.app_alias('FUCK')
+        settings.alter_history = False
+        assert 'history --delete' not in shell.app_alias('FUCK')
+        assert 'history --merge' not in shell.app_alias('FUCK')
+
     def test_get_history(self, history_lines, shell):
         history_lines(['- cmd: ls', '  when: 1432613911',
                        '- cmd: rm', '  when: 1432613916'])
         assert list(shell.get_history()) == ['ls', 'rm']
+
+    @pytest.mark.parametrize('entry, entry_utf8', [
+        ('ls', '- cmd: ls\n   when: 1430707243\n'),
+        (u'echo café', '- cmd: echo café\n   when: 1430707243\n')])
+    def test_put_to_history(self, entry, entry_utf8, builtins_open, mocker, shell):
+        mocker.patch('thefuck.shells.fish.time', return_value=1430707243.3517463)
+        shell.put_to_history(entry)
+        builtins_open.return_value.__enter__.return_value. \
+            write.assert_called_once_with(entry_utf8)

tests/shells/test_powershell.py

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+
+import pytest
+from thefuck.shells import Powershell
+
+
+@pytest.mark.usefixtures('isfile', 'no_memoize', 'no_cache')
+class TestPowershell(object):
+    @pytest.fixture
+    def shell(self):
+        return Powershell()
+
+    def test_and_(self, shell):
+        assert shell.and_('ls', 'cd') == '(ls) -and (cd)'
+
+    def test_app_alias(self, shell):
+        assert 'function fuck' in shell.app_alias('fuck')
+        assert 'function FUCK' in shell.app_alias('FUCK')
+        assert 'thefuck' in shell.app_alias('fuck')

tests/shells/test_zsh.py

@@ -45,6 +45,13 @@ class TestZsh(object):
         assert 'thefuck' in shell.app_alias('fuck')
         assert 'PYTHONIOENCODING' in shell.app_alias('fuck')
 
+    def test_app_alias_variables_correctly_set(self, shell):
+        alias = shell.app_alias('fuck')
+        assert "alias fuck='TF_CMD=$(TF_ALIAS" in alias
+        assert '$(TF_ALIAS=fuck PYTHONIOENCODING' in alias
+        assert 'PYTHONIOENCODING=utf-8 TF_SHELL_ALIASES' in alias
+        assert 'ALIASES=$(alias) thefuck' in alias
+
     def test_get_history(self, history_lines, shell):
         history_lines([': 1432613911:0;ls', ': 1432613916:0;rm'])
         assert list(shell.get_history()) == ['ls', 'rm']

tests/test_corrector.py

@@ -1,7 +1,12 @@
 # -*- coding: utf-8 -*-
 
 import pytest
-from pathlib import PosixPath
+try:
+    from pathlib import Path
+    pathlib_name = 'pathlib'
+except ImportError:
+    from pathlib2 import Path
+    pathlib_name = 'pathlib2'
 from thefuck import corrector, const
 from tests.utils import Rule, Command, CorrectedCommand
 from thefuck.corrector import get_corrected_commands, organize_commands
@@ -11,7 +16,7 @@ class TestGetRules(object):
     @pytest.fixture
     def glob(self, mocker):
         results = {}
-        mocker.patch('pathlib.Path.glob',
+        mocker.patch(pathlib_name + '.Path.glob',
                      new_callable=lambda: lambda *_: results.pop('value', []))
         return lambda value: results.update({'value': value})
 
@@ -30,7 +35,7 @@ class TestGetRules(object):
         (['git.py', 'bash.py'], ['git'], ['git'], [])])
     def test_get_rules(self, glob, settings, paths, conf_rules, exclude_rules,
                        loaded_rules):
-        glob([PosixPath(path) for path in paths])
+        glob([Path(path) for path in paths])
         settings.update(rules=conf_rules,
                         priority={},
                         exclude_rules=exclude_rules)

tests/test_types.py

@@ -1,8 +1,12 @@
 # -*- coding: utf-8 -*-
 
+import os
 from subprocess import PIPE
 from mock import Mock
-from pathlib import Path
+try:
+    from pathlib import Path
+except ImportError:
+    from pathlib2 import Path
 import pytest
 from tests.utils import CorrectedCommand, Rule, Command
 from thefuck import const
@@ -39,9 +43,10 @@ class TestRule(object):
                               enabled_by_default=True,
                               priority=900,
                               requires_output=True))
-        assert Rule.from_path(Path('/rules/bash.py')) \
+        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)
-        load_source.assert_called_once_with('bash', '/rules/bash.py')
+        load_source.assert_called_once_with('bash', rule_path)
 
     @pytest.mark.parametrize('rules, exclude_rules, rule, is_enabled', [
         (const.DEFAULT_RULES, [], Rule('git', enabled_by_default=True), True),
@@ -110,6 +115,7 @@ class TestCommand(object):
             'apt-get search vim', 'stdout', 'stderr')
         Popen.assert_called_once_with('apt-get search vim',
                                       shell=True,
+                                      stdin=PIPE,
                                       stdout=PIPE,
                                       stderr=PIPE,
                                       env={})

tests/test_ui.py

@@ -25,15 +25,16 @@ def test_read_actions(patch_get_key):
         # Ignored:
         'x', 'y',
         # Up:
-        const.KEY_UP,
+        const.KEY_UP, 'k',
         # Down:
-        const.KEY_DOWN,
+        const.KEY_DOWN, 'j',
         # Ctrl+C:
-        const.KEY_CTRL_C])
-    assert list(islice(ui.read_actions(), 5)) \
+        const.KEY_CTRL_C, 'q'])
+    assert list(islice(ui.read_actions(), 8)) \
            == [const.ACTION_SELECT, const.ACTION_SELECT,
-               const.ACTION_PREVIOUS, const.ACTION_NEXT,
-               const.ACTION_ABORT]
+               const.ACTION_PREVIOUS, const.ACTION_PREVIOUS,
+               const.ACTION_NEXT, const.ACTION_NEXT,
+               const.ACTION_ABORT, const.ACTION_ABORT]
 
 
 def test_command_selector():

tests/test_utils.py

@@ -1,9 +1,13 @@
+# -*- coding: utf-8 -*-
+
 import pytest
+import warnings
 from mock import Mock
 import six
 from thefuck.utils import default_settings, \
     memoize, get_closest, get_all_executables, replace_argument, \
-    get_all_matched_commands, is_app, for_app, cache, compatibility_call
+    get_all_matched_commands, is_app, for_app, cache, compatibility_call, \
+    get_valid_history_without_current
 from tests.utils import Command
 
 
@@ -198,7 +202,8 @@ class TestCompatibilityCall(object):
             assert settings == _settings
             return True
 
-        assert compatibility_call(match, Command())
+        with pytest.warns(UserWarning):
+            assert compatibility_call(match, Command())
 
     def test_get_new_command(self):
         def get_new_command(command):
@@ -213,7 +218,8 @@ class TestCompatibilityCall(object):
             assert settings == _settings
             return True
 
-        assert compatibility_call(get_new_command, Command())
+        with pytest.warns(UserWarning):
+            assert compatibility_call(get_new_command, Command())
 
     def test_side_effect(self):
         def side_effect(command, new_command):
@@ -228,4 +234,45 @@ class TestCompatibilityCall(object):
             assert settings == _settings
             return True
 
-        assert compatibility_call(side_effect, Command(), Command())
+        with pytest.warns(UserWarning):
+            assert compatibility_call(side_effect, Command(), Command())
+
+
+class TestGetValidHistoryWithoutCurrent(object):
+    @pytest.yield_fixture(autouse=True)
+    def fail_on_warning(self):
+        warnings.simplefilter('error')
+        yield
+        warnings.resetwarnings()
+
+    @pytest.fixture(autouse=True)
+    def history(self, mocker):
+        return mocker.patch('thefuck.shells.shell.get_history',
+                            return_value=['le cat', 'fuck', 'ls cat',
+                                          'diff x', 'nocommand x', u'café ô'])
+
+    @pytest.fixture(autouse=True)
+    def alias(self, mocker):
+        return mocker.patch('thefuck.utils.get_alias',
+                            return_value='fuck')
+
+    @pytest.fixture(autouse=True)
+    def bins(self, mocker, monkeypatch):
+        monkeypatch.setattr('thefuck.conf.os.environ', {'PATH': 'path'})
+        callables = list()
+        for name in ['diff', 'ls', 'café']:
+            bin_mock = mocker.Mock(name=name)
+            bin_mock.configure_mock(name=name, is_dir=lambda: False)
+            callables.append(bin_mock)
+        path_mock = mocker.Mock(iterdir=mocker.Mock(return_value=callables))
+        return mocker.patch('thefuck.utils.Path', return_value=path_mock)
+
+    @pytest.mark.parametrize('script, result', [
+        ('le cat', ['ls cat', 'diff x', u'café ô']),
+        ('diff x', ['ls cat', u'café ô']),
+        ('fuck', ['ls cat', 'diff x', u'café ô']),
+        (u'cafe ô', ['ls cat', 'diff x', u'café ô']),
+    ])
+    def test_get_valid_history_without_current(self, script, result):
+        command = Command(script=script)
+        assert get_valid_history_without_current(command) == result

thefuck/conf.py

@@ -1,7 +1,10 @@
 from imp import load_source
 import os
 import sys
-from pathlib import Path
+try:
+    from pathlib import Path
+except ImportError:
+    from pathlib2 import Path
 from six import text_type
 from . import const
 

thefuck/corrector.py

@@ -1,4 +1,7 @@
-from pathlib import Path
+try:
+    from pathlib import Path
+except ImportError:
+    from pathlib2 import Path
 from .conf import settings
 from .types import Rule
 from . import logs

thefuck/main.py

@@ -33,6 +33,8 @@ def fix_command():
 
         if selected_command:
             selected_command.run(command)
+        else:
+            sys.exit(1)
 
 
 def print_alias(entry_point=True):

thefuck/rules/brew_update_formula.py

@@ -0,0 +1,12 @@
+from thefuck.utils import for_app
+
+
+@for_app('brew', at_least=2)
+def match(command):
+    return ('update' in command.script
+            and "Error: This command updates brew itself" in command.stderr
+            and "Use 'brew upgrade <formula>'" in command.stderr)
+
+
+def get_new_command(command):
+    return command.script.replace('update', 'upgrade')

thefuck/rules/chmod_x.py

@@ -0,0 +1,15 @@
+import os
+from thefuck.shells import shell
+
+
+def match(command):
+    return (command.script.startswith('./')
+            and 'permission denied' in command.stderr.lower()
+            and os.path.exists(command.script_parts[0])
+            and not os.access(command.script_parts[0], os.X_OK))
+
+
+def get_new_command(command):
+    return shell.and_(
+        'chmod +x {}'.format(command.script_parts[0][2:]),
+        command.script)

thefuck/rules/git_add.py

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

thefuck/rules/git_branch_exists.py

@@ -0,0 +1,23 @@
+import re
+from thefuck.shells import shell
+from thefuck.specific.git import git_support
+from thefuck.utils import eager
+
+
+@git_support
+def match(command):
+    return ('branch' in command.script
+            and "fatal: A branch named '" in command.stderr
+            and " already exists." in command.stderr)
+
+
+@git_support
+@eager
+def get_new_command(command):
+    branch_name = re.findall(
+        r"fatal: A branch named '([^']*)' already exists.", command.stderr)[0]
+    new_command_templates = [['git branch -d {0}', 'git branch {0}'],
+                             ['git branch -D {0}', 'git branch {0}'],
+                             ['git checkout {0}']]
+    for new_command_template in new_command_templates:
+        yield shell.and_(*new_command_template).format(branch_name)

thefuck/rules/git_help_aliased.py

@@ -0,0 +1,12 @@
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return 'help' in command.script and ' is aliased to ' in command.stdout
+
+
+@git_support
+def get_new_command(command):
+    aliased = command.stdout.split('`', 2)[2].split("'", 1)[0].split(' ', 1)[0]
+    return 'git help {}'.format(aliased)

thefuck/rules/git_rebase_no_changes.py

@@ -0,0 +1,15 @@
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return ({'rebase', '--continue'}.issubset(command.script_parts) and
+            'No changes - did you forget to use \'git add\'?' in command.stdout)
+
+
+def get_new_command(command):
+    return 'git rebase --skip'
+
+
+enabled_by_default = True
+requires_output = True

thefuck/rules/git_remote_seturl_add.py

@@ -0,0 +1,14 @@
+from thefuck.utils import replace_argument
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return ('set-url' in command.script and 'fatal: No such remote' in command.stderr)
+
+
+def get_new_command(command):
+    return replace_argument(command.script, 'set-url', 'add')
+
+
+enabled_by_default = True

thefuck/rules/git_rm_recursive.py

@@ -0,0 +1,15 @@
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return (' rm ' in command.script
+            and "fatal: not removing '" in command.stderr
+            and "' recursively without -r" in command.stderr)
+
+
+@git_support
+def get_new_command(command):
+    index = command.script_parts.index('rm') + 1
+    command.script_parts.insert(index, '-r')
+    return u' '.join(command.script_parts)

thefuck/rules/history.py

@@ -1,37 +1,15 @@
 from difflib import get_close_matches
-from thefuck.shells import shell
-from thefuck.utils import get_closest, memoize, get_all_executables, get_alias
-
-
-def _not_corrected(history, tf_alias):
-    """Returns all lines from history except that comes before `fuck`."""
-    previous = None
-    for line in history:
-        if previous is not None and line != tf_alias:
-            yield previous
-        previous = line
-    if history:
-        yield history[-1]
-
-
-@memoize
-def _history_of_exists_without_current(command):
-    history = shell.get_history()
-    tf_alias = get_alias()
-    executables = get_all_executables()
-    return [line for line in _not_corrected(history, tf_alias)
-            if not line.startswith(tf_alias) and not line == command.script
-            and line.split(' ')[0] in executables]
+from thefuck.utils import get_closest, get_valid_history_without_current
 
 
 def match(command):
     return len(get_close_matches(command.script,
-                                 _history_of_exists_without_current(command)))
+                                 get_valid_history_without_current(command)))
 
 
 def get_new_command(command):
     return get_closest(command.script,
-                       _history_of_exists_without_current(command))
+                       get_valid_history_without_current(command))
 
 
 priority = 9999

thefuck/rules/ln_no_hard_link.py

@@ -15,7 +15,7 @@ from thefuck.specific.sudo import sudo_support
 @sudo_support
 def match(command):
     return (command.stderr.endswith("hard link not allowed for directory") and
-            command.script.startswith("ln "))
+            command.script_parts[0] == 'ln')
 
 
 @sudo_support

thefuck/rules/ln_s_order.py

@@ -0,0 +1,26 @@
+import os
+from thefuck.specific.sudo import sudo_support
+
+
+def _get_destination(script_parts):
+    """When arguments order is wrong first argument will be destination."""
+    for part in script_parts:
+        if part not in {'ln', '-s', '--symbolic'} and os.path.exists(part):
+            return part
+
+
+@sudo_support
+def match(command):
+    return (command.script_parts[0] == 'ln'
+            and {'-s', '--symbolic'}.intersection(command.script_parts)
+            and 'File exists' in command.stderr
+            and _get_destination(command.script_parts))
+
+
+@sudo_support
+def get_new_command(command):
+    destination = _get_destination(command.script_parts)
+    parts = command.script_parts[:]
+    parts.remove(destination)
+    parts.append(destination)
+    return ' '.join(parts)

thefuck/rules/no_command.py

@@ -1,5 +1,6 @@
 from difflib import get_close_matches
-from thefuck.utils import get_all_executables
+from thefuck.utils import get_all_executables, \
+    get_valid_history_without_current, get_closest
 from thefuck.specific.sudo import sudo_support
 
 
@@ -11,10 +12,29 @@ def match(command):
                                        get_all_executables())))
 
 
+def _get_used_executables(command):
+    for script in get_valid_history_without_current(command):
+        yield script.split(' ')[0]
+
+
 @sudo_support
 def get_new_command(command):
     old_command = command.script_parts[0]
-    new_cmds = get_close_matches(old_command, get_all_executables(), cutoff=0.1)
+
+    # One from history:
+    already_used = get_closest(
+        old_command, _get_used_executables(command),
+        fallback_to_first=False)
+    if already_used:
+        new_cmds = [already_used]
+    else:
+        new_cmds = []
+
+    # Other from all executables:
+    new_cmds += [cmd for cmd in get_close_matches(old_command,
+                                                  get_all_executables())
+                 if cmd not in new_cmds]
+
     return [' '.join([new_command] + command.script_parts[1:])
             for new_command in new_cmds]
 

thefuck/shells/__init__.py

@@ -9,20 +9,36 @@ from .fish import Fish
 from .generic import Generic
 from .tcsh import Tcsh
 from .zsh import Zsh
+from .powershell import Powershell
 
 shells = {'bash': Bash,
           'fish': Fish,
           'zsh': Zsh,
           'csh': Tcsh,
-          'tcsh': Tcsh}
+          'tcsh': Tcsh,
+          'powershell': Powershell}
 
 
 def _get_shell():
-    try:
-        shell_name = Process(os.getpid()).parent().name()
-    except TypeError:
-        shell_name = Process(os.getpid()).parent.name
-    return shells.get(shell_name, Generic)()
+    proc = Process(os.getpid())
+
+    while proc is not None:
+        try:
+            name = proc.name()
+        except TypeError:
+            name = proc.name
+
+        name = os.path.splitext(name)[0]
+
+        if name in shells:
+            return shells[name]()
+
+        try:
+            proc = proc.parent()
+        except TypeError:
+            proc = proc.parent
+
+    return Generic()
 
 
 shell = _get_shell()

thefuck/shells/bash.py

@@ -6,9 +6,11 @@ from .generic import Generic
 
 class Bash(Generic):
     def app_alias(self, fuck):
-        alias = "TF_ALIAS={0}" \
-                " alias {0}='PYTHONIOENCODING=utf-8" \
-                " TF_CMD=$(TF_SHELL_ALIASES=$(alias) thefuck $(fc -ln -1)) && " \
+        # It is VERY important to have the variables declared WITHIN the alias
+        alias = "alias {0}='TF_CMD=$(TF_ALIAS={0}" \
+                " PYTHONIOENCODING=utf-8" \
+                " TF_SHELL_ALIASES=$(alias)" \
+                " thefuck $(fc -ln -1)) &&" \
                 " eval $TF_CMD".format(fuck)
 
         if settings.alter_history:

thefuck/shells/fish.py

@@ -1,29 +1,38 @@
 from subprocess import Popen, PIPE
 from time import time
 import os
+import sys
+import six
+from .. import logs
+from ..conf import settings
 from ..utils import DEVNULL, memoize, cache
 from .generic import Generic
 
 
 class Fish(Generic):
     def _get_overridden_aliases(self):
-        overridden_aliases = os.environ.get('TF_OVERRIDDEN_ALIASES', '').strip()
-        if overridden_aliases:
-            return [alias.strip() for alias in overridden_aliases.split(',')]
-        else:
-            return ['cd', 'grep', 'ls', 'man', 'open']
+        overridden = os.environ.get('THEFUCK_OVERRIDDEN_ALIASES',
+                                    os.environ.get('TF_OVERRIDDEN_ALIASES', ''))
+        default = {'cd', 'grep', 'ls', 'man', 'open'}
+        for alias in overridden.split(','):
+            default.add(alias.strip())
+        return default
 
     def app_alias(self, fuck):
+        if settings.alter_history:
+            alter_history = ('    history --delete $fucked_up_command\n'
+                             '    history --merge ^ /dev/null\n')
+        else:
+            alter_history = ''
+        # It is VERY important to have the variables declared WITHIN the alias
         return ('function {0} -d "Correct your previous console command"\n'
                 '  set -l fucked_up_command $history[1]\n'
                 '  env TF_ALIAS={0} PYTHONIOENCODING=utf-8'
                 ' thefuck $fucked_up_command | read -l unfucked_command\n'
                 '  if [ "$unfucked_command" != "" ]\n'
-                '    eval $unfucked_command\n'
-                '    history --delete $fucked_up_command\n'
-                '    history --merge ^ /dev/null\n'
+                '    eval $unfucked_command\n{1}'
                 '  end\n'
-                'end').format(fuck)
+                'end').format(fuck, alter_history)
 
     @memoize
     @cache('.config/fish/config.fish', '.config/fish/functions')
@@ -41,10 +50,6 @@ class Fish(Generic):
         else:
             return command_script
 
-    def from_shell(self, command_script):
-        """Prepares command before running in app."""
-        return self._expand_aliases(command_script)
-
     def _get_history_file_name(self):
         return os.path.expanduser('~/.config/fish/fish_history')
 
@@ -63,3 +68,20 @@ class Fish(Generic):
     def how_to_configure(self):
         return (r"eval (thefuck --alias | tr '\n' ';')",
                 '~/.config/fish/config.fish')
+
+    def put_to_history(self, command):
+        try:
+            return self._put_to_history(command)
+        except IOError:
+            logs.exception("Can't update history", sys.exc_info())
+
+    def _put_to_history(self, command_script):
+        """Puts command script to shell history."""
+        history_file_name = self._get_history_file_name()
+        if os.path.isfile(history_file_name):
+            with open(history_file_name, 'a') as history:
+                entry = self._get_history_line(command_script)
+                if six.PY2:
+                    history.write(entry.encode('utf-8'))
+                else:
+                    history.write(entry)

thefuck/shells/generic.py

@@ -81,3 +81,11 @@ class Generic(object):
 
     def _script_from_history(self, line):
         return line
+
+    def put_to_history(self, command):
+        """Adds fixed command to shell history.
+
+        In most of shells we change history on shell-level, but not
+        all shells support it (Fish).
+
+        """

thefuck/shells/powershell.py

@@ -0,0 +1,18 @@
+from .generic import Generic
+
+
+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' \
+               '    }\n' \
+               '}\n'
+
+    def and_(self, *commands):
+        return u' -and '.join('({0})'.format(c) for c in commands)
+
+    def how_to_configure(self):
+        return 'iex "thefuck --alias"', '$profile'

thefuck/shells/zsh.py

@@ -7,10 +7,11 @@ from .generic import Generic
 
 class Zsh(Generic):
     def app_alias(self, alias_name):
-        alias = "alias {0}='TF_ALIAS={0}" \
+        # It is VERY important to have the variables declared WITHIN the alias
+        alias = "alias {0}='TF_CMD=$(TF_ALIAS={0}" \
                 " PYTHONIOENCODING=utf-8" \
-                ' TF_SHELL_ALIASES=$(alias)' \
-                " TF_CMD=$(thefuck $(fc -ln -1 | tail -n 1)) &&" \
+                " TF_SHELL_ALIASES=$(alias)" \
+                " thefuck $(fc -ln -1 | tail -n 1)) &&" \
                 " eval $TF_CMD".format(alias_name)
 
         if settings.alter_history:

thefuck/system/win32.py

@@ -1,3 +1,4 @@
+import os
 import sys
 import msvcrt
 import win_unicode_console
@@ -16,10 +17,11 @@ def get_key():
         ch = msvcrt.getch()  # second call returns the actual key code
 
     if ch == b'\x03':
-        raise const.KEY_CTRL_C
+        return const.KEY_CTRL_C
     if ch == b'H':
         return const.KEY_UP
     if ch == b'P':
         return const.KEY_DOWN
 
-    return ch.decode(sys.stdout.encoding)
+    encoding = sys.stdout.encoding or os.environ.get('PYTHONIOENCODING', 'utf-8')
+    return ch.decode(encoding)

thefuck/types.py

@@ -114,7 +114,7 @@ class Command(object):
         env.update(settings.env)
 
         with logs.debug_time(u'Call: {}; with env: {};'.format(script, env)):
-            result = Popen(script, shell=True, stdout=PIPE, stderr=PIPE, env=env)
+            result = Popen(script, shell=True, stdin=PIPE, stdout=PIPE, stderr=PIPE, env=env)
             if cls._wait_output(result):
                 stdout = result.stdout.read().decode('utf-8')
                 stderr = result.stderr.read().decode('utf-8')
@@ -280,7 +280,9 @@ class CorrectedCommand(object):
         """
         if self.side_effect:
             compatibility_call(self.side_effect, old_cmd, self.script)
+        if settings.alter_history:
+            shell.put_to_history(self.script)
         # This depends on correct setting of PYTHONIOENCODING by the alias:
         logs.debug(u'PYTHONIOENCODING: {}'.format(
-            os.environ.get('PYTHONIOENCODING', '>-not-set-<')))
+            os.environ.get('PYTHONIOENCODING', '!!not-set!!')))
         print(self.script)

thefuck/ui.py

@@ -16,7 +16,7 @@ def read_actions():
             yield const.ACTION_PREVIOUS
         elif key in (const.KEY_DOWN, 'j'):
             yield const.ACTION_NEXT
-        elif key == const.KEY_CTRL_C:
+        elif key in (const.KEY_CTRL_C, 'q'):
             yield const.ACTION_ABORT
         elif key in ('\n', '\r'):
             yield const.ACTION_SELECT

thefuck/utils.py

@@ -10,7 +10,10 @@ from decorator import decorator
 from difflib import get_close_matches
 from functools import wraps
 from inspect import getargspec
-from pathlib import Path
+try:
+    from pathlib import Path
+except ImportError:
+    from pathlib2 import Path
 from warnings import warn
 
 DEVNULL = open(os.devnull, 'w')
@@ -110,7 +113,7 @@ def get_all_executables():
     tf_entry_points = get_installation_info().get_entry_map()\
                                              .get('console_scripts', {})\
                                              .keys()
-    bins = [exe.name
+    bins = [exe.name.decode('utf8') if six.PY2 else exe.name
             for path in os.environ.get('PATH', '').split(':')
             for exe in _safe(lambda: list(Path(path).iterdir()), [])
             if not _safe(exe.is_dir, True)
@@ -228,8 +231,8 @@ def cache(*depends_on):
                     value = fn(*args, **kwargs)
                     db[key] = {'etag': etag, 'value': value}
                     return value
-        except shelve_open_error:
-            # Caused when going from Python 2 to Python 3 and vice-versa
+        except (shelve_open_error, ImportError):
+            # Caused when switching between Python versions
             warn("Removing possibly out-dated cache")
             os.remove(cache_path)
 
@@ -269,3 +272,24 @@ def get_installation_info():
 
 def get_alias():
     return os.environ.get('TF_ALIAS', 'fuck')
+
+
+@memoize
+def get_valid_history_without_current(command):
+    def _not_corrected(history, tf_alias):
+        """Returns all lines from history except that comes before `fuck`."""
+        previous = None
+        for line in history:
+            if previous is not None and line != tf_alias:
+                yield previous
+            previous = line
+        if history:
+            yield history[-1]
+
+    from thefuck.shells import shell
+    history = shell.get_history()
+    tf_alias = get_alias()
+    executables = get_all_executables()
+    return [line for line in _not_corrected(history, tf_alias)
+            if not line.startswith(tf_alias) and not line == command.script
+            and line.split(' ')[0] in executables]