Bump to 3.28

*  #855 - Support Ukrainian layout; Fix matching of similar layouts

* Fix splitting of command line

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,34 @@
+<!-- If you have any issue with The Fuck, sorry about that, but we will do what we
+can to fix that. Actually, maybe we already have, so first thing to do is to
+update The Fuck and see if the bug is still there. -->
+
+<!-- If it is (sorry again), check if the problem has not already been reported and
+if not, just open an issue on [GitHub](https://github.com/nvbn/thefuck) with
+the following basic information: -->
+
+The output of `thefuck --version` (something like `The Fuck 3.1 using Python
+3.5.0 and Bash 4.4.12(1)-release`):
+
+    FILL THIS IN
+
+Your system (Debian 7, ArchLinux, Windows, etc.):
+
+    FILL THIS IN
+
+How to reproduce the bug:
+
+    FILL THIS IN
+
+The output of The Fuck with `THEFUCK_DEBUG=true` exported (typically execute `export THEFUCK_DEBUG=true` in your shell before The Fuck):
+
+    FILL THIS IN
+
+If the bug only appears with a specific application, the output of that application and its version:
+
+    FILL THIS IN
+
+Anything else you think is relevant:
+
+    FILL THIS IN
+
+<!-- It's only with enough information that we can do something to fix the problem. -->

.travis.yml

@@ -2,6 +2,21 @@ language: python
 sudo: false
 matrix:
   include:
+    - os: linux
+      dist: xenial
+      python: "nightly"
+    - os: linux
+      dist: xenial
+      python: "3.8-dev"
+    - os: linux
+      dist: xenial
+      python: "3.7-dev"
+    - os: linux
+      dist: xenial
+      python: "3.7"
+    - os: linux
+      dist: trusty
+      python: "3.6-dev"
     - os: linux
       dist: trusty
       python: "3.6"
@@ -11,18 +26,16 @@ matrix:
     - os: linux
       dist: trusty
       python: "3.4"
-    - os: linux
-      dist: trusty
-      python: "3.3"
     - os: linux
       dist: trusty
       python: "2.7"
     - os: osx
-      env: FORMULA="python"
-      language: generic
-    - os: osx
-      env: FORMULA="python3"
       language: generic
+  allow_failures:
+    - python: nightly
+    - python: 3.8-dev
+    - python: 3.7-dev
+    - python: 3.6-dev
 services:
   - docker
 addons:
@@ -31,9 +44,11 @@ addons:
       - python-commandnotfound
       - python3-commandnotfound
 before_install:
-  - if [[ $TRAVIS_OS_NAME == "osx" ]]; then brew update ; fi
-  - if [[ $TRAVIS_OS_NAME == "osx" ]]; then if brew ls --versions $FORMULA; then brew upgrade $FORMULA || echo Python is up to date; else brew install $FORMULA; fi; fi
-  - if [[ $TRAVIS_OS_NAME == "osx" ]]; then virtualenv venv -p $FORMULA; fi
+  - if [[ $TRAVIS_OS_NAME == "osx" ]]; then rm -rf /usr/local/include/c++; fi
+  - if [[ $TRAVIS_OS_NAME == "osx" ]]; then brew update; fi
+  - if [[ $TRAVIS_OS_NAME == "osx" ]]; then brew upgrade python; fi
+  - if [[ $TRAVIS_OS_NAME == "osx" ]]; then pip3 install virtualenv; fi
+  - if [[ $TRAVIS_OS_NAME == "osx" ]]; then virtualenv venv -p python3; fi
   - if [[ $TRAVIS_OS_NAME == "osx" ]]; then source venv/bin/activate; fi
   - pip install -U pip
   - pip install -U coveralls
@@ -45,7 +60,7 @@ 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
+  - if [[ $TRAVIS_PYTHON_VERSION == 3.7 && $TRAVIS_OS_NAME != "osx" ]]; then $RUN_TESTS --enable-functional; fi
+  - if [[ $TRAVIS_PYTHON_VERSION != 3.7 || $TRAVIS_OS_NAME == "osx" ]]; then $RUN_TESTS; fi
 after_success:
-  - if [[ $TRAVIS_PYTHON_VERSION == 3.6 && $TRAVIS_OS_NAME != "osx" ]]; then coveralls; fi
+  - if [[ $TRAVIS_PYTHON_VERSION == 3.7 && $TRAVIS_OS_NAME != "osx" ]]; then coveralls; fi

CONTRIBUTING.md

@@ -23,3 +23,37 @@ It's only with enough information that we can do something to fix the problem.
 We gladly accept pull request on the [official
 repository](https://github.com/nvbn/thefuck) for new rules, new features, bug
 fixes, etc.
+
+# Developing
+
+Install `The Fuck` for development:
+
+```bash
+pip install -r requirements.txt
+python setup.py develop
+```
+
+Run code style checks:
+
+```bash
+flake8
+```
+
+Run unit tests:
+
+```bash
+py.test
+```
+
+Run unit and functional tests (requires docker):
+
+```bash
+py.test --enable-functional
+```
+
+For sending package to pypi:
+
+```bash
+sudo apt-get install pandoc
+./release.py
+```

LICENSE.md

@@ -1,7 +1,7 @@
 The MIT License (MIT)
 =====================
 
-Copyright (c) 2015 Vladimir Iakovlev
+Copyright (c) 2015-2018 Vladimir Iakovlev
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,14 +1,15 @@
 # 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).
+*The Fuck* is a magnificent app, inspired by a [@liamosaur](https://twitter.com/liamosaur/)
+[tweet](https://twitter.com/liamosaur/status/506975850596536320),
+that corrects errors in previous console commands.
 
-The Fuck is too slow? [Try experimental instant mode!](#experimental-instant-mode) 
+
+Is *The Fuck* too slow? [Try the experimental instant mode!](#experimental-instant-mode)
 
 [![gif with examples][examples-link]][examples-link]
 
-Few more examples:
+More examples:
 
 ```bash
 ➜ apt-get install vim
@@ -75,8 +76,8 @@ REPL-y 0.3.1
 ...
 ```
 
-If you are not scared to blindly run the changed command, there is a `require_confirmation`
-[settings](#settings) option:
+If you're not afraid of blindly running corrected commands, the
+`require_confirmation` [settings](#settings) option can be disabled:
 
 ```bash
 ➜ apt-get install vim
@@ -92,35 +93,47 @@ Reading package lists... Done
 
 ## Requirements
 
-- python (3.3+)
+- python (3.4+)
 - pip
 - python-dev
 
 ## Installation
 
-On OS X you can install `The Fuck` with [Homebrew][homebrew]:
+On OS X, you can install *The Fuck* via [Homebrew][homebrew]:
 
 ```bash
 brew install thefuck
 ```
 
-On Ubuntu you can install `The Fuck` with:
+On Ubuntu / Mint, install *The Fuck* with the following commands:
 ```bash
 sudo apt update
-sudo apt install python3-dev python3-pip
+sudo apt install python3-dev python3-pip python3-setuptools
 sudo pip3 install thefuck
 ```
 
-On other systems you can install `The Fuck` with `pip`:
+On FreeBSD, install *The Fuck* with the following commands:
+```bash
+sudo portsnap fetch update
+cd /usr/ports/misc/thefuck && sudo make install clean
+```
+
+On ChromeOS, install *The Fuck* using [chromebrew](https://github.com/skycocker/chromebrew) with the following command:
+```bash
+crew install thefuck
+```
+
+On other systems, install *The Fuck*  by using `pip`:
 
 ```bash
 pip install thefuck
 ```
 
-[Or using an OS package manager (OS X, Ubuntu, Arch).](https://github.com/nvbn/thefuck/wiki/Installation)
+[Alternatively, you may use an OS package manager (OS X, Ubuntu, Arch).](https://github.com/nvbn/thefuck/wiki/Installation)
 
 <a href='#manual-installation' name='manual-installation'>#</a>
-You should place this command in your `.bash_profile`, `.bashrc`, `.zshrc` or other startup script:
+It is recommended that you place this command in your `.bash_profile`,
+`.bashrc`, `.zshrc` or other startup script:
 
 ```bash
 eval $(thefuck --alias)
@@ -130,38 +143,42 @@ eval $(thefuck --alias FUCK)
 
 [Or in your shell config (Bash, Zsh, Fish, Powershell, tcsh).](https://github.com/nvbn/thefuck/wiki/Shell-aliases)
 
-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`).
+Changes are only available in a new shell session. To make changes immediately
+available, run `source ~/.bashrc` (or your shell config file like `.zshrc`).
 
-If you want to run fixed command without confirmation you can use `-y` option:
+To run fixed commands without confirmation, use the `--yeah` option (or just `-y` for short):
 
 ```bash
-fuck -y
+fuck --yeah
 ```
 
-If you want to fix commands recursively until success you can use `-r` option:
+To fix commands recursively until succeeding, use the `-r` option:
 
 ```bash
 fuck -r
 ```
 
-## Update
+## Updating
 
 ```bash
-pip install thefuck --upgrade
+pip3 install thefuck --upgrade
 ```
 
-**Aliases changed in 1.34.**
+**Note: Alias functionality was changed in v1.34 of *The Fuck***
 
 ## How it works
 
-The Fuck tries to match a rule for the previous command, creates a new command
-using the matched rule and runs it. Rules enabled by default are as follows:
+*The Fuck* attempts to match the previous command with a rule. If a match is
+found, a new command is created using the matched rule and executed. The
+following rules are enabled by default:
 
+* `adb_unknown_command` &ndash; fixes misspelled commands like `adb logcta`;
 * `ag_literal` &ndash; adds `-Q` to `ag` when suggested;
 * `aws_cli` &ndash; fixes misspelled commands like `aws dynamdb scan`;
+* `az_cli` &ndash; fixes misspelled commands like `az providers`;
 * `cargo` &ndash; runs `cargo build` instead of `cargo`;
 * `cargo_no_command` &ndash; fixes wrongs commands like `cargo buid`;
+* `cat_dir` &ndash; replaces `cat` with `ls` when you try to `cat` a directory;
 * `cd_correction` &ndash; spellchecks and correct failed cd commands;
 * `cd_mkdir` &ndash; creates directories before cd'ing into them;
 * `cd_parent` &ndash; changes `cd..` to `cd ..`;
@@ -186,11 +203,14 @@ using the matched rule and runs it. Rules enabled by default are as follows:
 * `git_branch_exists` &ndash; offers `git branch -d foo`, `git branch -D foo` or `git checkout foo` when creating a branch that already exists;
 * `git_branch_list` &ndash; catches `git branch list` in place of `git branch` and removes created branch;
 * `git_checkout` &ndash; fixes branch name or creates new branch;
+* `git_commit_amend` &ndash; offers `git commit --amend` after previous commit;
 * `git_diff_no_index` &ndash; adds `--no-index` to previous `git diff` on untracked files;
 * `git_diff_staged` &ndash; adds `--staged` to previous `git diff` with unexpected output;
 * `git_fix_stash` &ndash; fixes `git stash` commands (misspelled subcommand and missing `save`);
 * `git_flag_after_filename` &ndash; fixes `fatal: bad flag '...' after filename`
 * `git_help_aliased` &ndash; fixes `git help <alias>` commands replacing <alias> with the aliased command;
+* `git_merge` &ndash; adds remote to branch names;
+* `git_merge_unrelated` &ndash; adds `--allow-unrelated-histories` when required
 * `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;
@@ -213,11 +233,12 @@ using the matched rule and runs it. Rules enabled by default are as follows:
 * `go_run` &ndash; appends `.go` extension when compiling/running Go programs;
 * `gradle_no_task` &ndash; fixes not found or ambiguous `gradle` task;
 * `gradle_wrapper` &ndash; replaces `gradle` with `./gradlew`;
-* `grep_arguments_order` &ndash; fixes grep arguments order for situations like `grep -lir . test`;
-* `grep_recursive` &ndash; adds `-r` when you trying to `grep` directory;
+* `grep_arguments_order` &ndash; fixes `grep` arguments order for situations like `grep -lir . test`;
+* `grep_recursive` &ndash; adds `-r` when you try to `grep` directory;
 * `grunt_task_not_found` &ndash; fixes misspelled `grunt` commands;
 * `gulp_not_task` &ndash; fixes misspelled `gulp` tasks;
 * `has_exists_script` &ndash; prepends `./` when script/binary exists;
+* `heroku_multiple_apps` &ndash; add `--app <app>` to `heroku` commands like `heroku pg`;
 * `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;
@@ -225,6 +246,7 @@ using the matched rule and runs it. Rules enabled by default are as follows:
 * `java` &ndash; removes `.java` extension when running Java programs;
 * `javac` &ndash; appends missing `.java` when compiling Java files;
 * `lein_not_task` &ndash; fixes wrong `lein` tasks like `lein rpl`;
+* `long_form_help` &ndash; changes `-h` to `--help` when the short form version is not supported
 * `ln_no_hard_link` &ndash; catches hard link creation on directories, suggest symbolic link;
 * `ln_s_order` &ndash; fixes `ln -s` arguments order;
 * `ls_all` &ndash; adds `-A` to `ls` when output is empty;
@@ -233,7 +255,7 @@ using the matched rule and runs it. Rules enabled by default are as follows:
 * `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;
+* `mkdir_p` &ndash; adds `-p` when you try to create a directory without parent;
 * `mvn_no_command` &ndash; adds `clean package` to `mvn`;
 * `mvn_unknown_lifecycle_phase` &ndash; fixes misspelled lifecycle phases with `mvn`;
 * `npm_missing_script` &ndash; fixes `npm` custom script name in `npm run-script <script>`;
@@ -246,13 +268,13 @@ using the matched rule and runs it. Rules enabled by default are as follows:
 * `php_s` &ndash; replaces `-s` by `-S` when trying to run a local php server;
 * `port_already_in_use` &ndash; kills process that bound port;
 * `prove_recursively` &ndash; adds `-r` when called with directory;
-* `python_command` &ndash; prepends `python` when you trying to run not executable/without `./` python script;
+* `python_command` &ndash; prepends `python` when you try to run non-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;
+* `rm_dir` &ndash; adds `-rf` when you try to remove a 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`;
@@ -267,6 +289,7 @@ using the matched rule and runs it. Rules enabled by default are as follows:
 * `tsuru_not_command` &ndash; fixes wrong `tsuru` commands like `tsuru shell`;
 * `tmux` &ndash; fixes `tmux` commands;
 * `unknown_command` &ndash; fixes hadoop hdfs-style "unknown command", for example adds missing '-' to the command on `hdfs dfs ls`;
+* `unsudo` &ndash; removes `sudo` from previous command if a process refuses to run on super user privilege.
 * `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.
@@ -275,13 +298,16 @@ using the matched rule and runs it. Rules enabled by default are as follows:
 * `yarn_command_replaced` &ndash; fixes replaced `yarn` commands;
 * `yarn_help` &ndash; makes it easier to open `yarn` documentation;
 
-Enabled by default only on specific platforms:
+The following rules are enabled by default on specific platforms only:
 
 * `apt_get` &ndash; installs app from apt if it not installed (requires `python-commandnotfound` / `python3-commandnotfound`);
 * `apt_get_search` &ndash; changes trying to search using `apt-get` with searching using `apt-cache`;
 * `apt_invalid_operation` &ndash; fixes invalid `apt` and `apt-get` calls, like `apt-get isntall vim`;
+* `apt_list_upgradable` &ndash; helps you run `apt list --upgradable` after `apt update`;
+* `apt_upgrade` &ndash; helps you run `apt upgrade` after `apt list --upgradable`;
 * `brew_cask_dependency` &ndash; installs cask dependencies;
 * `brew_install` &ndash; fixes formula name for `brew install`;
+* `brew_reinstall` &ndash; turns `brew install <formula>` into `brew reinstall <formula>`;
 * `brew_link` &ndash; adds `--overwrite --dry-run` if linking fails;
 * `brew_uninstall` &ndash; adds `--force` to `brew uninstall` if multiple versions were installed;
 * `brew_unknown_command` &ndash; fixes wrong brew commands, for example `brew docto/brew doctor`;
@@ -290,36 +316,40 @@ Enabled by default only on specific platforms:
 * `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`.
 
-Bundled, but not enabled by default:
+The following commands are bundled with *The Fuck*, but are not enabled by
+default:
 
 * `git_push_force` &ndash; adds `--force-with-lease` to a `git push` (may conflict with `git_push_pull`);
 * `rm_root` &ndash; adds `--no-preserve-root` to `rm -rf /` command.
 
 ## Creating your own rules
 
-For adding your own rule you should create `your-rule-name.py`
-in `~/.config/thefuck/rules`. The rule should contain two functions:
+To add your own rule, create a file named `your-rule-name.py`
+in `~/.config/thefuck/rules`. The rule file must contain two functions:
 
 ```python
 match(command: Command) -> bool
 get_new_command(command: Command) -> str | list[str]
 ```
 
-Also the rule can contain an optional function
+Additionally, rules can contain optional functions:
 
 ```python
 side_effect(old_command: Command, fixed_command: str) -> None
 ```
-and optional `enabled_by_default`, `requires_output` and `priority` variables.
+Rules can also contain the optional variables `enabled_by_default`, `requires_output` and `priority`.
 
 `Command` has three attributes: `script`, `output` and `script_parts`.
-Rule shouldn't change `Command`.
+Your rule should not change `Command`.
 
 
-*Rules api changed in 3.0:* For accessing settings in rule you need to import it with `from thefuck.conf import settings`.
-`settings` is a special object filled with `~/.config/thefuck/settings.py` and values from env ([see more below](#settings)).
+**Rules api changed in 3.0:** To access a rule's settings, import it with
+ `from thefuck.conf import settings`
+  
+`settings` is a special object assembled from `~/.config/thefuck/settings.py`, 
+and values from env ([see more below](#settings)).
 
-Simple example of the rule for running script with `sudo`:
+A simple example rule for running a script with `sudo`:
 
 ```python
 def match(command):
@@ -347,7 +377,8 @@ requires_output = True
 
 ## Settings
 
-The Fuck has a few settings parameters which can be changed in `$XDG_CONFIG_HOME/thefuck/settings.py` (`$XDG_CONFIG_HOME` defaults to `~/.config`):
+Several *The Fuck* parameters can be changed in the file `$XDG_CONFIG_HOME/thefuck/settings.py`
+(`$XDG_CONFIG_HOME` defaults to `~/.config`):
 
 * `rules` &ndash; list of enabled rules, by default `thefuck.conf.DEFAULT_RULES`;
 * `exclude_rules` &ndash; list of disabled rules, by default `[]`;
@@ -359,9 +390,10 @@ The Fuck has a few settings parameters which can be changed in `$XDG_CONFIG_HOME
 * `history_limit` &ndash; numeric value of how many history commands will be scanned, like `2000`;
 * `alter_history` &ndash; push fixed command to history, by default `True`;
 * `wait_slow_command` &ndash; max amount of time in seconds for getting previous command output if it in `slow_commands` list;
-* `slow_commands` &ndash; list of slow commands.
+* `slow_commands` &ndash; list of slow commands;
+* `num_close_matches` &ndash; maximum number of close matches to suggest, by default `3`.
 
-Example of `settings.py`:
+An example of `settings.py`:
 
 ```python
 rules = ['sudo', 'no_command']
@@ -374,6 +406,7 @@ debug = False
 history_limit = 9999
 wait_slow_command = 20
 slow_commands = ['react-native', 'gradle']
+num_close_matches = 5
 ```
 
 Or via environment variables:
@@ -389,7 +422,8 @@ rule with lower `priority` will be matched first;
 * `THEFUCK_HISTORY_LIMIT` &ndash; how many history commands will be scanned, like `2000`;
 * `THEFUCK_ALTER_HISTORY` &ndash; push fixed command to history `true/false`;
 * `THEFUCK_WAIT_SLOW_COMMAND` &ndash; max amount of time in seconds for getting previous command output if it in `slow_commands` list;
-* `THEFUCK_SLOW_COMMANDS` &ndash; list of slow commands, like `lein:gradle`.
+* `THEFUCK_SLOW_COMMANDS` &ndash; list of slow commands, like `lein:gradle`;
+* `THEFUCK_NUM_CLOSE_MATCHES` &ndash; maximum number of close matches to suggest, like `5`.
 
 For example:
 
@@ -401,20 +435,42 @@ export THEFUCK_WAIT_COMMAND=10
 export THEFUCK_NO_COLORS='false'
 export THEFUCK_PRIORITY='no_command=9999:apt_get=100'
 export THEFUCK_HISTORY_LIMIT='2000'
+export THEFUCK_NUM_CLOSE_MATCHES='5'
 ```
 
+## Third-party packages with rules
+
+If you'd like to make a specific set of non-public rules, but would still like
+to share them with others, create a package named `thefuck_contrib_*` with
+the following structure:
+
+```
+thefuck_contrib_foo
+  thefuck_contrib_foo
+    rules
+      __init__.py
+      *third-party rules*
+    __init__.py
+    *third-party-utils*
+  setup.py
+```
+
+*The Fuck* will find rules located in the `rules` module.
+
 ## Experimental instant mode
 
-By default The Fuck reruns a previous command and that takes time,
-in instant mode The Fuck logs output with [script](https://en.wikipedia.org/wiki/Script_(Unix))
-and just reads the log.
+The default behavior of *The Fuck* requires time to re-run previous commands.
+When in instant mode, *The Fuck* saves time by logging output with [script](https://en.wikipedia.org/wiki/Script_(Unix)),
+then reading the log.
 
 [![gif with instant mode][instant-mode-gif-link]][instant-mode-gif-link]
 
-At the moment only Python 3 with bash or zsh is supported.
+Currently, instant mode only supports Python 3 with bash or zsh. zsh's autocorrect function also needs to be disabled in order for thefuck to work properly.
 
-For enabling instant mode you need to add `--enable-experimental-instant-mode`
-to alias initialization in your `.bashrc`, `.bash_profile` or `.zshrc` like:
+To enable instant mode, add `--enable-experimental-instant-mode`
+to the alias initialization in `.bashrc`, `.bash_profile` or `.zshrc`.
+
+For example:
 
 ```bash
 eval $(thefuck --alias --enable-experimental-instant-mode)
@@ -422,37 +478,7 @@ eval $(thefuck --alias --enable-experimental-instant-mode)
 
 ## Developing
 
-Install `The Fuck` for development:
-
-```bash
-pip install -r requirements.txt
-python setup.py develop
-```
-
-Run code style checks:
-
-```bash
-flake8
-```
-
-Run unit tests:
-
-```bash
-py.test
-```
-
-Run unit and functional tests (requires docker):
-
-```bash
-py.test --enable-functional
-```
-
-For sending package to pypi:
-
-```bash
-sudo apt-get install pandoc
-./release.py
-```
+See [CONTRIBUTING.md](CONTRIBUTING.md)
 
 ## License MIT
 Project License can be found [here](LICENSE.md).

appveyor.yml

@@ -3,10 +3,10 @@ build: false
 environment:
   matrix:
     - PYTHON: "C:/Python27"
-    - PYTHON: "C:/Python33"
     - PYTHON: "C:/Python34"
     - PYTHON: "C:/Python35"
     - PYTHON: "C:/Python36"
+    - PYTHON: "C:/Python37"
 
 init:
   - "ECHO %PYTHON%"

release.py

@@ -32,4 +32,5 @@ call('git push --tags', shell=True)
 
 env = os.environ
 env['CONVERT_README'] = 'true'
-call('python setup.py sdist bdist_wheel upload', shell=True, env=env)
+call('python setup.py sdist bdist_wheel', shell=True, env=env)
+call('twine upload dist/*', shell=True, env=env)

requirements.txt

@@ -1,4 +1,3 @@
-pip
 flake8
 pytest
 mock
@@ -9,3 +8,4 @@ pexpect
 pypandoc
 pytest-benchmark
 pytest-docker-pexpect
+twine

setup.py

@@ -26,12 +26,12 @@ if version < (2, 7):
     print('thefuck requires Python version 2.7 or later' +
           ' ({}.{} detected).'.format(*version))
     sys.exit(-1)
-elif (3, 0) < version < (3, 3):
-    print('thefuck requires Python version 3.3 or later' +
+elif (3, 0) < version < (3, 4):
+    print('thefuck requires Python version 3.4 or later' +
           ' ({}.{} detected).'.format(*version))
     sys.exit(-1)
 
-VERSION = '3.24'
+VERSION = '3.28'
 
 install_requires = ['psutil', 'colorama', 'six', 'decorator', 'pyte']
 extras_require = {':python_version<"3.4"': ['pathlib2'],

snapcraft.yaml

@@ -0,0 +1,25 @@
+name: thefuck
+version: stable
+version-script: git -C parts/thefuck/build describe --abbrev=0 --tags
+summary: Magnificent app which corrects your previous console command.
+description: |
+  The Fuck tries to match a rule for the previous command,
+  creates a new command using the matched rule and runs it.
+
+grade: stable
+confinement: classic
+
+apps:
+  thefuck:
+    command: bin/thefuck
+    environment:
+        PYTHONIOENCODING: utf-8
+  fuck:
+    command: bin/fuck
+    environment:
+        PYTHONIOENCODING: utf-8
+
+parts:
+  thefuck:
+    source: https://github.com/nvbn/thefuck.git
+    plugin: python

tests/functional/test_performance.py

@@ -1,45 +0,0 @@
-import pytest
-import time
-
-dockerfile = u'''
-FROM python:3
-RUN adduser --disabled-password --gecos '' test
-ENV SEED "{seed}"
-WORKDIR /src
-USER test
-RUN echo 'eval $(thefuck --alias)' > /home/test/.bashrc
-RUN echo > /home/test/.bash_history
-RUN git config --global user.email "you@example.com"
-RUN git config --global user.name "Your Name"
-USER root
-'''.format(seed=time.time())
-
-
-def plot(proc, TIMEOUT):
-    proc.sendline(u'cd /home/test/')
-    proc.sendline(u'fuck')
-    assert proc.expect([TIMEOUT, u'No fucks given'])
-    proc.sendline(u'git init')
-    proc.sendline(u'git add .')
-    proc.sendline(u'git commit -a -m init')
-    proc.sendline(u'git brnch')
-    proc.sendline(u'fuck')
-    assert proc.expect([TIMEOUT, u'git branch'])
-    proc.send('\n')
-    assert proc.expect([TIMEOUT, u'master'])
-    proc.sendline(u'echo test')
-    proc.sendline(u'echo tst')
-    proc.sendline(u'fuck')
-    assert proc.expect([TIMEOUT, u'echo test'])
-    proc.send('\n')
-    assert proc.expect([TIMEOUT, u'test'])
-
-
-@pytest.mark.functional
-@pytest.mark.benchmark(min_rounds=10)
-def test_performance(spawnu, TIMEOUT, benchmark):
-    proc = spawnu(u'thefuck/python3-bash-performance',
-                  dockerfile, u'bash')
-    proc.sendline(u'pip install /src')
-    proc.sendline(u'su test')
-    assert benchmark(plot, proc, TIMEOUT) is None

tests/output_readers/test_rerun.py

@@ -0,0 +1,58 @@
+# -*- encoding: utf-8 -*-
+
+from mock import Mock, patch
+from psutil import AccessDenied, TimeoutExpired
+
+from thefuck.output_readers import rerun
+
+
+class TestRerun(object):
+    def setup_method(self, test_method):
+        self.patcher = patch('thefuck.output_readers.rerun.Process')
+        process_mock = self.patcher.start()
+        self.proc_mock = process_mock.return_value = Mock()
+
+    def teardown_method(self, test_method):
+        self.patcher.stop()
+
+    @patch('thefuck.output_readers.rerun._wait_output', return_value=False)
+    @patch('thefuck.output_readers.rerun.Popen')
+    def test_get_output(self, popen_mock, wait_output_mock):
+        popen_mock.return_value.stdout.read.return_value = b'output'
+        assert rerun.get_output('', '') is None
+        wait_output_mock.assert_called_once()
+
+    def test_wait_output_is_slow(self, settings):
+        assert rerun._wait_output(Mock(), True)
+        self.proc_mock.wait.assert_called_once_with(settings.wait_slow_command)
+
+    def test_wait_output_is_not_slow(self, settings):
+        assert rerun._wait_output(Mock(), False)
+        self.proc_mock.wait.assert_called_once_with(settings.wait_command)
+
+    @patch('thefuck.output_readers.rerun._kill_process')
+    def test_wait_output_timeout(self, kill_process_mock):
+        self.proc_mock.wait.side_effect = TimeoutExpired(3)
+        self.proc_mock.children.return_value = []
+        assert not rerun._wait_output(Mock(), False)
+        kill_process_mock.assert_called_once_with(self.proc_mock)
+
+    @patch('thefuck.output_readers.rerun._kill_process')
+    def test_wait_output_timeout_children(self, kill_process_mock):
+        self.proc_mock.wait.side_effect = TimeoutExpired(3)
+        self.proc_mock.children.return_value = [Mock()] * 2
+        assert not rerun._wait_output(Mock(), False)
+        assert kill_process_mock.call_count == 3
+
+    def test_kill_process(self):
+        proc = Mock()
+        rerun._kill_process(proc)
+        proc.kill.assert_called_once_with()
+
+    @patch('thefuck.output_readers.rerun.logs')
+    def test_kill_process_access_denied(self, logs_mock):
+        proc = Mock()
+        proc.kill.side_effect = AccessDenied()
+        rerun._kill_process(proc)
+        proc.kill.assert_called_once_with()
+        logs_mock.debug.assert_called_once()

tests/rules/test_adb_unknown_command.py

@@ -0,0 +1,41 @@
+import pytest
+from thefuck.rules.adb_unknown_command import match, get_new_command
+from thefuck.types import Command
+
+
+@pytest.fixture
+def output():
+    return '''Android Debug Bridge version 1.0.31
+
+ -d                            - directs command to the only connected USB device
+                                 returns an error if more than one USB device is present.
+ -e                            - directs command to the only running emulator.
+                                 returns an error if more than one emulator is running.
+ -s <specific device>          - directs command to the device or emulator with the given
+                                 serial number or qualifier. Overrides ANDROID_SERIAL
+                                 environment variable.
+'''
+
+
+@pytest.mark.parametrize('script', [
+    ('adb lgcat'),
+    ('adb puhs')])
+def test_match(output, script):
+    assert match(Command(script, output))
+
+
+@pytest.mark.parametrize('script', [
+    'git branch foo',
+    'abd push'])
+def test_not_match(script):
+    assert not match(Command(script, ''))
+
+
+@pytest.mark.parametrize('script, new_command', [
+    ('adb puhs test.bin /sdcard/test.bin', 'adb push test.bin /sdcard/test.bin'),
+    ('adb -s 1111 logcta', 'adb -s 1111 logcat'),
+    ('adb -P 666 pulll /sdcard/test.bin', 'adb -P 666 pull /sdcard/test.bin'),
+    ('adb -d logcatt', 'adb -d logcat'),
+    ('adb -e reboott', 'adb -e reboot')])
+def test_get_new_command(script, output, new_command):
+    assert get_new_command(Command(script, output)) == new_command

tests/rules/test_ag_literal.py

@@ -9,7 +9,7 @@ def output():
             'If you meant to search for a literal string, run ag with -Q\n')
 
 
-@pytest.mark.parametrize('script', ['ag \('])
+@pytest.mark.parametrize('script', ['ag \\('])
 def test_match(script, output):
     assert match(Command(script, output))
 
@@ -20,6 +20,6 @@ def test_not_match(script):
 
 
 @pytest.mark.parametrize('script, new_cmd', [
-    ('ag \(', 'ag -Q \(')])
+    ('ag \\(', 'ag -Q \\(')])
 def test_get_new_command(script, new_cmd, output):
     assert get_new_command((Command(script, output))) == new_cmd

tests/rules/test_apt_get.py

@@ -12,9 +12,8 @@ from thefuck.types import Command
      [('vim', 'main'), ('vim-tiny', 'main')])])
 def test_match(mocker, command, packages):
     mocker.patch('thefuck.rules.apt_get.which', return_value=None)
-    mock = mocker.patch('thefuck.rules.apt_get.command_not_found',
-                        create=True)
-    mock.getPackages.return_value = packages
+    mocker.patch('thefuck.rules.apt_get._get_packages',
+                 create=True, return_value=packages)
 
     assert match(command)
 
@@ -30,9 +29,8 @@ def test_match(mocker, command, packages):
      ['vim'], '/usr/bin/vim')])
 def test_not_match(mocker, command, packages, which):
     mocker.patch('thefuck.rules.apt_get.which', return_value=which)
-    mock = mocker.patch('thefuck.rules.apt_get.command_not_found',
-                        create=True)
-    mock.getPackages.return_value = packages
+    mocker.patch('thefuck.rules.apt_get._get_packages',
+                 create=True, return_value=packages)
 
     assert not match(command)
 
@@ -49,7 +47,7 @@ def test_not_match(mocker, command, packages, which):
      [('imagemagick', 'main'),
       ('graphicsmagick-imagemagick-compat', 'universe')])])
 def test_get_new_command(mocker, command, new_command, packages):
-    mock = mocker.patch('thefuck.rules.apt_get.command_not_found',
-                        create=True)
-    mock.getPackages.return_value = packages
+    mocker.patch('thefuck.rules.apt_get._get_packages',
+                 create=True, return_value=packages)
+
     assert get_new_command(command) == new_command

tests/rules/test_apt_list_upgradable.py

@@ -0,0 +1,75 @@
+import pytest
+from thefuck.rules.apt_list_upgradable import get_new_command, match
+from thefuck.types import Command
+
+match_output = '''
+Hit:1 http://us.archive.ubuntu.com/ubuntu zesty InRelease
+Hit:2 http://us.archive.ubuntu.com/ubuntu zesty-updates InRelease
+Get:3 http://us.archive.ubuntu.com/ubuntu zesty-backports InRelease [89.2 kB]
+Hit:4 http://security.ubuntu.com/ubuntu zesty-security InRelease
+Hit:5 http://ppa.launchpad.net/ubuntu-mozilla-daily/ppa/ubuntu zesty InRelease
+Hit:6 https://download.docker.com/linux/ubuntu zesty InRelease
+Hit:7 https://cli-assets.heroku.com/branches/stable/apt ./ InRelease
+Fetched 89.2 kB in 0s (122 kB/s)
+Reading package lists... Done
+Building dependency tree
+Reading state information... Done
+8 packages can be upgraded. Run 'apt list --upgradable' to see them.
+'''
+
+no_match_output = '''
+Hit:1 http://us.archive.ubuntu.com/ubuntu zesty InRelease
+Get:2 http://us.archive.ubuntu.com/ubuntu zesty-updates InRelease [89.2 kB]
+Get:3 http://us.archive.ubuntu.com/ubuntu zesty-backports InRelease [89.2 kB]
+Get:4 http://security.ubuntu.com/ubuntu zesty-security InRelease [89.2 kB]
+Hit:5 https://cli-assets.heroku.com/branches/stable/apt ./ InRelease
+Hit:6 http://ppa.launchpad.net/ubuntu-mozilla-daily/ppa/ubuntu zesty InRelease
+Hit:7 https://download.docker.com/linux/ubuntu zesty InRelease
+Get:8 http://us.archive.ubuntu.com/ubuntu zesty-updates/main i386 Packages [232 kB]
+Get:9 http://us.archive.ubuntu.com/ubuntu zesty-updates/main amd64 Packages [235 kB]
+Get:10 http://us.archive.ubuntu.com/ubuntu zesty-updates/main amd64 DEP-11 Metadata [55.2 kB]
+Get:11 http://us.archive.ubuntu.com/ubuntu zesty-updates/main DEP-11 64x64 Icons [32.3 kB]
+Get:12 http://us.archive.ubuntu.com/ubuntu zesty-updates/universe amd64 Packages [156 kB]
+Get:13 http://us.archive.ubuntu.com/ubuntu zesty-updates/universe i386 Packages [156 kB]
+Get:14 http://us.archive.ubuntu.com/ubuntu zesty-updates/universe amd64 DEP-11 Metadata [175 kB]
+Get:15 http://us.archive.ubuntu.com/ubuntu zesty-updates/universe DEP-11 64x64 Icons [253 kB]
+Get:16 http://us.archive.ubuntu.com/ubuntu zesty-updates/multiverse amd64 DEP-11 Metadata [5,840 B]
+Get:17 http://us.archive.ubuntu.com/ubuntu zesty-backports/universe amd64 DEP-11 Metadata [4,588 B]
+Get:18 http://security.ubuntu.com/ubuntu zesty-security/main amd64 DEP-11 Metadata [12.7 kB]
+Get:19 http://security.ubuntu.com/ubuntu zesty-security/main DEP-11 64x64 Icons [17.6 kB]
+Get:20 http://security.ubuntu.com/ubuntu zesty-security/universe amd64 DEP-11 Metadata [21.6 kB]
+Get:21 http://security.ubuntu.com/ubuntu zesty-security/universe DEP-11 64x64 Icons [47.7 kB]
+Get:22 http://security.ubuntu.com/ubuntu zesty-security/multiverse amd64 DEP-11 Metadata [208 B]
+Fetched 1,673 kB in 0s (1,716 kB/s)
+Reading package lists... Done
+Building dependency tree
+Reading state information... Done
+All packages are up to date.
+'''
+
+
+def test_match():
+    assert match(Command('sudo apt update', match_output))
+
+
+@pytest.mark.parametrize('command', [
+    Command('apt-cache search foo', ''),
+    Command('aptitude search foo', ''),
+    Command('apt search foo', ''),
+    Command('apt-get install foo', ''),
+    Command('apt-get source foo', ''),
+    Command('apt-get clean', ''),
+    Command('apt-get remove', ''),
+    Command('apt-get update', ''),
+    Command('sudo apt update', no_match_output)
+])
+def test_not_match(command):
+    assert not match(command)
+
+
+def test_get_new_command():
+    new_command = get_new_command(Command('sudo apt update', match_output))
+    assert new_command == 'sudo apt list --upgradable'
+
+    new_command = get_new_command(Command('apt update', match_output))
+    assert new_command == 'apt list --upgradable'

tests/rules/test_apt_upgrade.py

@@ -0,0 +1,36 @@
+import pytest
+from thefuck.rules.apt_upgrade import get_new_command, match
+from thefuck.types import Command
+
+match_output = '''
+Listing... Done
+heroku/stable 6.15.2-1 amd64 [upgradable from: 6.14.43-1]
+resolvconf/zesty-updates,zesty-updates 1.79ubuntu4.1 all [upgradable from: 1.79ubuntu4]
+squashfs-tools/zesty-updates 1:4.3-3ubuntu2.17.04.1 amd64 [upgradable from: 1:4.3-3ubuntu2]
+unattended-upgrades/zesty-updates,zesty-updates 0.93.1ubuntu2.4 all [upgradable from: 0.93.1ubuntu2.3]
+'''
+
+no_match_output = '''
+Listing... Done
+'''
+
+
+def test_match():
+    assert match(Command('apt list --upgradable', match_output))
+    assert match(Command('sudo apt list --upgradable', match_output))
+
+
+@pytest.mark.parametrize('command', [
+    Command('apt list --upgradable', no_match_output),
+    Command('sudo apt list --upgradable', no_match_output)
+])
+def test_not_match(command):
+    assert not match(command)
+
+
+def test_get_new_command():
+    new_command = get_new_command(Command('apt list --upgradable', match_output))
+    assert new_command == 'apt upgrade'
+
+    new_command = get_new_command(Command('sudo apt list --upgradable', match_output))
+    assert new_command == 'sudo apt upgrade'

tests/rules/test_az_cli.py

@@ -0,0 +1,44 @@
+import pytest
+
+from thefuck.rules.az_cli import match, get_new_command
+from thefuck.types import Command
+
+
+no_suggestions = '''\
+az provider: error: the following arguments are required: _subcommand
+usage: az provider [-h] {list,show,register,unregister,operation} ...
+'''
+
+
+misspelled_command = '''\
+az: 'providers' is not in the 'az' command group. See 'az --help'.
+
+The most similar choice to 'providers' is:
+    provider
+'''
+
+misspelled_subcommand = '''\
+az provider: 'lis' is not in the 'az provider' command group. See 'az provider --help'.
+
+The most similar choice to 'lis' is:
+    list
+'''
+
+
+@pytest.mark.parametrize('command', [
+    Command('az providers', misspelled_command),
+    Command('az provider lis', misspelled_subcommand)])
+def test_match(command):
+    assert match(command)
+
+
+def test_not_match():
+    assert not match(Command('az provider', no_suggestions))
+
+
+@pytest.mark.parametrize('command, result', [
+    (Command('az providers list', misspelled_command), ['az provider list']),
+    (Command('az provider lis', misspelled_subcommand), ['az provider list'])
+])
+def test_get_new_command(command, result):
+    assert get_new_command(command) == result

tests/rules/test_brew_reinstall.py

@@ -0,0 +1,28 @@
+import pytest
+from thefuck.types import Command
+from thefuck.rules.brew_reinstall import get_new_command, match
+
+
+output = ("Warning: thefuck 9.9 is already installed and up-to-date\nTo "
+          "reinstall 9.9, run `brew reinstall thefuck`")
+
+
+def test_match():
+    command = Command('brew install thefuck', output)
+    assert match(command)
+
+
+@pytest.mark.parametrize('script', [
+    'brew reinstall thefuck',
+    'brew install foo'])
+def test_not_match(script):
+    assert not match(Command(script, ''))
+
+
+@pytest.mark.parametrize('script, formula, ', [
+    ('brew install foo', 'foo'),
+    ('brew install bar zap', 'bar zap')])
+def test_get_new_command(script, formula):
+    command = Command(script, output)
+    new_command = 'brew reinstall {}'.format(formula)
+    assert get_new_command(command) == new_command

tests/rules/test_cat_dir.py

@@ -0,0 +1,39 @@
+import pytest
+from thefuck.rules.cat_dir import match, get_new_command
+from thefuck.types import Command
+
+
+@pytest.fixture
+def isdir(mocker):
+    return mocker.patch('thefuck.rules.cat_dir'
+                        '.os.path.isdir')
+
+
+@pytest.mark.parametrize('command', [
+    Command('cat foo', 'cat: foo: Is a directory\n'),
+    Command('cat /foo/bar/', 'cat: /foo/bar/: Is a directory\n'),
+    Command('cat cat/', 'cat: cat/: Is a directory\n'),
+])
+def test_match(command, isdir):
+    isdir.return_value = True
+    assert match(command)
+
+
+@pytest.mark.parametrize('command', [
+    Command('cat foo', 'foo bar baz'),
+    Command('cat foo bar', 'foo bar baz'),
+    Command('notcat foo bar', 'some output'),
+])
+def test_not_match(command, isdir):
+    isdir.return_value = False
+    assert not match(command)
+
+
+@pytest.mark.parametrize('command, new_command', [
+    (Command('cat foo', 'cat: foo: Is a directory\n'), 'ls foo'),
+    (Command('cat /foo/bar/', 'cat: /foo/bar/: Is a directory\n'), 'ls /foo/bar/'),
+    (Command('cat cat', 'cat: cat: Is a directory\n'), 'ls cat'),
+])
+def test_get_new_command(command, new_command):
+    isdir.return_value = True
+    assert get_new_command(command) == new_command

tests/rules/test_cd_correction.py

@@ -0,0 +1,23 @@
+import pytest
+from thefuck.rules.cd_correction import match
+from thefuck.types import Command
+
+
+@pytest.mark.parametrize('command', [
+    Command('cd foo', 'cd: foo: No such file or directory'),
+    Command('cd foo/bar/baz',
+            'cd: foo: No such file or directory'),
+    Command('cd foo/bar/baz', 'cd: can\'t cd to foo/bar/baz'),
+    Command('cd /foo/bar/', 'cd: The directory "/foo/bar/" does not exist')])
+def test_match(command):
+    assert match(command)
+
+
+@pytest.mark.parametrize('command', [
+    Command('cd foo', ''), Command('', '')])
+def test_not_match(command):
+    assert not match(command)
+
+
+# Note that get_new_command uses local filesystem, so not testing it here.
+# Instead, see the functional test `functional.test_cd_correction`

tests/rules/test_cd_mkdir.py

@@ -7,7 +7,8 @@ from thefuck.types import Command
     Command('cd foo', 'cd: foo: No such file or directory'),
     Command('cd foo/bar/baz',
             'cd: foo: No such file or directory'),
-    Command('cd foo/bar/baz', 'cd: can\'t cd to foo/bar/baz')])
+    Command('cd foo/bar/baz', 'cd: can\'t cd to foo/bar/baz'),
+    Command('cd /foo/bar/', 'cd: The directory "/foo/bar/" does not exist')])
 def test_match(command):
     assert match(command)
 

tests/rules/test_git_branch_exists.py

@@ -4,8 +4,8 @@ from thefuck.types import Command
 
 
 @pytest.fixture
-def output(branch_name):
-    return "fatal: A branch named '{}' already exists.".format(branch_name)
+def output(src_branch_name):
+    return "fatal: A branch named '{}' already exists.".format(src_branch_name)
 
 
 @pytest.fixture
@@ -17,18 +17,25 @@ def new_command(branch_name):
         'git branch -D {0} && git checkout -b {0}', 'git checkout {0}']]
 
 
-@pytest.mark.parametrize('script, branch_name', [
-    ('git branch foo', 'foo'), ('git checkout bar', 'bar')])
+@pytest.mark.parametrize('script, src_branch_name, branch_name', [
+    ('git branch foo', 'foo', 'foo'),
+    ('git checkout bar', 'bar', 'bar'),
+    ('git checkout -b "let\'s-push-this"', '"let\'s-push-this"', '"let\'s-push-this"')])
 def test_match(output, script, branch_name):
     assert match(Command(script, output))
 
 
-@pytest.mark.parametrize('script', ['git branch foo', 'git checkout bar'])
+@pytest.mark.parametrize('script', [
+    'git branch foo',
+    'git checkout bar',
+    'git checkout -b "let\'s-push-this"'])
 def test_not_match(script):
     assert not match(Command(script, ''))
 
 
-@pytest.mark.parametrize('script, branch_name, ', [
-    ('git branch foo', 'foo'), ('git checkout bar', 'bar')])
-def test_get_new_command(output, new_command, script, branch_name):
+@pytest.mark.parametrize('script, src_branch_name, branch_name', [
+    ('git branch foo', 'foo', 'foo'),
+    ('git checkout bar', 'bar', 'bar'),
+    ('git checkout -b "let\'s-push-this"', "let's-push-this", "let\\'s-push-this")])
+def test_get_new_command(output, new_command, script, src_branch_name, branch_name):
     assert get_new_command(Command(script, output)) == new_command

tests/rules/test_git_checkout.py

@@ -4,7 +4,6 @@ from thefuck.rules.git_checkout import match, get_branches, get_new_command
 from thefuck.types import Command
 
 
-@pytest.fixture
 def did_not_match(target, did_you_forget=False):
     error = ("error: pathspec '{}' did not match any "
              "file(s) known to git.".format(target))
@@ -52,7 +51,7 @@ def test_get_branches(branches, branch_list, git_branch):
 @pytest.mark.parametrize('branches, command, new_command', [
     (b'',
      Command('git checkout unknown', did_not_match('unknown')),
-     'git branch unknown && git checkout unknown'),
+     'git checkout -b unknown'),
     (b'',
      Command('git commit unknown', did_not_match('unknown')),
      'git branch unknown && git commit unknown'),

tests/rules/test_git_commit_amend.py

@@ -0,0 +1,25 @@
+import pytest
+from thefuck.rules.git_commit_amend import match, get_new_command
+from thefuck.types import Command
+
+
+@pytest.mark.parametrize('script, output', [
+    ('git commit -m "test"', 'test output'),
+    ('git commit', '')])
+def test_match(output, script):
+    assert match(Command(script, output))
+
+
+@pytest.mark.parametrize('script', [
+    'git branch foo',
+    'git checkout feature/test_commit',
+    'git push'])
+def test_not_match(script):
+    assert not match(Command(script, ''))
+
+
+@pytest.mark.parametrize('script', [
+    ('git commit -m "test commit"'),
+    ('git commit')])
+def test_get_new_command(script):
+    assert get_new_command(Command(script, '')) == 'git commit --amend'

tests/rules/test_git_flag_after_filename.py

@@ -8,10 +8,16 @@ command2 = Command('git log README.md -p CONTRIBUTING.md',
                    "fatal: bad flag '-p' used after filename")
 command3 = Command('git log -p README.md --name-only',
                    "fatal: bad flag '--name-only' used after filename")
+command4 = Command('git log README.md -p',
+                   "fatal: option '-p' must come before non-option arguments")
+command5 = Command('git log README.md -p CONTRIBUTING.md',
+                   "fatal: option '-p' must come before non-option arguments")
+command6 = Command('git log -p README.md --name-only',
+                   "fatal: option '--name-only' must come before non-option arguments")
 
 
 @pytest.mark.parametrize('command', [
-    command1, command2, command3])
+    command1, command2, command3, command4, command5, command6])
 def test_match(command):
     assert match(command)
 
@@ -26,6 +32,9 @@ def test_not_match(command):
 @pytest.mark.parametrize('command, result', [
     (command1, "git log -p README.md"),
     (command2, "git log -p README.md CONTRIBUTING.md"),
-    (command3, "git log -p --name-only README.md")])
+    (command3, "git log -p --name-only README.md"),
+    (command4, "git log -p README.md"),
+    (command5, "git log -p README.md CONTRIBUTING.md"),
+    (command6, "git log -p --name-only README.md")])
 def test_get_new_command(command, result):
     assert get_new_command(command) == result

tests/rules/test_git_merge.py

@@ -0,0 +1,24 @@
+import pytest
+from thefuck.rules.git_merge import match, get_new_command
+from thefuck.types import Command
+
+
+output = 'merge: local - not something we can merge\n\n' \
+         'Did you mean this?\n\tremote/local'
+
+
+def test_match():
+    assert match(Command('git merge test', output))
+    assert not match(Command('git merge master', ''))
+    assert not match(Command('ls', output))
+
+
+@pytest.mark.parametrize('command, new_command', [
+    (Command('git merge local', output),
+     'git merge remote/local'),
+    (Command('git merge -m "test" local', output),
+     'git merge -m "test" remote/local'),
+    (Command('git merge -m "test local" local', output),
+     'git merge -m "test local" remote/local')])
+def test_get_new_command(command, new_command):
+    assert get_new_command(command) == new_command

tests/rules/test_git_merge_unrelated.py

@@ -0,0 +1,23 @@
+import pytest
+from thefuck.rules.git_merge_unrelated import match, get_new_command
+from thefuck.types import Command
+
+
+output = 'fatal: refusing to merge unrelated histories'
+
+
+def test_match():
+    assert match(Command('git merge test', output))
+    assert not match(Command('git merge master', ''))
+    assert not match(Command('ls', output))
+
+
+@pytest.mark.parametrize('command, new_command', [
+    (Command('git merge local', output),
+     'git merge local --allow-unrelated-histories'),
+    (Command('git merge -m "test" local', output),
+     'git merge -m "test" local --allow-unrelated-histories'),
+    (Command('git merge -m "test local" local', output),
+     'git merge -m "test local" local --allow-unrelated-histories')])
+def test_get_new_command(command, new_command):
+    assert get_new_command(command) == new_command

tests/rules/test_git_push.py

@@ -4,30 +4,72 @@ from thefuck.types import Command
 
 
 @pytest.fixture
-def output():
-    return '''fatal: The current branch master has no upstream branch.
+def output(branch_name):
+    if not branch_name:
+        return ''
+    return '''fatal: The current branch {} has no upstream branch.
 To push the current branch and set the remote as upstream, use
 
-    git push --set-upstream origin master
+    git push --set-upstream origin {}
 
+'''.format(branch_name, branch_name)
+
+
+@pytest.fixture
+def output_bitbucket():
+    return '''Total 0 (delta 0), reused 0 (delta 0)
+remote:
+remote: Create pull request for feature/set-upstream:
+remote:   https://bitbucket.org/set-upstream
+remote:
+To git@bitbucket.org:test.git
+   e5e7fbb..700d998  feature/set-upstream -> feature/set-upstream
+Branch feature/set-upstream set up to track remote branch feature/set-upstream from origin.
 '''
 
 
-def test_match(output):
-    assert match(Command('git push', output))
-    assert match(Command('git push master', output))
-    assert not match(Command('git push master', ''))
-    assert not match(Command('ls', output))
+@pytest.mark.parametrize('script, branch_name', [
+    ('git push', 'master'),
+    ('git push origin', 'master')])
+def test_match(output, script, branch_name):
+    assert match(Command(script, output))
 
 
-def test_get_new_command(output):
-    assert get_new_command(Command('git push', output))\
-        == "git push --set-upstream origin master"
-    assert get_new_command(Command('git push -u', output))\
-        == "git push --set-upstream origin master"
-    assert get_new_command(Command('git push -u origin', output))\
-        == "git push --set-upstream origin master"
-    assert get_new_command(Command('git push --set-upstream origin', output))\
-        == "git push --set-upstream origin master"
-    assert get_new_command(Command('git push --quiet', output))\
-        == "git push --set-upstream origin master --quiet"
+def test_match_bitbucket(output_bitbucket):
+    assert not match(Command('git push origin', output_bitbucket))
+
+
+@pytest.mark.parametrize('script, branch_name', [
+    ('git push master', None),
+    ('ls', 'master')])
+def test_not_match(output, script, branch_name):
+    assert not match(Command(script, output))
+
+
+@pytest.mark.parametrize('script, branch_name, new_command', [
+    ('git push', 'master',
+     'git push --set-upstream origin master'),
+    ('git push master', 'master',
+     'git push --set-upstream origin master'),
+    ('git push -u', 'master',
+     'git push --set-upstream origin master'),
+    ('git push -u origin', 'master',
+     'git push --set-upstream origin master'),
+    ('git push origin', 'master',
+     'git push --set-upstream origin master'),
+    ('git push --set-upstream origin', 'master',
+     'git push --set-upstream origin master'),
+    ('git push --quiet', 'master',
+     'git push --set-upstream origin master --quiet'),
+    ('git push --quiet origin', 'master',
+     'git push --set-upstream origin master --quiet'),
+    ('git -c test=test push --quiet origin', 'master',
+     'git -c test=test push --set-upstream origin master --quiet'),
+    ('git push', "test's",
+     "git push --set-upstream origin test\\'s"),
+    ('git push --force', 'master',
+     'git push --set-upstream origin master --force'),
+    ('git push --force-with-lease', 'master',
+     'git push --set-upstream origin master --force-with-lease')])
+def test_get_new_command(output, script, branch_name, new_command):
+    assert get_new_command(Command(script, output)) == new_command

tests/rules/test_heroku_multiple_apps.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+
+import pytest
+from thefuck.types import Command
+from thefuck.rules.heroku_multiple_apps import match, get_new_command
+
+
+suggest_output = '''
+ ▸    Multiple apps in git remotes
+ ▸    Usage: --remote heroku-dev
+ ▸    or: --app myapp-dev
+ ▸    Your local git repository has more than 1 app referenced in git remotes.
+ ▸    Because of this, we can't determine which app you want to run this command against.
+ ▸    Specify the app you want with --app or --remote.
+ ▸    Heroku remotes in repo:
+ ▸    myapp (heroku)
+ ▸    myapp-dev (heroku-dev)
+ ▸
+ ▸    https://devcenter.heroku.com/articles/multiple-environments
+'''
+
+not_match_output = '''
+=== HEROKU_POSTGRESQL_TEAL_URL, DATABASE_URL
+Plan:                  Hobby-basic
+Status:                Available
+Connections:           20/20
+PG Version:            9.6.4
+Created:               2017-01-01 00:00 UTC
+Data Size:             99.9 MB
+Tables:                99
+Rows:                  12345/10000000 (In compliance)
+Fork/Follow:           Unsupported
+Rollback:              Unsupported
+Continuous Protection: Off
+Add-on:                postgresql-round-12345
+'''
+
+
+@pytest.mark.parametrize('cmd', ['pg'])
+def test_match(cmd):
+    assert match(
+        Command('heroku {}'.format(cmd), suggest_output))
+
+
+@pytest.mark.parametrize('script, output', [
+    ('heroku pg', not_match_output)])
+def test_not_match(script, output):
+    assert not match(Command(script, output))
+
+
+@pytest.mark.parametrize('cmd, result', [
+    ('pg', ['heroku pg --app myapp', 'heroku pg --app myapp-dev'])])
+def test_get_new_command(cmd, result):
+    command = Command('heroku {}'.format(cmd), suggest_output)
+    assert get_new_command(command) == result

tests/rules/test_long_form_help.py

@@ -0,0 +1,22 @@
+import pytest
+from thefuck.rules.long_form_help import match, get_new_command
+from thefuck.types import Command
+
+
+@pytest.mark.parametrize('output', [
+    'Try \'grep --help\' for more information.'])
+def test_match(output):
+    assert match(Command('grep -h', output))
+
+
+def test_not_match():
+    assert not match(Command('', ''))
+
+
+@pytest.mark.parametrize('before, after', [
+    ('grep -h', 'grep --help'),
+    ('tar -h', 'tar --help'),
+    ('docker run -h', 'docker run --help'),
+    ('cut -h', 'cut --help')])
+def test_get_new_command(before, after):
+    assert get_new_command(Command(before, '')) == after

tests/rules/test_switch_lang.py

@@ -7,7 +7,9 @@ from thefuck.types import Command
 
 @pytest.mark.parametrize('command', [
     Command(u'фзе-пуе', 'command not found: фзе-пуе'),
-    Command(u'λσ', 'command not found: λσ')])
+    Command(u'λσ', 'command not found: λσ'),
+    Command(u'שפא-עקא', 'command not found: שפא-עקא'),
+    Command(u'ךד', 'command not found: ךד')])
 def test_match(command):
     assert switch_lang.match(command)
 
@@ -16,13 +18,16 @@ def test_match(command):
     Command(u'pat-get', 'command not found: pat-get'),
     Command(u'ls', 'command not found: ls'),
     Command(u'агсл', 'command not found: агсл'),
-    Command(u'фзе-пуе', 'some info')])
+    Command(u'фзе-пуе', 'some info'),
+    Command(u'שפא-עקא', 'some info')])
 def test_not_match(command):
     assert not switch_lang.match(command)
 
 
 @pytest.mark.parametrize('command, new_command', [
     (Command(u'фзе-пуе штыефдд мшь', ''), 'apt-get install vim'),
-    (Command(u'λσ -λα', ''), 'ls -la')])
+    (Command(u'λσ -λα', ''), 'ls -la'),
+    (Command(u'שפא-עקא ןמדאשךך הןצ', ''), 'apt-get install vim'),
+    (Command(u'ךד -ךש', ''), 'ls -la')])
 def test_get_new_command(command, new_command):
     assert switch_lang.get_new_command(command) == new_command

tests/rules/test_touch.py

@@ -3,25 +3,31 @@ from thefuck.rules.touch import match, get_new_command
 from thefuck.types import Command
 
 
-@pytest.fixture
-def output():
-    return "touch: cannot touch '/a/b/c':" \
-           " No such file or directory"
+def output(is_bsd):
+    if is_bsd:
+        return "touch: /a/b/c: No such file or directory"
+    return "touch: cannot touch '/a/b/c': No such file or directory"
 
 
-def test_match(output):
-    command = Command('touch /a/b/c', output)
+@pytest.mark.parametrize('script, is_bsd', [
+    ('touch /a/b/c', False),
+    ('touch /a/b/c', True)])
+def test_match(script, is_bsd):
+    command = Command(script, output(is_bsd))
     assert match(command)
 
 
 @pytest.mark.parametrize('command', [
     Command('touch /a/b/c', ''),
-    Command('ls /a/b/c', output())])
+    Command('ls /a/b/c', output(False))])
 def test_not_match(command):
     assert not match(command)
 
 
-def test_get_new_command(output):
-    command = Command('touch /a/b/c', output)
+@pytest.mark.parametrize('script, is_bsd', [
+    ('touch /a/b/c', False),
+    ('touch /a/b/c', True)])
+def test_get_new_command(script, is_bsd):
+    command = Command(script, output(is_bsd))
     fixed_command = get_new_command(command)
     assert fixed_command == 'mkdir -p /a/b && touch /a/b/c'

tests/rules/test_unsudo.py

@@ -0,0 +1,22 @@
+import pytest
+from thefuck.rules.unsudo import match, get_new_command
+from thefuck.types import Command
+
+
+@pytest.mark.parametrize('output', [
+    'you cannot perform this operation as root'])
+def test_match(output):
+    assert match(Command('sudo ls', output))
+
+
+def test_not_match():
+    assert not match(Command('', ''))
+    assert not match(Command('sudo ls', 'Permission denied'))
+    assert not match(Command('ls', 'you cannot perform this operation as root'))
+
+
+@pytest.mark.parametrize('before, after', [
+    ('sudo ls', 'ls'),
+    ('sudo pacaur -S helloworld', 'pacaur -S helloworld')])
+def test_get_new_command(before, after):
+    assert get_new_command(Command(before, '')) == after

tests/shells/test_bash.py

@@ -51,6 +51,7 @@ class TestBash(object):
     def test_app_alias_variables_correctly_set(self, shell):
         alias = shell.app_alias('fuck')
         assert "fuck () {" in alias
+        assert 'TF_SHELL=bash' in alias
         assert "TF_ALIAS=fuck" in alias
         assert 'PYTHONIOENCODING=utf-8' in alias
         assert 'TF_SHELL_ALIASES=$(alias)' in alias
@@ -72,3 +73,8 @@ class TestBash(object):
                                                     config_exists):
         config_exists.return_value = False
         assert not shell.how_to_configure().can_configure_automatically
+
+    def test_info(self, shell, mocker):
+        patch = mocker.patch('thefuck.shells.bash.Popen')
+        patch.return_value.stdout.read.side_effect = [b'3.5.9']
+        assert shell.info() == 'Bash 3.5.9'

tests/shells/test_fish.py

@@ -13,9 +13,11 @@ class TestFish(object):
     @pytest.fixture(autouse=True)
     def Popen(self, mocker):
         mock = mocker.patch('thefuck.shells.fish.Popen')
-        mock.return_value.stdout.read.return_value = (
+        mock.return_value.stdout.read.side_effect = [(
             b'cd\nfish_config\nfuck\nfunced\nfuncsave\ngrep\nhistory\nll\nls\n'
-            b'man\nmath\npopd\npushd\nruby')
+            b'man\nmath\npopd\npushd\nruby'),
+            (b'alias fish_key_reader /usr/bin/fish_key_reader\nalias g git\n'
+             b'alias alias_with_equal_sign=echo\ninvalid_alias'), b'func1\nfunc2', b'']
         return mock
 
     @pytest.mark.parametrize('key, value', [
@@ -42,7 +44,8 @@ class TestFish(object):
         ('open', 'open'),
         ('vim', 'vim'),
         ('ll', 'fish -ic "ll"'),
-        ('ls', 'ls')])  # Fish has no aliases but functions
+        ('ls', 'ls'),
+        ('g', 'git')])
     def test_from_shell(self, before, after, shell):
         assert shell.from_shell(before) == after
 
@@ -65,12 +68,17 @@ class TestFish(object):
                                        'math': 'math',
                                        'popd': 'popd',
                                        'pushd': 'pushd',
-                                       'ruby': 'ruby'}
+                                       'ruby': 'ruby',
+                                       'g': 'git',
+                                       'fish_key_reader': '/usr/bin/fish_key_reader',
+                                       'alias_with_equal_sign': 'echo'}
+        assert shell.get_aliases() == {'func1': 'func1', 'func2': 'func2'}
 
     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')
+        assert 'TF_SHELL=fish' in shell.app_alias('fuck')
         assert 'TF_ALIAS=fuck PYTHONIOENCODING' in shell.app_alias('fuck')
         assert 'PYTHONIOENCODING=utf-8 thefuck' in shell.app_alias('fuck')
 
@@ -104,3 +112,7 @@ class TestFish(object):
                                                     config_exists):
         config_exists.return_value = False
         assert not shell.how_to_configure().can_configure_automatically
+
+    def test_info(self, shell, Popen):
+        Popen.return_value.stdout.read.side_effect = [b'3.5.9']
+        assert shell.info() == 'Fish Shell 3.5.9'

tests/shells/test_tcsh.py

@@ -44,6 +44,7 @@ class TestTcsh(object):
                                        'll': 'ls -alF'}
 
     def test_app_alias(self, shell):
+        assert 'setenv TF_SHELL tcsh' in shell.app_alias('fuck')
         assert 'alias fuck' in shell.app_alias('fuck')
         assert 'alias FUCK' in shell.app_alias('FUCK')
         assert 'thefuck' in shell.app_alias('fuck')

tests/shells/test_zsh.py

@@ -51,6 +51,7 @@ class TestZsh(object):
     def test_app_alias_variables_correctly_set(self, shell):
         alias = shell.app_alias('fuck')
         assert "fuck () {" in alias
+        assert 'TF_SHELL=zsh' in alias
         assert "TF_ALIAS=fuck" in alias
         assert 'PYTHONIOENCODING=utf-8' in alias
         assert 'TF_SHELL_ALIASES=$(alias)' in alias
@@ -67,3 +68,8 @@ class TestZsh(object):
                                                     config_exists):
         config_exists.return_value = False
         assert not shell.how_to_configure().can_configure_automatically
+
+    def test_info(self, shell, mocker):
+        patch = mocker.patch('thefuck.shells.zsh.Popen')
+        patch.return_value.stdout.read.side_effect = [b'3.5.9']
+        assert shell.info() == 'ZSH 3.5.9'

tests/test_conf.py

@@ -53,7 +53,8 @@ class TestSettingsFromEnv(object):
                            'THEFUCK_NO_COLORS': 'false',
                            'THEFUCK_PRIORITY': 'bash=10:lisp=wrong:vim=15',
                            'THEFUCK_WAIT_SLOW_COMMAND': '999',
-                           'THEFUCK_SLOW_COMMANDS': 'lein:react-native:./gradlew'})
+                           'THEFUCK_SLOW_COMMANDS': 'lein:react-native:./gradlew',
+                           'THEFUCK_NUM_CLOSE_MATCHES': '359'})
         settings.init()
         assert settings.rules == ['bash', 'lisp']
         assert settings.exclude_rules == ['git', 'vim']
@@ -63,6 +64,7 @@ class TestSettingsFromEnv(object):
         assert settings.priority == {'bash': 10, 'vim': 15}
         assert settings.wait_slow_command == 999
         assert settings.slow_commands == ['lein', 'react-native', './gradlew']
+        assert settings.num_close_matches == 359
 
     def test_from_env_with_DEFAULT(self, os_environ, settings):
         os_environ.update({'THEFUCK_RULES': 'DEFAULT_RULES:bash:lisp'})

tests/test_utils.py

@@ -2,11 +2,11 @@
 
 import pytest
 import warnings
-from mock import Mock
+from mock import Mock, patch
 from thefuck.utils import default_settings, \
     memoize, get_closest, get_all_executables, replace_argument, \
     get_all_matched_commands, is_app, for_app, cache, \
-    get_valid_history_without_current, _cache
+    get_valid_history_without_current, _cache, get_close_matches
 from thefuck.types import Command
 
 
@@ -50,6 +50,18 @@ class TestGetClosest(object):
                            fallback_to_first=False) is None
 
 
+class TestGetCloseMatches(object):
+    @patch('thefuck.utils.difflib_get_close_matches')
+    def test_call_with_n(self, difflib_mock):
+        get_close_matches('', [], 1)
+        assert difflib_mock.call_args[0][2] == 1
+
+    @patch('thefuck.utils.difflib_get_close_matches')
+    def test_call_without_n(self, difflib_mock, settings):
+        get_close_matches('', [])
+        assert difflib_mock.call_args[0][2] == settings.get('num_close_matches')
+
+
 @pytest.fixture
 def get_aliases(mocker):
     mocker.patch('thefuck.shells.shell.get_aliases',

thefuck/argument_parser.py

@@ -55,7 +55,7 @@ class Parser(object):
         """It's too dangerous to use `-y` and `-r` together."""
         group = self._parser.add_mutually_exclusive_group()
         group.add_argument(
-            '-y', '--yes',
+            '-y', '--yes', '--yeah',
             action='store_true',
             help='execute fixed command without confirmation')
         group.add_argument(

thefuck/conf.py

@@ -95,7 +95,8 @@ class Settings(dict):
             return self._rules_from_env(val)
         elif attr == 'priority':
             return dict(self._priority_from_env(val))
-        elif attr in ('wait_command', 'history_limit', 'wait_slow_command'):
+        elif attr in ('wait_command', 'history_limit', 'wait_slow_command',
+                      'num_close_matches'):
             return int(val)
         elif attr in ('require_confirmation', 'no_colors', 'debug',
                       'alter_history', 'instant_mode'):

thefuck/const.py

@@ -42,6 +42,7 @@ DEFAULT_SETTINGS = {'rules': DEFAULT_RULES,
                                       './gradlew', 'vagrant'],
                     'repeat': False,
                     'instant_mode': False,
+                    'num_close_matches': 3,
                     'env': {'LC_ALL': 'C', 'LANG': 'C', 'GIT_TRACE': '1'}}
 
 ENV_TO_ATTR = {'THEFUCK_RULES': 'rules',
@@ -56,7 +57,8 @@ ENV_TO_ATTR = {'THEFUCK_RULES': 'rules',
                'THEFUCK_WAIT_SLOW_COMMAND': 'wait_slow_command',
                'THEFUCK_SLOW_COMMANDS': 'slow_commands',
                'THEFUCK_REPEAT': 'repeat',
-               'THEFUCK_INSTANT_MODE': 'instant_mode'}
+               'THEFUCK_INSTANT_MODE': 'instant_mode',
+               'THEFUCK_NUM_CLOSE_MATCHES': 'num_close_matches'}
 
 SETTINGS_HEADER = u"""# The Fuck settings file
 #
@@ -76,8 +78,12 @@ CONFIGURATION_TIMEOUT = 60
 
 USER_COMMAND_MARK = u'\u200B' * 10
 
-LOG_SIZE = 1000
-
 LOG_SIZE_IN_BYTES = 1024 * 1024
 
+LOG_SIZE_TO_CLEAN = 10 * 1024
+
 DIFF_WITH_ALIAS = 0.5
+
+SHELL_LOGGER_SOCKET_ENV = 'SHELL_LOGGER_SOCKET'
+
+SHELL_LOGGER_LIMIT = 5

thefuck/corrector.py

@@ -1,3 +1,4 @@
+import sys
 from .conf import settings
 from .types import Rule
 from .system import Path
@@ -18,17 +19,33 @@ def get_loaded_rules(rules_paths):
                 yield rule
 
 
+def get_rules_import_paths():
+    """Yields all rules import paths.
+
+    :rtype: Iterable[Path]
+
+    """
+    # Bundled rules:
+    yield Path(__file__).parent.joinpath('rules')
+    # Rules defined by user:
+    yield settings.user_dir.joinpath('rules')
+    # Packages with third-party rules:
+    for path in sys.path:
+        for contrib_module in Path(path).glob('thefuck_contrib_*'):
+            contrib_rules = contrib_module.joinpath('rules')
+            if contrib_rules.is_dir():
+                yield contrib_rules
+
+
 def get_rules():
     """Returns all enabled rules.
 
     :rtype: [Rule]
 
     """
-    bundled = Path(__file__).parent \
-        .joinpath('rules') \
-        .glob('*.py')
-    user = settings.user_dir.joinpath('rules').glob('*.py')
-    return sorted(get_loaded_rules(sorted(bundled) + sorted(user)),
+    paths = [rule_path for path in get_rules_import_paths()
+             for rule_path in sorted(path.glob('*.py'))]
+    return sorted(get_loaded_rules(paths),
                   key=lambda rule: rule.priority)
 
 

thefuck/entrypoints/main.py

@@ -8,9 +8,9 @@ import sys  # noqa: E402
 from .. import logs  # noqa: E402
 from ..argument_parser import Parser  # noqa: E402
 from ..utils import get_installation_info  # noqa: E402
+from ..shells import shell  # noqa: E402
 from .alias import print_alias  # noqa: E402
 from .fix_command import fix_command  # noqa: E402
-from .shell_logger import shell_logger  # noqa: E402
 
 
 def main():
@@ -21,12 +21,17 @@ def main():
         parser.print_help()
     elif known_args.version:
         logs.version(get_installation_info().version,
-                     sys.version.split()[0])
+                     sys.version.split()[0], shell.info())
     elif known_args.command or 'TF_HISTORY' in os.environ:
         fix_command(known_args)
     elif known_args.alias:
         print_alias(known_args)
     elif known_args.shell_logger:
-        shell_logger(known_args.shell_logger)
+        try:
+            from .shell_logger import shell_logger  # noqa: E402
+        except ImportError:
+            logs.warn('Shell logger supports only Linux and macOS')
+        else:
+            shell_logger(known_args.shell_logger)
     else:
         parser.print_usage()

thefuck/entrypoints/not_configured.py

@@ -3,6 +3,7 @@ from ..system import init_output
 
 init_output()
 
+import getpass  # noqa: E402
 import os  # noqa: E402
 import json  # noqa: E402
 from tempfile import gettempdir  # noqa: E402
@@ -27,7 +28,9 @@ def _get_shell_pid():
 
 def _get_not_configured_usage_tracker_path():
     """Returns path of special file where we store latest shell pid."""
-    return Path(gettempdir()).joinpath('thefuck.last_not_configured_run')
+    return Path(gettempdir()).joinpath(u'thefuck.last_not_configured_run_{}'.format(
+        getpass.getuser(),
+    ))
 
 
 def _record_first_run():

thefuck/entrypoints/shell_logger.py

@@ -1,19 +1,26 @@
 import array
 import fcntl
 from functools import partial
+import mmap
 import os
 import pty
 import signal
 import sys
 import termios
 import tty
-from ..logs import warn
+from .. import logs, const
 
 
 def _read(f, fd):
     data = os.read(fd, 1024)
-    f.write(data)
-    f.flush()
+    try:
+        f.write(data)
+    except ValueError:
+        position = const.LOG_SIZE_IN_BYTES - const.LOG_SIZE_TO_CLEAN
+        f.move(0, const.LOG_SIZE_TO_CLEAN, position)
+        f.seek(position)
+        f.write(b'\x00' * const.LOG_SIZE_TO_CLEAN)
+        f.seek(position)
     return data
 
 
@@ -61,10 +68,12 @@ def shell_logger(output):
 
     """
     if not os.environ.get('SHELL'):
-        warn("Shell logger doesn't support your platform.")
+        logs.warn("Shell logger doesn't support your platform.")
         sys.exit(1)
 
-    with open(output, 'wb') as f:
-        return_code = _spawn(os.environ['SHELL'], partial(_read, f))
+    fd = os.open(output, os.O_CREAT | os.O_TRUNC | os.O_RDWR)
+    os.write(fd, b'\x00' * const.LOG_SIZE_IN_BYTES)
+    buffer = mmap.mmap(fd, const.LOG_SIZE_IN_BYTES, mmap.MAP_SHARED, mmap.PROT_WRITE)
+    return_code = _spawn(os.environ['SHELL'], partial(_read, buffer))
 
     sys.exit(return_code)

thefuck/logs.py

@@ -134,7 +134,8 @@ def configured_successfully(configuration_details):
             reload=configuration_details.reload))
 
 
-def version(thefuck_version, python_version):
+def version(thefuck_version, python_version, shell_info):
     sys.stderr.write(
-        u'The Fuck {} using Python {}\n'.format(thefuck_version,
-                                                python_version))
+        u'The Fuck {} using Python {} and {}\n'.format(thefuck_version,
+                                                       python_version,
+                                                       shell_info))

thefuck/output_readers/__init__.py

@@ -1,5 +1,5 @@
 from ..conf import settings
-from . import read_log, rerun
+from . import read_log, rerun, shell_logger
 
 
 def get_output(script, expanded):
@@ -12,6 +12,8 @@ def get_output(script, expanded):
     :rtype: str
 
     """
+    if shell_logger.is_available():
+        return shell_logger.get_output(script)
     if settings.instant_mode:
         return read_log.get_output(script)
     else:

thefuck/output_readers/read_log.py

@@ -1,5 +1,7 @@
 import os
 import shlex
+import mmap
+import re
 try:
     from shutil import get_terminal_size
 except ImportError:
@@ -18,11 +20,6 @@ def _group_by_calls(log):
     script_line = None
     lines = []
     for line in log:
-        try:
-            line = line.decode()
-        except UnicodeDecodeError:
-            continue
-
         if const.USER_COMMAND_MARK in line or ps1_counter > 0:
             if script_line and ps1_counter == 0:
                 yield script_line, lines
@@ -53,13 +50,14 @@ def _get_script_group_lines(grouped, script):
 
 
 def _get_output_lines(script, log_file):
-    lines = log_file.readlines()[-const.LOG_SIZE:]
+    data = log_file.read().decode()
+    data = re.sub(r'\x00+$', '', data)
+    lines = data.split('\n')
     grouped = list(_group_by_calls(lines))
     script_lines = _get_script_group_lines(grouped, script)
-
     screen = pyte.Screen(get_terminal_size().columns, len(script_lines))
     stream = pyte.Stream(screen)
-    stream.feed(''.join(script_lines))
+    stream.feed('\n'.join(script_lines))
     return screen.display
 
 
@@ -91,10 +89,11 @@ def get_output(script):
         return None
 
     try:
-        with logs.debug_time(u'Read output from log'), \
-                open(os.environ['THEFUCK_OUTPUT_LOG'], 'rb') as log_file:
-            _skip_old_lines(log_file)
-            lines = _get_output_lines(script, log_file)
+        with logs.debug_time(u'Read output from log'):
+            fd = os.open(os.environ['THEFUCK_OUTPUT_LOG'], os.O_RDONLY)
+            buffer = mmap.mmap(fd, const.LOG_SIZE_IN_BYTES, mmap.MAP_SHARED, mmap.PROT_READ)
+            _skip_old_lines(buffer)
+            lines = _get_output_lines(script, buffer)
             output = '\n'.join(lines).strip()
             logs.debug(u'Received output: {}'.format(output))
             return output

thefuck/output_readers/rerun.py

@@ -1,11 +1,25 @@
 import os
 import shlex
 from subprocess import Popen, PIPE, STDOUT
-from psutil import Process, TimeoutExpired
+from psutil import AccessDenied, Process, TimeoutExpired
 from .. import logs
 from ..conf import settings
 
 
+def _kill_process(proc):
+    """Tries to kill the process otherwise just logs a debug message, the
+    process will be killed when thefuck terminates.
+
+    :type proc: Process
+
+    """
+    try:
+        proc.kill()
+    except AccessDenied:
+        logs.debug(u'Rerun: process PID {} ({}) could not be terminated'.format(
+            proc.pid, proc.exe()))
+
+
 def _wait_output(popen, is_slow):
     """Returns `True` if we can get output of the command in the
     `settings.wait_command` time.
@@ -23,8 +37,8 @@ def _wait_output(popen, is_slow):
         return True
     except TimeoutExpired:
         for child in proc.children(recursive=True):
-            child.kill()
-        proc.kill()
+            _kill_process(child)
+        _kill_process(proc)
         return False
 
 

thefuck/output_readers/shell_logger.py

@@ -0,0 +1,60 @@
+import json
+import os
+import socket
+try:
+    from shutil import get_terminal_size
+except ImportError:
+    from backports.shutil_get_terminal_size import get_terminal_size
+import pyte
+from .. import const, logs
+
+
+def _get_socket_path():
+    return os.environ.get(const.SHELL_LOGGER_SOCKET_ENV)
+
+
+def is_available():
+    """Returns `True` if shell logger socket available.
+
+    :rtype: book
+
+    """
+    path = _get_socket_path()
+    if not path:
+        return False
+
+    return os.path.exists(path)
+
+
+def _get_last_n(n):
+    with socket.socket(socket.AF_UNIX) as client:
+        client.connect(_get_socket_path())
+        request = json.dumps({
+            "type": "list",
+            "count": n,
+        }) + '\n'
+        client.sendall(request.encode('utf-8'))
+        response = client.makefile().readline()
+        return json.loads(response)['commands']
+
+
+def _get_output_lines(output):
+    lines = output.split('\n')
+    screen = pyte.Screen(get_terminal_size().columns, len(lines))
+    stream = pyte.Stream(screen)
+    stream.feed('\n'.join(lines))
+    return screen.display
+
+
+def get_output(script):
+    """Gets command output from shell logger."""
+    with logs.debug_time(u'Read output from external shell logger'):
+        commands = _get_last_n(const.SHELL_LOGGER_LIMIT)
+        for command in commands:
+            if command['command'] == script:
+                lines = _get_output_lines(command['output'])
+                output = '\n'.join(lines).strip()
+                return output
+            else:
+                logs.warn("Output isn't available in shell logger")
+                return None

thefuck/rules/adb_unknown_command.py

@@ -0,0 +1,54 @@
+from thefuck.utils import is_app, get_closest, replace_argument
+
+
+_ADB_COMMANDS = (
+    'backup',
+    'bugreport',
+    'connect',
+    'devices',
+    'disable-verity',
+    'disconnect',
+    'enable-verity',
+    'emu',
+    'forward',
+    'get-devpath',
+    'get-serialno',
+    'get-state',
+    'install',
+    'install-multiple',
+    'jdwp',
+    'keygen',
+    'kill-server',
+    'logcat',
+    'pull',
+    'push',
+    'reboot',
+    'reconnect',
+    'restore',
+    'reverse',
+    'root',
+    'run-as',
+    'shell',
+    'sideload',
+    'start-server',
+    'sync',
+    'tcpip',
+    'uninstall',
+    'unroot',
+    'usb',
+    'wait-for',
+)
+
+
+def match(command):
+    return (is_app(command, 'adb')
+            and command.output.startswith('Android Debug Bridge version'))
+
+
+def get_new_command(command):
+    for idx, arg in enumerate(command.script_parts[1:]):
+        # allowed params to ADB are a/d/e/s/H/P/L where s, H, P and L take additional args
+        # for example 'adb -s 111 logcat' or 'adb -e logcat'
+        if not arg[0] == '-' and not command.script_parts[idx] in ('-s', '-H', '-P', '-L'):
+            adb_cmd = get_closest(arg, _ADB_COMMANDS)
+            return replace_argument(command.script, arg, adb_cmd)

thefuck/rules/apt_get.py

@@ -1,3 +1,4 @@
+from types import ModuleType
 from thefuck.specific.apt import apt_available
 from thefuck.utils import memoize, which
 from thefuck.shells import shell
@@ -5,8 +6,14 @@ from thefuck.shells import shell
 try:
     from CommandNotFound import CommandNotFound
 
-    command_not_found = CommandNotFound()
     enabled_by_default = apt_available
+
+    if isinstance(CommandNotFound, ModuleType):
+        # For ubuntu 18.04+
+        _get_packages = CommandNotFound.CommandNotFound().get_packages
+    else:
+        # For older versions
+        _get_packages = CommandNotFound().getPackages
 except ImportError:
     enabled_by_default = False
 
@@ -21,7 +28,7 @@ def _get_executable(command):
 @memoize
 def get_package(executable):
     try:
-        packages = command_not_found.getPackages(executable)
+        packages = _get_packages(executable)
         return packages[0][0]
     except IndexError:
         # IndexError is thrown when no matching package is found

thefuck/rules/apt_list_upgradable.py

@@ -0,0 +1,16 @@
+from thefuck.specific.apt import apt_available
+from thefuck.specific.sudo import sudo_support
+from thefuck.utils import for_app
+
+enabled_by_default = apt_available
+
+
+@sudo_support
+@for_app('apt')
+def match(command):
+    return "Run 'apt list --upgradable' to see them." in command.output
+
+
+@sudo_support
+def get_new_command(command):
+    return 'apt list --upgradable'

thefuck/rules/apt_upgrade.py

@@ -0,0 +1,16 @@
+from thefuck.specific.apt import apt_available
+from thefuck.specific.sudo import sudo_support
+from thefuck.utils import for_app
+
+enabled_by_default = apt_available
+
+
+@sudo_support
+@for_app('apt')
+def match(command):
+    return command.script == "apt list --upgradable" and len(command.output.strip().split('\n')) > 1
+
+
+@sudo_support
+def get_new_command(command):
+    return 'apt upgrade'

thefuck/rules/aws_cli.py

@@ -3,7 +3,7 @@ import re
 from thefuck.utils import for_app, replace_argument
 
 INVALID_CHOICE = "(?<=Invalid choice: ')(.*)(?=', maybe you meant:)"
-OPTIONS = "^\s*\*\s(.*)"
+OPTIONS = "^\\s*\\*\\s(.*)"
 
 
 @for_app('aws')

thefuck/rules/az_cli.py

@@ -0,0 +1,17 @@
+import re
+
+from thefuck.utils import for_app, replace_argument
+
+INVALID_CHOICE = "(?=az)(?:.*): '(.*)' is not in the '.*' command group."
+OPTIONS = "^The most similar choice to '.*' is:\n\\s*(.*)$"
+
+
+@for_app('az')
+def match(command):
+    return "is not in the" in command.output and "command group" in command.output
+
+
+def get_new_command(command):
+    mistake = re.search(INVALID_CHOICE, command.output).group(1)
+    options = re.findall(OPTIONS, command.output, flags=re.MULTILINE)
+    return [replace_argument(command.script, mistake, o) for o in options]

thefuck/rules/brew_install.py

@@ -15,12 +15,12 @@ def _get_formulas():
         for file_name in os.listdir(brew_formula_path):
             if file_name.endswith('.rb'):
                 yield file_name[:-3]
-    except:
+    except Exception:
         pass
 
 
 def _get_similar_formula(formula_name):
-    return get_closest(formula_name, _get_formulas(), 1, 0.85)
+    return get_closest(formula_name, _get_formulas(), cutoff=0.85)
 
 
 def match(command):

thefuck/rules/brew_reinstall.py

@@ -0,0 +1,19 @@
+import re
+from thefuck.utils import for_app
+
+
+warning_regex = re.compile(r'Warning: (?:.(?!is ))+ is already installed and '
+                           r'up-to-date')
+message_regex = re.compile(r'To reinstall (?:(?!, ).)+, run `brew reinstall '
+                           r'[^`]+`')
+
+
+@for_app('brew', at_least=2)
+def match(command):
+    return ('install' in command.script
+            and warning_regex.search(command.output)
+            and message_regex.search(command.output))
+
+
+def get_new_command(command):
+    return command.script.replace('install', 'reinstall')

thefuck/rules/cat_dir.py

@@ -0,0 +1,14 @@
+import os
+from thefuck.utils import for_app
+
+
+@for_app('cat', at_least=1)
+def match(command):
+    return (
+        command.output.startswith('cat: ') and
+        os.path.isdir(command.script_parts[1])
+    )
+
+
+def get_new_command(command):
+    return command.script.replace('cat', 'ls', 1)

thefuck/rules/cd_correction.py

@@ -2,10 +2,9 @@
 
 import os
 import six
-from difflib import get_close_matches
 from thefuck.specific.sudo import sudo_support
 from thefuck.rules import cd_mkdir
-from thefuck.utils import for_app
+from thefuck.utils import for_app, get_close_matches
 
 __author__ = "mmussomele"
 
@@ -21,9 +20,12 @@ def _get_sub_dirs(parent):
 @for_app('cd')
 def match(command):
     """Match function copied from cd_mkdir.py"""
-    return (command.script.startswith('cd ')
-            and ('no such file or directory' in command.output.lower()
-                 or 'cd: can\'t cd to' in command.output.lower()))
+    return (
+        command.script.startswith('cd ') and any((
+            'no such file or directory' in command.output.lower(),
+            'cd: can\'t cd to' in command.output.lower(),
+            'does not exist' in command.output.lower()
+        )))
 
 
 @sudo_support
@@ -37,7 +39,11 @@ def get_new_command(command):
     dest = command.script_parts[1].split(os.sep)
     if dest[-1] == '':
         dest = dest[:-1]
-    if six.PY2:
+
+    if dest[0] == '':
+        cwd = os.sep
+        dest = dest[1:]
+    elif six.PY2:
         cwd = os.getcwdu()
     else:
         cwd = os.getcwd()

thefuck/rules/cd_mkdir.py

@@ -8,10 +8,11 @@ from thefuck.shells import shell
 @for_app('cd')
 def match(command):
     return (
-        'no such file or directory' in command.output.lower()
-        or 'cd: can\'t cd to' in command.output.lower()
-        or 'the system cannot find the path specified.' in command.output.lower()
-    )
+        command.script.startswith('cd ') and any((
+            'no such file or directory' in command.output.lower(),
+            'cd: can\'t cd to' in command.output.lower(),
+            'does not exist' in command.output.lower()
+        )))
 
 
 @sudo_support

thefuck/rules/dirty_unzip.py

@@ -8,7 +8,7 @@ def _is_bad_zip(file):
     try:
         with zipfile.ZipFile(file, 'r') as archive:
             return len(archive.namelist()) > 1
-    except:
+    except Exception:
         return False
 
 

thefuck/rules/git_branch_exists.py

@@ -7,14 +7,15 @@ from thefuck.utils import eager
 @git_support
 def match(command):
     return ("fatal: A branch named '" in command.output
-            and " already exists." in command.output)
+            and "' already exists." in command.output)
 
 
 @git_support
 @eager
 def get_new_command(command):
     branch_name = re.findall(
-        r"fatal: A branch named '([^']*)' already exists.", command.output)[0]
+        r"fatal: A branch named '(.+)' already exists.", command.output)[0]
+    branch_name = branch_name.replace("'", r"\'")
     new_command_templates = [['git branch -d {0}', 'git branch {0}'],
                              ['git branch -d {0}', 'git checkout -b {0}'],
                              ['git branch -D {0}', 'git branch {0}'],

thefuck/rules/git_checkout.py

@@ -34,6 +34,8 @@ def get_new_command(command):
                                        fallback_to_first=False)
     if closest_branch:
         return replace_argument(command.script, missing_file, closest_branch)
+    elif command.script_parts[1] == 'checkout':
+        return replace_argument(command.script, 'checkout', 'checkout -b')
     else:
         return shell.and_('git branch {}', '{}').format(
             missing_file, command.script)

thefuck/rules/git_commit_amend.py

@@ -0,0 +1,11 @@
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return ('commit' in command.script_parts)
+
+
+@git_support
+def get_new_command(command):
+    return 'git commit --amend'

thefuck/rules/git_flag_after_filename.py

@@ -2,11 +2,12 @@ import re
 from thefuck.specific.git import git_support
 
 error_pattern = "fatal: bad flag '(.*?)' used after filename"
+error_pattern2 = "fatal: option '(.*?)' must come before non-option arguments"
 
 
 @git_support
 def match(command):
-    return re.search(error_pattern, command.output)
+    return re.search(error_pattern, command.output) or re.search(error_pattern2, command.output)
 
 
 @git_support
@@ -14,7 +15,7 @@ def get_new_command(command):
     command_parts = command.script_parts[:]
 
     # find the bad flag
-    bad_flag = re.search(error_pattern, command.output).group(1)
+    bad_flag = match(command).group(1)
     bad_flag_index = command_parts.index(bad_flag)
 
     # find the filename

thefuck/rules/git_merge.py

@@ -0,0 +1,18 @@
+import re
+from thefuck.utils import replace_argument
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return ('merge' in command.script
+            and ' - not something we can merge' in command.output
+            and 'Did you mean this?' in command.output)
+
+
+@git_support
+def get_new_command(command):
+    unknown_branch = re.findall(r'merge: (.+) - not something we can merge', command.output)[0]
+    remote_branch = re.findall(r'Did you mean this\?\n\t([^\n]+)', command.output)[0]
+
+    return replace_argument(command.script, unknown_branch, remote_branch)

thefuck/rules/git_merge_unrelated.py

@@ -0,0 +1,12 @@
+from thefuck.specific.git import git_support
+
+
+@git_support
+def match(command):
+    return ('merge' in command.script
+            and 'fatal: refusing to merge unrelated histories' in command.output)
+
+
+@git_support
+def get_new_command(command):
+    return command.script + ' --allow-unrelated-histories'

thefuck/rules/git_push.py

@@ -5,8 +5,8 @@ from thefuck.specific.git import git_support
 
 @git_support
 def match(command):
-    return ('push' in command.script
-            and 'set-upstream' in command.output)
+    return ('push' in command.script_parts
+            and 'git push --set-upstream' in command.output)
 
 
 def _get_upstream_option_index(command_parts):
@@ -32,7 +32,13 @@ def get_new_command(command):
         # In case of `git push -u` we don't have next argument:
         if len(command_parts) > upstream_option_index:
             command_parts.pop(upstream_option_index)
+    else:
+        # the only non-qualified permitted options are the repository and refspec; git's
+        # suggestion include them, so they won't be lost, but would be duplicated otherwise.
+        push_idx = command_parts.index('push') + 1
+        while len(command_parts) > push_idx and command_parts[len(command_parts) - 1][0] != '-':
+            command_parts.pop(len(command_parts) - 1)
 
-    arguments = re.findall(r'git push (.*)', command.output)[0].strip()
+    arguments = re.findall(r'git push (.*)', command.output)[-1].replace("'", r"\'").strip()
     return replace_argument(" ".join(command_parts), 'push',
                             'push {}'.format(arguments))

thefuck/rules/git_rebase_merge_dir.py

@@ -1,4 +1,4 @@
-from difflib import get_close_matches
+from thefuck.utils import get_close_matches
 from thefuck.specific.git import git_support
 
 

thefuck/rules/heroku_multiple_apps.py

@@ -0,0 +1,12 @@
+import re
+from thefuck.utils import for_app
+
+
+@for_app('heroku')
+def match(command):
+    return 'https://devcenter.heroku.com/articles/multiple-environments' in command.output
+
+
+def get_new_command(command):
+    apps = re.findall('([^ ]*) \\([^)]*\\)', command.output)
+    return [command.script + ' --app ' + app for app in apps]

thefuck/rules/history.py

@@ -1,5 +1,5 @@
-from difflib import get_close_matches
-from thefuck.utils import get_closest, get_valid_history_without_current
+from thefuck.utils import get_close_matches, get_closest, \
+    get_valid_history_without_current
 
 
 def match(command):

thefuck/rules/long_form_help.py

@@ -0,0 +1,27 @@
+from thefuck.utils import replace_argument
+import re
+
+# regex to match a suggested help command from the tool output
+help_regex = r"(?:Run|Try) '([^']+)'(?: or '[^']+')? for (?:details|more information)."
+
+
+def match(command):
+    if re.search(help_regex, command.output, re.I) is not None:
+        return True
+
+    if '--help' in command.output:
+        return True
+
+    return False
+
+
+def get_new_command(command):
+    if re.search(help_regex, command.output) is not None:
+        match_obj = re.search(help_regex, command.output, re.I)
+        return match_obj.group(1)
+
+    return replace_argument(command.script, '-h', '--help')
+
+
+enabled_by_default = True
+priority = 5000

thefuck/rules/mvn_unknown_lifecycle_phase.py

@@ -1,5 +1,4 @@
-from thefuck.utils import replace_command, for_app
-from difflib import get_close_matches
+from thefuck.utils import for_app, get_close_matches, replace_command
 import re
 
 
@@ -25,8 +24,7 @@ def get_new_command(command):
     available_lifecycles = _getavailable_lifecycles(command)
     if available_lifecycles and failed_lifecycle:
         selected_lifecycle = get_close_matches(
-            failed_lifecycle.group(1), available_lifecycles.group(1).split(", "),
-            3, 0.6)
+            failed_lifecycle.group(1), available_lifecycles.group(1).split(", "))
         return replace_command(command, failed_lifecycle.group(1), selected_lifecycle)
     else:
         return []

thefuck/rules/no_command.py

@@ -1,5 +1,4 @@
-from difflib import get_close_matches
-from thefuck.utils import get_all_executables, \
+from thefuck.utils import get_all_executables, get_close_matches, \
     get_valid_history_without_current, get_closest, which
 from thefuck.specific.sudo import sudo_support
 

thefuck/rules/switch_lang.py

@@ -4,8 +4,10 @@ from thefuck.utils import memoize, get_alias
 target_layout = '''qwertyuiop[]asdfghjkl;'zxcvbnm,./QWERTYUIOP{}ASDFGHJKL:"ZXCVBNM<>?'''
 
 source_layouts = [u'''йцукенгшщзхъфывапролджэячсмитьбю.ЙЦУКЕНГШЩЗХЪФЫВАПРОЛДЖЭЯЧСМИТЬБЮ,''',
+                  u'''йцукенгшщзхїфівапролджєячсмитьбю.ЙЦУКЕНГШЩЗХЇФІВАПРОЛДЖЄЯЧСМИТЬБЮ,''',
                   u'''ضصثقفغعهخحجچشسیبلاتنمکگظطزرذدپو./ًٌٍَُِّْ][}{ؤئيإأآة»«:؛كٓژٰ‌ٔء><؟''',
-                  u''';ςερτυθιοπ[]ασδφγηξκλ΄ζχψωβνμ,./:΅ΕΡΤΥΘΙΟΠ{}ΑΣΔΦΓΗΞΚΛ¨"ΖΧΨΩΒΝΜ<>?''']
+                  u''';ςερτυθιοπ[]ασδφγηξκλ΄ζχψωβνμ,./:΅ΕΡΤΥΘΙΟΠ{}ΑΣΔΦΓΗΞΚΛ¨"ΖΧΨΩΒΝΜ<>?''',
+                  u'''/'קראטוןםפ][שדגכעיחלךף,זסבהנמצתץ.QWERTYUIOP{}ASDFGHJKL:"ZXCVBNM<>?''']
 
 
 @memoize
@@ -14,7 +16,14 @@ def _get_matched_layout(command):
     # result in a non-splitable sript as per shlex
     cmd = command.script.split(' ')
     for source_layout in source_layouts:
-        if all([ch in source_layout or ch in '-_' for ch in cmd[0]]):
+        is_all_match = True
+
+        for cmd_part in cmd:
+            if not all([ch in source_layout or ch in '-_' for ch in cmd_part]):
+                is_all_match = False
+                break
+
+        if is_all_match:
             return source_layout
 
 

thefuck/rules/touch.py

@@ -9,5 +9,6 @@ def match(command):
 
 
 def get_new_command(command):
-    path = re.findall(r"touch: cannot touch '(.+)/.+':", command.output)[0]
+    path = path = re.findall(
+        r"touch: (?:cannot touch ')?(.+)/.+'?:", command.output)[0]
     return shell.and_(u'mkdir -p {}'.format(path), command.script)

thefuck/rules/unsudo.py

@@ -0,0 +1,15 @@
+patterns = ['you cannot perform this operation as root']
+
+
+def match(command):
+    if command.script_parts and command.script_parts[0] != 'sudo':
+        return False
+
+    for pattern in patterns:
+        if pattern in command.output.lower():
+            return True
+    return False
+
+
+def get_new_command(command):
+    return ' '.join(command.script_parts[1:])

thefuck/shells/__init__.py

@@ -16,13 +16,12 @@ shells = {'bash': Bash,
           'zsh': Zsh,
           'csh': Tcsh,
           'tcsh': Tcsh,
-          'powershell': Powershell}
+          'powershell': Powershell,
+          'pwsh': Powershell}
 
 
 def _get_shell_from_env():
-    path = os.environ.get('SHELL', '')
-    base_name = os.path.basename(path)
-    name = os.path.splitext(base_name)[0]
+    name = os.environ.get('TF_SHELL')
 
     if name in shells:
         return shells[name]()

thefuck/shells/bash.py

@@ -1,9 +1,10 @@
 import os
+from subprocess import Popen, PIPE
 from tempfile import gettempdir
 from uuid import uuid4
 from ..conf import settings
 from ..const import ARGUMENT_PLACEHOLDER, USER_COMMAND_MARK
-from ..utils import memoize
+from ..utils import DEVNULL, memoize
 from .generic import Generic
 
 
@@ -13,6 +14,7 @@ class Bash(Generic):
         return '''
             function {name} () {{
                 TF_PYTHONIOENCODING=$PYTHONIOENCODING;
+                export TF_SHELL=bash;
                 export TF_ALIAS={name};
                 export TF_SHELL_ALIASES=$(alias);
                 export TF_HISTORY=$(fc -ln -10);
@@ -80,3 +82,10 @@ class Bash(Generic):
             content=u'eval $(thefuck --alias)',
             path=config,
             reload=u'source {}'.format(config))
+
+    def info(self):
+        """Returns the name and version of the current shell"""
+        proc = Popen(['bash', '-c', 'echo $BASH_VERSION'],
+                     stdout=PIPE, stderr=DEVNULL)
+        version = proc.stdout.read().decode('utf-8').strip()
+        return u'Bash {}'.format(version)

thefuck/shells/fish.py

@@ -10,12 +10,32 @@ from .generic import Generic
 
 
 @cache('~/.config/fish/config.fish', '~/.config/fish/functions')
-def _get_aliases(overridden):
+def _get_functions(overridden):
     proc = Popen(['fish', '-ic', 'functions'], stdout=PIPE, stderr=DEVNULL)
     functions = proc.stdout.read().decode('utf-8').strip().split('\n')
     return {func: func for func in functions if func not in overridden}
 
 
+@cache('~/.config/fish/config.fish')
+def _get_aliases(overridden):
+    aliases = {}
+    proc = Popen(['fish', '-ic', 'alias'], stdout=PIPE, stderr=DEVNULL)
+    alias_out = proc.stdout.read().decode('utf-8').strip()
+    if not alias_out:
+        return aliases
+    for alias in alias_out.split('\n'):
+        for separator in (' ', '='):
+            split_alias = alias.replace('alias ', '', 1).split(separator, 1)
+            if len(split_alias) == 2:
+                name, value = split_alias
+                break
+        else:
+            continue
+        if name not in overridden:
+            aliases[name] = value
+    return aliases
+
+
 class Fish(Generic):
     def _get_overridden_aliases(self):
         overridden = os.environ.get('THEFUCK_OVERRIDDEN_ALIASES',
@@ -35,7 +55,7 @@ class Fish(Generic):
         # 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'
+                '  env TF_SHELL=fish TF_ALIAS={0} PYTHONIOENCODING=utf-8'
                 ' thefuck $fucked_up_command | read -l unfucked_command\n'
                 '  if [ "$unfucked_command" != "" ]\n'
                 '    eval $unfucked_command\n{1}'
@@ -44,12 +64,17 @@ class Fish(Generic):
 
     def get_aliases(self):
         overridden = self._get_overridden_aliases()
-        return _get_aliases(overridden)
+        functions = _get_functions(overridden)
+        raw_aliases = _get_aliases(overridden)
+        functions.update(raw_aliases)
+        return functions
 
     def _expand_aliases(self, command_script):
         aliases = self.get_aliases()
         binary = command_script.split(' ')[0]
-        if binary in aliases:
+        if binary in aliases and aliases[binary] != binary:
+            return command_script.replace(binary, aliases[binary], 1)
+        elif binary in aliases:
             return u'fish -ic "{}"'.format(command_script.replace('"', r'\"'))
         else:
             return command_script
@@ -78,6 +103,13 @@ class Fish(Generic):
             path='~/.config/fish/config.fish',
             reload='fish')
 
+    def info(self):
+        """Returns the name and version of the current shell"""
+        proc = Popen(['fish', '-c', 'echo $FISH_VERSION'],
+                     stdout=PIPE, stderr=DEVNULL)
+        version = proc.stdout.read().decode('utf-8').strip()
+        return u'Fish Shell {}'.format(version)
+
     def put_to_history(self, command):
         try:
             return self._put_to_history(command)

thefuck/shells/generic.py

@@ -82,7 +82,7 @@ class Generic(object):
         encoded = self.encode_utf8(command)
 
         try:
-            splitted = [s.replace("??", "\ ") for s in shlex.split(encoded.replace('\ ', '??'))]
+            splitted = [s.replace("??", "\\ ") for s in shlex.split(encoded.replace('\\ ', '??'))]
         except ValueError:
             splitted = encoded.split(' ')
 
@@ -131,6 +131,10 @@ class Generic(object):
                 'type', 'typeset', 'ulimit', 'umask', 'unalias', 'unset',
                 'until', 'wait', 'while']
 
+    def info(self):
+        """Returns the name and version of the current shell"""
+        return 'Generic Shell'
+
     def _create_shell_configuration(self, content, path, reload):
         return ShellConfiguration(
             content=content,

thefuck/shells/powershell.py

@@ -12,6 +12,7 @@ class Powershell(Generic):
                '            else { iex "$fuck"; }\n' \
                '        }\n' \
                '    }\n' \
+               '    [Console]::ResetColor() \n' \
                '}\n'
 
     def and_(self, *commands):

thefuck/shells/tcsh.py

@@ -7,7 +7,7 @@ from .generic import Generic
 
 class Tcsh(Generic):
     def app_alias(self, alias_name):
-        return ("alias {0} 'setenv TF_ALIAS {0} && "
+        return ("alias {0} 'setenv TF_SHELL tcsh && setenv TF_ALIAS {0} && "
                 "set fucked_cmd=`history -h 2 | head -n 1` && "
                 "eval `thefuck ${{fucked_cmd}}`'").format(alias_name)
 

thefuck/shells/zsh.py

@@ -1,10 +1,11 @@
 from time import time
 import os
+from subprocess import Popen, PIPE
 from tempfile import gettempdir
 from uuid import uuid4
 from ..conf import settings
 from ..const import ARGUMENT_PLACEHOLDER, USER_COMMAND_MARK
-from ..utils import memoize
+from ..utils import DEVNULL, memoize
 from .generic import Generic
 
 
@@ -13,14 +14,19 @@ class Zsh(Generic):
         # It is VERY important to have the variables declared WITHIN the function
         return '''
             {name} () {{
-                TF_HISTORY=$(fc -ln -10)
+                TF_PYTHONIOENCODING=$PYTHONIOENCODING;
+                export TF_SHELL=zsh;
+                export TF_ALIAS={name};
+                TF_SHELL_ALIASES=$(alias);
+                export TF_SHELL_ALIASES;
+                TF_HISTORY="$(fc -ln -10)";
+                export TF_HISTORY;
+                export PYTHONIOENCODING=utf-8;
                 TF_CMD=$(
-                    TF_ALIAS={name}
-                    TF_SHELL_ALIASES=$(alias)
-                    TF_HISTORY=$TF_HISTORY
-                    PYTHONIOENCODING=utf-8
-                    thefuck {argument_placeholder} $*
+                    thefuck {argument_placeholder} $@
                 ) && eval $TF_CMD;
+                unset TF_HISTORY;
+                export PYTHONIOENCODING=$TF_PYTHONIOENCODING;
                 {alter_history}
             }}
         '''.format(
@@ -46,7 +52,7 @@ class Zsh(Generic):
                 export THEFUCK_INSTANT_MODE=True;
                 export THEFUCK_OUTPUT_LOG={log};
                 thefuck --shell-logger {log};
-                rm {log};
+                rm -f {log};
                 exit
             '''.format(log=log_path)
 
@@ -80,3 +86,10 @@ class Zsh(Generic):
             content=u'eval $(thefuck --alias)',
             path='~/.zshrc',
             reload='source ~/.zshrc')
+
+    def info(self):
+        """Returns the name and version of the current shell"""
+        proc = Popen(['zsh', '-c', 'echo $ZSH_VERSION'],
+                     stdout=PIPE, stderr=DEVNULL)
+        version = proc.stdout.read().decode('utf-8').strip()
+        return u'ZSH {}'.format(version)

thefuck/specific/brew.py

@@ -11,5 +11,5 @@ def get_brew_path_prefix():
     try:
         return subprocess.check_output(['brew', '--prefix'],
                                        universal_newlines=True).strip()
-    except:
+    except Exception:
         return None

thefuck/system/win32.py

@@ -1,5 +1,4 @@
 import os
-import sys
 import msvcrt
 import win_unicode_console
 from .. import const
@@ -12,20 +11,18 @@ def init_output():
 
 
 def get_key():
-    ch = msvcrt.getch()
-    if ch in (b'\x00', b'\xe0'):  # arrow or function key prefix?
-        ch = msvcrt.getch()  # second call returns the actual key code
+    ch = msvcrt.getwch()
+    if ch in ('\x00', '\xe0'):  # arrow or function key prefix?
+        ch = msvcrt.getwch()  # second call returns the actual key code
 
     if ch in const.KEY_MAPPING:
         return const.KEY_MAPPING[ch]
-    if ch == b'H':
+    if ch == 'H':
         return const.KEY_UP
-    if ch == b'P':
+    if ch == 'P':
         return const.KEY_DOWN
 
-    encoding = (sys.stdout.encoding
-                or os.environ.get('PYTHONIOENCODING', 'utf-8'))
-    return ch.decode(encoding)
+    return ch
 
 
 def open_command(arg):

thefuck/utils.py

@@ -3,11 +3,12 @@ import os
 import pickle
 import re
 import shelve
+import sys
 import six
 from decorator import decorator
-from difflib import get_close_matches
+from difflib import get_close_matches as difflib_get_close_matches
 from functools import wraps
-from .logs import warn
+from .logs import warn, exception
 from .conf import settings
 from .system import Path
 
@@ -86,16 +87,23 @@ def default_settings(params):
     return decorator(_default_settings)
 
 
-def get_closest(word, possibilities, n=3, cutoff=0.6, fallback_to_first=True):
+def get_closest(word, possibilities, cutoff=0.6, fallback_to_first=True):
     """Returns closest match or just first from possibilities."""
     possibilities = list(possibilities)
     try:
-        return get_close_matches(word, possibilities, n, cutoff)[0]
+        return difflib_get_close_matches(word, possibilities, 1, cutoff)[0]
     except IndexError:
         if fallback_to_first:
             return possibilities[0]
 
 
+def get_close_matches(word, possibilities, n=None, cutoff=0.6):
+    """Overrides `difflib.get_close_match` to controle argument `n`."""
+    if n is None:
+        n = settings.num_close_matches
+    return difflib_get_close_matches(word, possibilities, n, cutoff)
+
+
 @memoize
 def get_all_executables():
     from thefuck.shells import shell
@@ -190,6 +198,13 @@ class Cache(object):
         self._db = None
 
     def _init_db(self):
+        try:
+            self._setup_db()
+        except Exception:
+            exception("Unable to init cache", sys.exc_info())
+            self._db = {}
+
+    def _setup_db(self):
         cache_dir = self._get_cache_dir()
         cache_path = Path(cache_dir).joinpath('thefuck').as_posix()
 

tox.ini

@@ -1,10 +1,10 @@
 [tox]
-envlist = py27,py33,py34,py35,py36
+envlist = py27,py34,py35,py36,py37
 
 [testenv]
 deps = -rrequirements.txt
 commands = py.test -v --capture=sys
 
 [flake8]
-ignore = E501,W503
+ignore = E501,W503,W504
 exclude = venv,build,.tox,setup.py,fastentrypoints.py