v20151006

use container-based infrastructure on travis-ci.org
change to SVG build status
2025-11-08 11:33:55 -05:00 · 2015-10-06 14:06:58 +00:00 · 2015-10-06 14:04:10 +00:00 · 2015-10-06 14:02:49 +00:00 · 2015-10-06 13:53:43 +00:00 · 2015-09-24 21:56:18 +09:00
32 changed files with 3064 additions and 165 deletions
--- a/.travis.yml
+++ b/.travis.yml
@@ -0,0 +1,7 @@
+sudo: false
+install: git clone https://github.com/sstephenson/bats.git
+script: bats/bin/bats --tap test
+language: c
+notifications:
+  email:
+    on_success: never
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -0,0 +1,131 @@
+## Version History
+
+#### 20151006
+
+* Ignore user's site-packages on ensurepip/get-pip (#89)
+* Find `python-config` from source version if current version is a virtualenv
+* Fix pyenv-virtualenv-init script for fish where command was in string and not being evaluated (#98)
+* Add foolproof for `-p` argument. (yyuu/pyenv#98)
+
+#### 20150719
+
+* Add support for `conda` environments created by Anaconda/Miniconda (#91)
+* Look up commands for original version as well if the environment is created with `--system-site-packages` (#62)
+* Add error message if the source version is not installed (#83)
+
+#### 20150526
+
+* Use `typeset -g` with `precmd_functions` (#75)
+* activate: display setup instructions only with `PYENV_VIRTUALENV_INIT=0` (#78)
+* Ignore failure of pyenv activate (#68)
+
+#### 20150119
+
+ * Ignore errors from `pyenv-version-name` since it might fail if there is configuration error (yyuu/pyenv#291)
+ * The _shell_ version set in `activate` should be unset in `deactivate` (#61)
+ * Anaconda has `activate` script nevertheless it is not a virtual environment (#65)
+
+#### 20141106
+
+ * Stop creating after `ensurepip` since it has done by `ensurepip` itself
+ * Suppress some useless warnings from `pyenv virtualenv-init`
+
+#### 20141012
+
+ * Fix warnings from `shellcheck` to improve support for POSIX sh (#40)
+ * Do not allow whitespace in `VIRTUALENV_NAME` (#44)
+ * Should not persist `PYENV_DEACTIVATE` after automatic deactivation (#47, #48)
+
+#### 20140705
+
+ * Display information on auto-(de)?activation
+ * Support manual (de)?activation with auto-activation enabled (#32, #34)
+ * Exit as error when (de)?activation failed
+ * Use https://bootstrap.pypa.io/ to install setuptools and pip
+ * Create backup of original virtualenv within `$(pyenv root)/versions` when `--upgrade`
+
+#### 20140615
+
+ * Fix incompatibility issue of `pyenv activate` and `pyenv deactivate` (#26)
+ * Workaround for the issue with pyenv-which-ext (#26)
+
+#### 20140614
+
+ * Add `pyenv virtualenv-init` to enable auto-activation feature (#24)
+ * Create symlinks for executables with version suffix (yyuu/pyenv#182)
+
+#### 20140602
+
+ * Use new style GH raw url to avoid redirects (raw.github.com -> raw.githubusercontent.com)
+ * Repaired virtualenv activation and deactivation for the fish shell (#23)
+
+#### 20140421
+
+ * Display error if `pyenv activate` was invoked as a command
+ * Fix completion of `pyenv activate` (#15)
+ * Use `virtualenv` instead of `pyvenv` if `-p` has given (yyuu/pyenv#158)
+
+#### 20140123
+
+ * Add `activate` and `deactivate` to make `pyenv-virtualenv` work with [jedi](https://github.com/davidhalter/jedi) (#9)
+ * Use `ensurepip` to install `pip` if it is available
+ * Unset `PIP_REQUIRE_VENV` to avoid problem on the installation of `virtualenv` (#10)
+ * Add tests
+
+#### 20140110.1
+
+ * Fix install script
+
+#### 20140110
+
+ * Support environment variables of `EZ_SETUP` and `GET_PIP`.
+ * Support a short option `-p` of `virtualenv`.
+
+#### 20131216
+
+ * Use latest release of setuptools and pip if the version not given via environment variables.
+
+#### 20130622
+
+ * Removed bundled `virtualenv.py` script. Now pyenv-virtualenv installs `virtualenv` package into source version and then use it.
+ * On Python 3.3+, use `pyvenv` as virtualenv command if `virtualenv` is not available.
+ * Install setuptools and pip into environments created by `pyvenv`.
+
+#### 20130614
+
+ * Add `pyenv virtualenvs` to list all virtualenv versions.
+ * *EXPERIMENTAL*: Add `--upgrade` option to re-create virtualenv with migrating packages
+
+#### 20130527
+
+ * Remove `python-virtualenv` which was no longer used.
+ * Change the installation path of the `virtualenv.py` script. (`./libexec` -> `./libexec/pyenv-virtualenv/${VIRTUALENV_VERSION}`)
+ * Download `virtualenv.py` if desired version has not been installed.
+
+#### 20130507
+
+ * Display virtualenv information in `--help` and `--version`
+ * Update virtualenv version; 1.8.4 -> 1.9.1
+
+#### 20130307
+
+ * Rename the project; `s/python-virtualenv/pyenv-virtualenv/g`
+ * The `pyenv-virtualenv` script is not depending on `python-virtualenv` now.
+   `python-virtualenv` will left for compatibility and will not continue for future releases.
+ * Update virtualenv version; 1.8.2 -> 1.8.4
+
+#### 20130218
+
+ * Add pyenv 0.2.x (rbenv 0.4.x) style help messages.
+
+#### 20121023
+
+ * Create virtualenv with exact name of python executables.
+ * Changed command-line options of python-virtualenv.
+   First argument should be a path to the python executable.
+ * Add install script.
+
+#### 20120927
+
+ * Initial public release.
+
--- a/README.md
+++ b/README.md
@@ -1,122 +1,216 @@
-# pyenv-virtualenv (a.k.a. [python-virtualenv](https://github.com/yyuu/python-virtualenv))
+# pyenv-virtualenv
+
+[![Build Status](https://travis-ci.org/yyuu/pyenv-virtualenv.svg)](https://travis-ci.org/yyuu/pyenv-virtualenv)

 pyenv-virtualenv is a [pyenv](https://github.com/yyuu/pyenv) plugin
-that provides a `pyenv virtualenv` command to create virtualenv for Python
-on UNIX-like systems.
+that provides features to manage virtualenvs and conda environments
+for Python on UNIX-like systems.

 (NOTICE: If you are an existing user of [virtualenvwrapper](http://pypi.python.org/pypi/virtualenvwrapper)
 and you love it, [pyenv-virtualenvwrapper](https://github.com/yyuu/pyenv-virtualenvwrapper) may help you
-to manage your virtualenvs.)
+(additionally) to manage your virtualenvs.)

 ## Installation

 ### Installing as a pyenv plugin

-Installing pyenv-virtualenv as a pyenv plugin will give you access to the
-`pyenv virtualenv` command.
-
-    $ git clone git://github.com/yyuu/pyenv-virtualenv.git ~/.pyenv/plugins/pyenv-virtualenv
-
 This will install the latest development version of pyenv-virtualenv into
-the `~/.pyenv/plugins/pyenv-virtualenv` directory. From that directory, you
-can check out a specific release tag. To update pyenv-virtualenv, run `git
-pull` to download the latest changes.
+the `~/.pyenv/plugins/pyenv-virtualenv` directory.
+
+**Important note:**  If you installed pyenv into a non-standard directory, make
+sure that you clone this repo into the 'plugins' directory of wherever you
+installed into.
+
+From inside that directory you can:
+ - Check out a specific release tag.
+ - Get the latest development release by running `git pull` to download the
+   latest changes.
+
+1. **Check out pyenv-virtualenv into plugin directory**
+
+    ```
+    $ git clone https://github.com/yyuu/pyenv-virtualenv.git ~/.pyenv/plugins/pyenv-virtualenv
+    ```
+
+2. (OPTIONAL) **Add `pyenv virtualenv-init` to your shell** to enable auto-activation of virtualenv. This is entirely optional but pretty useful.
+
+    ```
+    $ echo 'eval "$(pyenv virtualenv-init -)"' >> ~/.bash_profile
+    ```
+
+    **Zsh note**: Modify your `~/.zshenv` file instead of `~/.bash_profile`.
+    **Pyenv note**: You may also need to add `eval "$(pyenv init -)"` to your profile if you haven't done so already.
+
+3. **Restart your shell to enable pyenv-virtualenv**
+
+    ```
+    $ exec "$SHELL"
+    ```
+
+
+### Installing with Homebrew (for OS X users)
+
+Mac OS X users can install pyenv-virtualenv with the
+[Homebrew](http://brew.sh) package manager.
+This will give you access to the `pyenv-virtualenv` command. If you have pyenv
+installed, you will also be able to use the `pyenv virtualenv` command.
+
+*This is the recommended method of installation if you installed pyenv
+ with Homebrew.*
+
+```
+$ brew install pyenv-virtualenv
+```
+
+Or, if you would like to install the latest development release:
+
+```
+$ brew install --HEAD pyenv-virtualenv
+```
+
+After installation, you'll still need to add 
+```
+eval "$(pyenv init -)"
+eval "$(pyenv virtualenv-init -)"
+```
+to your profile (as stated in the caveats). You'll only ever have to do this once.
+

 ## Usage

 ### Using `pyenv virtualenv` with pyenv

-To create a virtualenv for the Python version use with pyenv, run
-`pyenv virtualenv` with tha exact name of the version you want to create
-virtualenv. For example,
+To create a virtualenv for the Python version used with pyenv, run
+`pyenv virtualenv`, specifying the Python version you want and the name
+of the virtualenv directory. For example,

-    $ pyenv virtualenv 2.7.5 venv27
+```
+$ pyenv virtualenv 2.7.10 my-virtual-env-2.7.10
+```

-virtualenvs will be created into a directory of the same name
-under `~/.pyenv/versions`.
+will create a virtualenv based on Python 2.7.10 under `~/.pyenv/versions` in a
+folder called `my-virtual-env-2.7.10`.


 ### Create virtualenv from current version

-If there is only one argument is given to `pyenv virtualenv`,
-virtualenv will be created with given name based on current
-version.
+If there is only one argument given to `pyenv virtualenv`, the virtualenv will
+be created with the given name based on the current pyenv Python version.

-    $ pyenv version
-    3.3.2 (set by /home/yyuu/.pyenv/version)
-    $ pyenv virtualenv venv33
+```
+$ pyenv version
+3.4.3 (set by /home/yyuu/.pyenv/version)
+$ pyenv virtualenv venv34
+```


 ### List existing virtualenvs

-`pyenv virtualenvs` shows you the list of existing virtualenvs.
+`pyenv virtualenvs` shows you the list of existing virtualenvs and `conda` environments.

-    $ pyenv shell venv27
-    $ pyenv virtualenvs
-    * venv27 (created from /home/yyuu/.pyenv/versions/2.7.5)
-      venv33 (created from /home/yyuu/.pyenv/versions/3.3.2)
+```
+$ pyenv shell venv27
+$ pyenv virtualenvs
+  miniconda3-3.9.1 (created from /home/yyuu/.pyenv/versions/miniconda3-3.9.1)
+  miniconda3-3.9.1/envs/myenv (created from /home/yyuu/.pyenv/versions/miniconda3-3.9.1)
+* venv27 (created from /home/yyuu/.pyenv/versions/2.7.10)
+  venv34 (created from /home/yyuu/.pyenv/versions/3.4.3)
+```
+
+
+### Activate virtualenv
+
+Some external tools (e.g. [jedi](https://github.com/davidhalter/jedi)) might
+require you to `activate` the virtualenv and `conda` environments.
+
+`pyenv-virtualenv` will automatically activate/deactivate the virtualenv if
+the `eval "$(pyenv virtualenv-init -)"` is properly configured in your shell.
+
+You can also activate and deactivate a pyenv virtualenv manually:
+
+```sh
+pyenv activate <name>
+pyenv deactivate
+```
+
+
+### Delete existing virtualenv
+
+Removing the directory in `~/.pyenv/versions` will delete the virtualenv, or you can run:
+
+```sh
+pyenv uninstall my-virtual-env
+```
+
+
+### virtualenv and pyvenv
+
+There is a [venv](http://docs.python.org/3/library/venv.html) module available
+for CPython 3.3 and newer.
+It provides a command-line tool `pyvenv` which is the successor of `virtualenv`
+and distributed by default.
+
+`pyenv-virtualenv` uses `pyvenv` if it is available and the `virtualenv`
+command is not available.
+
+
+### Anaconda and Miniconda
+
+Because Anaconda and Miniconda may install standard commands (e.g. `curl`, `openssl`, `sqlite3`, etc.) into their prefix,
+we'd recommend you to install [pyenv-which-ext](https://github.com/yyuu/pyenv-which-ext).
+
+You can manage `conda` environments by `conda env` as same manner as standard Anaconda/Miniconda installations.
+To use those environments, you can use `pyenv activate` and `pyenv deactivate`.
+
+```
+(root)$ pyenv version
+miniconda3-3.9.1 (set by /home/yyuu/.pyenv/version)
+(root)$ conda env list
+# conda environments:
+#
+myenv                    /home/yyuu/.pyenv/versions/miniconda3-3.9.1/envs/myenv
+root                  *  /home/yyuu/.pyenv/versions/miniconda3-3.9.1
+(root)$ pyenv activate myenv
+discarding /home/yyuu/.pyenv/versions/miniconda3-3.9.1/bin from PATH
+prepending /home/yyuu/.pyenv/versions/miniconda3-3.9.1/envs/myenv/bin to PATH
+(myenv)$ python --version
+Python 3.4.3 :: Continuum Analytics, Inc.
+(myenv)$ pyenv deactivate
+discarding /home/yyuu/.pyenv/versions/miniconda3-3.9.1/envs/myenv/bin from PATH
+```
+
+You can use version like `miniconda3-3.9.1/envs/myenv` to specify `conda` environment as a version in pyenv.
+
+```
+(root)$ pyenv version
+miniconda3-3.9.1 (set by /home/yyuu/.pyenv/version)
+(root)$ pyenv shell miniconda3-3.9.1/envs/myenv
+(myenv)$ which python
+/home/yyuu/.pyenv/versions/miniconda3-3.9.1/envs/myenv/bin/python
+```


 ### Special environment variables

-You can set certain environment variables to control the pyenv-virtualenv.
+You can set certain environment variables to control pyenv-virtualenv.

 * `PYENV_VIRTUALENV_CACHE_PATH`, if set, specifies a directory to use for
  caching downloaded package files.
-* `VIRTUALENV_VERSION`, if set, forces pyenv-virtualenv to install desired
-  version of virtualenv. If the virtualenv has not been installed,
+* `VIRTUALENV_VERSION`, if set, forces pyenv-virtualenv to install the desired
+  version of virtualenv. If `virtualenv` has not been installed,
  pyenv-virtualenv will try to install the given version of virtualenv.
-* `EZ_SETUP_URL` and `GET_PIP_URL`, if set and pyvenv is preferred
-  than virtualenv, download `ez_setup.py` and `get_pip.py` from specified URL.
-* `SETUPTOOLS_VERSION` and `PIP_VERSION`, if set and pyvenv is preferred
-  than virtualenv, install specified version of setuptools and pip.
+* `GET_PIP`, if set and `pyvenv` is preferred over `virtualenv`,
+  use `get_pip.py` from the specified location.
+* `GET_PIP_URL`, if set and `pyvenv` is preferred over
+  `virtualenv`, download `get_pip.py` from the specified URL.
+* `PIP_VERSION`, if set and `pyvenv` is preferred
+  over `virtualenv`, install the specified version of pip.


 ## Version History

-#### 20130622
+See [CHANGELOG.md](CHANGELOG.md).

- * Removed bundled `virtualenv.py` script. Now pyenv-virtualenv installs `virtualenv` package into source version and then use it.
- * On Python 3.3+, use `pyvenv` as virtualenv command if `virtualenv` is not available.
- * Install setuptools and pip into environments created by `pyvenv`.
-
-#### 20130614
-
- * Add `pyenv virtualenvs` to list all virtualenv versions.
- * *EXPERIMENTAL*: Add `--upgrade` option to re-create virtualenv with migrating packages
-
-#### 20130527
-
- * Remove `python-virtualenv` which was no longer used.
- * Change the installation path of the `virtualenv.py` script. (`./libexec` -> `./libexec/pyenv-virtualenv/${VIRTUALENV_VERSION}`)
- * Download `virtualenv.py` if desired version has not been installed.
-
-#### 20130507
-
- * Display virtualenv information in `--help` and `--version`
- * Update virtualenv version; 1.8.4 -> 1.9.1
-
-#### 20130307
-
- * Rename the project; `s/python-virtualenv/pyenv-virtualenv/g`
- * The `pyenv-virtualenv` script is not depending on `python-virtualenv` now.
-   `python-virtualenv` will left for compatibility and will not continue for future releases.
- * Update virtualenv version; 1.8.2 -> 1.8.4
-
-#### 20130218
-
- * Add pyenv 0.2.x (rbenv 0.4.x) style help messages.
-
-#### 20121023
-
- * Create virtualenv with exact name of python executables.
- * Changed command-line options of python-virtualenv.
-   First argument should be a path to the python executable.
- * Add install script.
-
-#### 20120927
-
- * Initial public release.

 ### License

--- a/bin/pyenv-activate
+++ b/bin/pyenv-activate
@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+#
+# Summary: Activate virtual environment
+#
+# Usage: pyenv activate <virtualenv>
+#        pyenv activate --unset
+#
+# Activate a Python virtualenv environment in current shell.
+# This acts almost as same as `pyenv shell`, but this invokes the `activate`
+# script in your shell.
+#
+# <virtualenv> should be a string matching a Python version known to pyenv.
+
+set -e
+[ -n "$PYENV_DEBUG" ] && set -x
+
+# Provide pyenv completions
+if [ "$1" = "--complete" ]; then
+  echo --unset
+  exec pyenv-virtualenvs --bare
+fi
+
+{ printf "\x1B[31;1m"
+  echo
+  echo "Failed to activate virtualenv."
+  echo
+  echo "Perhaps pyenv-virtualenv has not been loaded into your shell properly."
+  echo "Please restart current shell and try again."
+  echo
+  printf "\x1B[0m"
+} 1>&2
+exit 1
--- a/bin/pyenv-deactivate
+++ b/bin/pyenv-deactivate
@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+#
+# Summary: Deactivate virtual environment
+#
+# Usage: pyenv deactivate
+#
+# Deactivate a Python virtual environment.
+
+set -e
+[ -n "$PYENV_DEBUG" ] && set -x
+
+{ printf "\x1B[31;1m"
+  echo
+  echo "Failed to deactivate virtualenv."
+  echo
+  echo "Perhaps pyenv-virtualenv has not been loaded into your shell properly."
+  echo "Please restart current shell and try again."
+  echo
+  printf "\x1B[0m"
+} 1>&2
+exit 1
--- a/bin/pyenv-sh-activate
+++ b/bin/pyenv-sh-activate
@@ -0,0 +1,152 @@
+#!/usr/bin/env bash
+#
+# Summary: Activate virtual environment
+#
+# Usage: pyenv activate <virtualenv>
+#        pyenv activate --unset
+#
+# Activate a Python virtualenv environment in current shell.
+# This acts almost as same as `pyenv shell`, but this invokes the `activate`
+# script in your shell.
+#
+# <virtualenv> should be a string matching a Python version known to pyenv.
+
+set -e
+[ -n "$PYENV_DEBUG" ] && set -x
+
+unset NOERROR
+unset VERBOSE
+
+while [ $# -gt 0 ]; do
+  case "$1" in
+  "--complete" )
+    # Provide pyenv completions
+    echo --unset
+    exec pyenv-virtualenvs --bare
+    ;;
+  "--no-error" )
+    NOERROR=1
+    ;;
+  "--unset" )
+    echo "pyenv deactivate"
+    exit
+    ;;
+  "--verbose" )
+    VERBOSE=1
+    ;;
+  * )
+    break
+    ;;
+  esac
+  shift 1
+done
+
+no_shell=
+versions=("$@")
+if [ -z "${versions}" ]; then
+  no_shell=1
+  OLDIFS="$IFS"
+  IFS=: versions=($(pyenv-version-name))
+  IFS="$OLDIFS"
+fi
+
+if [ -z "${PYENV_VIRTUALENV_INIT}" ]; then
+  # Backward compatibility issue
+  # https://github.com/yyuu/pyenv-virtualenv/issues/26
+  no_shell=
+fi
+
+if [ "${#versions[@]}" -gt 1 ]; then
+  [ -n "$NOERROR" ] || echo "pyenv-virtualenv: cannot activate multiple versions at once: ${versions[@]}" 1>&2
+  echo "false"
+  exit 1
+fi
+
+if pyenv-prefix "${versions}" 1>/dev/null 2>&1; then
+  if ! pyenv-virtualenv-prefix "${versions}" 1>/dev/null 2>&1; then
+    [ -n "$NOERROR" ] || echo "pyenv-virtualenv: version \`${versions}' is not a virtualenv" 1>&2
+    echo "false"
+    exit 1
+  fi
+else
+  version="$(pyenv-version-name)"
+  if [[ "${versions}" == "root" ]]; then
+    versions="${version%/envs/*}"
+  else
+    versions="${version%/envs/*}/envs/${versions}"
+  fi
+  if ! pyenv-virtualenv-prefix "${versions}" 1>/dev/null 2>&1; then
+    [ -n "$NOERROR" ] || echo "pyenv-virtualenv: version \`${versions}' is not an environment of anaconda/miniconda" 1>&2
+    echo "false"
+    exit 1
+  fi
+fi
+
+shell="${PYENV_SHELL:-${SHELL##*/}}"
+prefix="$(pyenv-prefix "${versions}")"
+
+unset conda_env
+
+if [ -f "${prefix}/bin/conda" ]; then
+  if [[ "$shell" != "bash" ]] && [[ "$shell" != "zsh" ]]; then
+    [ -n "$NOERROR" ] || echo "pyenv-virtualenv: Only bash and zsh are supported by Anaconda/Miniconda" 1>&2
+    echo "false"
+    exit 1
+  fi
+  if [[ "${prefix}" != "${prefix%/envs/*}" ]]; then
+    conda_env="${prefix##*/envs/}"
+  else
+    conda_env="root"
+  fi
+fi
+
+# Display setup instruction, if pyenv-virtualenv has not been initialized.
+# if 'pyenv virtualenv-init -' is not found in "$profile"
+if [ -z "$PYENV_VIRTUALENV_INIT" ]; then
+  pyenv-virtualenv-init >&2 || true
+fi
+
+if [ -n "$VERBOSE" ]; then
+  echo "pyenv-virtualenv: activate ${versions}" 1>&2
+fi
+
+if [ -z "$no_shell" ]; then
+  echo "pyenv shell \"${versions}\";"
+  # shell version set in pyenv-sh-activate should be unset
+  # https://github.com/yyuu/pyenv-virtualenv/issues/61
+  case "$shell" in
+  fish )
+    echo "setenv PYENV_ACTIVATE_SHELL 1;"
+    ;;
+  * )
+    echo "export PYENV_ACTIVATE_SHELL=1;"
+    ;;
+  esac
+fi
+
+if [ -n "${conda_env}" ]; then
+  # anaconda/miniconda
+  cat <<EOS
+unset PYENV_DEACTIVATE;
+export PYENV_ACTIVATE="${prefix}";
+. "${prefix%/envs/*}/bin/activate" "${conda_env}";
+EOS
+else
+  # virtualenv/pyvenv
+  case "$shell" in
+  fish )
+    cat <<EOS
+set -e PYENV_DEACTIVATE;
+setenv PYENV_ACTIVATE "${prefix}";
+. "${prefix}/bin/activate.fish";
+EOS
+   ;;
+  *    )
+    cat <<EOS
+unset PYENV_DEACTIVATE;
+export PYENV_ACTIVATE="${prefix}";
+. "${prefix}/bin/activate";
+EOS
+    ;;
+  esac
+fi
--- a/bin/pyenv-sh-deactivate
+++ b/bin/pyenv-sh-deactivate
@@ -0,0 +1,120 @@
+#!/usr/bin/env bash
+#
+# Summary: Deactivate virtual environment
+#
+# Usage: pyenv deactivate
+#
+# Deactivate a Python virtual environment.
+
+set -e
+[ -n "$PYENV_DEBUG" ] && set -x
+
+unset NOERROR
+unset VERBOSE
+
+while [ $# -gt 0 ]; do
+  case "$1" in
+  "--no-error" )
+    NOERROR=1
+    ;;
+  "--verbose" )
+    VERBOSE=1
+    ;;
+  * )
+    break
+    ;;
+  esac
+  shift 1
+done
+
+shell="$(basename "${PYENV_SHELL:-$SHELL}")"
+prefix="${PYENV_ACTIVATE:-${VIRTUAL_ENV}}"
+
+unset conda_env
+
+if [ -f "${prefix}/bin/conda" ]; then
+  if [[ "$shell" != "bash" ]] && [[ "$shell" != "zsh" ]]; then
+    [ -n "$NOERROR" ] || echo "pyenv-virtualenv: Only bash and zsh are supported by Anaconda/Miniconda" 1>&2
+    echo "false"
+    exit 1
+  fi
+  if [[ "${prefix}" != "${prefix%/envs/*}" ]]; then
+    conda_env="${prefix##*/envs/}"
+  else
+    conda_env="root"
+  fi
+fi
+
+if [ -n "${conda_env}" ]; then
+  echo "if [ -f \"${prefix%/envs/*}/bin/deactivate\" ]; then"
+else
+  case "$shell" in
+  fish )
+    echo "if functions -q deactivate;"
+    ;;
+  *    )
+    echo "if declare -f deactivate 1>/dev/null 2>&1; then"
+    ;;
+  esac
+fi
+
+if [ -n "$VERBOSE" ]; then
+  echo "  echo \"pyenv-virtualenv: deactivate ${prefix##*/}\" 1>&2;"
+fi
+
+if [ -n "${PYENV_ACTIVATE_SHELL}" ]; then
+  # shell version set in pyenv-sh-activate should be unset
+  # https://github.com/yyuu/pyenv-virtualenv/issues/61
+  echo "  pyenv shell --unset;"
+  case "$shell" in
+  fish )
+    echo "  set -e PYENV_ACTIVATE_SHELL;"
+    ;;
+  * )
+    echo "  unset PYENV_ACTIVATE_SHELL;"
+    ;;
+  esac
+fi
+
+if [ -n "${conda_env}" ]; then
+  cat <<EOS
+  export PYENV_DEACTIVATE="$prefix";
+  unset PYENV_ACTIVATE;
+  . "${prefix%/envs/*}/bin/deactivate";
+else
+EOS
+else
+  case "$shell" in
+  fish )
+    cat <<EOS
+  setenv PYENV_DEACTIVATE "$prefix";
+  set -e PYENV_ACTIVATE;
+  deactivate;
+else;
+EOS
+    ;;
+  *    )
+    cat <<EOS
+  export PYENV_DEACTIVATE="$prefix";
+  unset PYENV_ACTIVATE;
+  deactivate;
+else
+EOS
+    ;;
+  esac
+fi
+
+if [ -z "$NOERROR" ]; then
+  echo "  echo \"pyenv-virtualenv: no virtualenv has been activated.\" 1>&2;"
+fi
+
+echo "  false;"
+
+case "$shell" in
+fish )
+  echo "end;"
+  ;;
+*    )
+  echo "fi;"
+  ;;
+esac
--- a/bin/pyenv-virtualenv
+++ b/bin/pyenv-virtualenv
@@ -2,16 +2,14 @@
 #
 # Summary: Create a Python virtualenv using the pyenv-virtualenv plugin
 #
-# Usage: pyenv virtualenv [-f|--force] [-u|--upgrade] [VIRTUALENV_OPTIONS] <version> <virtualenv-name>
+# Usage: pyenv virtualenv [-f|--force] [VIRTUALENV_OPTIONS] [version] <virtualenv-name>
 #        pyenv virtualenv --version
 #        pyenv virtualenv --help
 #
-#   -u/--upgrade     Upgrade existing virtualenv to use new version of Python,
-#                    assuming Python has been upgraded in-place.
 #   -f/--force       Install even if the version appears to be installed already
 #

-PYENV_VIRTUALENV_VERSION="20130622"
+PYENV_VIRTUALENV_VERSION="20151006"

 set -e
 [ -n "$PYENV_DEBUG" ] && set -x
@@ -25,6 +23,9 @@ if [ -z "$PYENV_ROOT" ]; then
  PYENV_ROOT="${HOME}/.pyenv"
 fi

+unset PIP_REQUIRE_VENV
+unset PIP_REQUIRE_VIRTUALENV
+
 # Define library functions
 parse_options() {
  OPTIONS=()
@@ -100,8 +101,17 @@ http_get_wget() {
 }

 version() {
-  local version="$(venv --version 2>/dev/null || true)"
-  echo "pyenv-virtualenv ${PYENV_VIRTUALENV_VERSION} (virtualenv ${version:-unknown})"
+  detect_venv
+  local version
+  if [ -n "$USE_PYVENV" ]; then
+    version="$(pyenv-which pyvenv 2>/dev/null || true)"
+    version="${version#$(pyenv-root)/versions/}"
+    version="${version%/bin/pyvenv}"
+    echo "pyenv-virtualenv ${PYENV_VIRTUALENV_VERSION} (pyvenv ${version:-unknown})"
+  else
+    version="$(venv --version 2>/dev/null || true)"
+    echo "pyenv-virtualenv ${PYENV_VIRTUALENV_VERSION} (virtualenv ${version:-unknown})"
+  fi
 }

 usage() {
@@ -111,20 +121,90 @@ usage() {
  [ -z "$1" ] || exit "$1"
 }

-virtualenv_is_pyvenv() {
-  # Use pyvenv only if virtualenv is not installed and there is pyvenv
-  if pyenv-which "virtualenv" 1>/dev/null 2>&1; then
-    return 1
-  else
-    pyenv-which "pyvenv" 1>/dev/null 2>&1
+detect_venv() {
+  # Check the existence of executables as a workaround for the issue with pyenv-which-ext
+  # https://github.com/yyuu/pyenv-virtualenv/issues/26
+  if [ -x "$(pyenv-prefix)/bin/virtualenv" ]; then
+    HAS_VIRTUALENV=1
+  fi
+  if [ -x "$(pyenv-prefix)/bin/pyvenv" ]; then
+    HAS_PYVENV=1
+  fi
+  # Use pyvenv only if there is pyvenv, virtualenv is not installed, and `-p` not given
+  if [ -n "${HAS_PYVENV}" ] && [ -z "${HAS_VIRTUALENV}" ] && [ -z "${VIRTUALENV_PYTHON}" ]; then
+    USE_PYVENV=1
  fi
 }

 venv() {
-  if virtualenv_is_pyvenv; then
-    pyenv-exec pyvenv "$@"
+  local args=("$@")
+  if [ -n "${USE_PYVENV}" ]; then
+    pyenv-exec pyvenv "${args[@]}"
  else
-    pyenv-exec virtualenv "$@"
+    pyenv-exec virtualenv "${args[@]}"
+  fi
+}
+
+build_package_ez_setup() {
+  local ez_setup="${PYENV_VIRTUALENV_CACHE_PATH}/ez_setup.py"
+  rm -f "${ez_setup}"
+  { if [ "${EZ_SETUP+defined}" ] && [ -f "${EZ_SETUP}" ]; then
+      echo "Installing setuptools from ${EZ_SETUP}..." 1>&2
+      cat "${EZ_SETUP}"
+    else
+      [ -n "${EZ_SETUP_URL}" ] || EZ_SETUP_URL="https://bootstrap.pypa.io/ez_setup.py"
+      echo "Installing setuptools from ${EZ_SETUP_URL}..." 1>&2
+      http get "${EZ_SETUP_URL}"
+    fi
+  } 1> "${ez_setup}"
+  pyenv-exec python -s "${ez_setup}" ${EZ_SETUP_OPTS} 1>&2 || {
+    echo "error: failed to install setuptools via ez_setup.py" >&2
+    return 1
+  }
+}
+
+build_package_get_pip() {
+  local get_pip="${PYENV_VIRTUALENV_CACHE_PATH}/get-pip.py"
+  rm -f "${get_pip}"
+  { if [ "${GET_PIP+defined}" ] && [ -f "${GET_PIP}" ]; then
+      echo "Installing pip from ${GET_PIP}..." 1>&2
+      cat "${GET_PIP}"
+    else
+      [ -n "${GET_PIP_URL}" ] || GET_PIP_URL="https://bootstrap.pypa.io/get-pip.py"
+      echo "Installing pip from ${GET_PIP_URL}..." 1>&2
+      http get "${GET_PIP_URL}"
+    fi
+  } 1> "${get_pip}"
+  pyenv-exec python -s "${get_pip}" ${GET_PIP_OPTS} 1>&2 || {
+    echo "error: failed to install pip via get-pip.py" >&2
+    return 1
+  }
+}
+
+build_package_ensurepip() {
+  pyenv-exec python -s -m ensurepip 2>/dev/null || build_package_get_pip "$@" || return 1
+}
+
+prepare_requirements() {
+  pyenv-exec pip freeze > "${REQUIREMENTS}"
+  mv -f "${VIRTUALENV_PATH}" "${VIRTUALENV_ORIG}"
+}
+
+install_requirements() {
+  if [ -f "${REQUIREMENTS}" ]; then
+    ## Migrate previously installed packages from requirements.txt
+    pyenv-exec pip install $QUIET $VERBOSE --requirement "${REQUIREMENTS}" || {
+      echo
+      echo "PIP INSTALL FAILED"
+      echo
+      echo "Inspect or clean up the original tree at ${VIRTUALENV_ORIG}"
+      echo
+      echo "Package list:"
+      cat "${REQUIREMENTS}" | sed 's/^/ * /'
+      return 1
+    } 1>&2
+    rm -f "${REQUIREMENTS}"
+    rm -fr "${VIRTUALENV_ORIG}"
  fi
 }

@@ -135,6 +215,7 @@ fi
 VIRTUALENV_OPTIONS=()

 unset FORCE
+unset VIRTUALENV_PYTHON
 unset QUIET
 unset UPGRADE
 unset VERBOSE
@@ -148,6 +229,10 @@ for option in "${OPTIONS[@]}"; do
  "h" | "help" )
    usage 0
    ;;
+  "p" | "python" )
+    VIRTUALENV_PYTHON="${ARGUMENTS[0]}"
+    ARGUMENTS=("${ARGUMENTS[@]:1}") # shift 1
+    ;;
  "q" | "quiet" )
    QUIET="--quiet"
    ;;
@@ -162,13 +247,17 @@ for option in "${OPTIONS[@]}"; do
    exit 0
    ;;
  * ) # virtualenv long options
-    VIRTUALENV_OPTIONS[${#VIRTUALENV_OPTIONS[*]}]="--$option"
+    if [[ "$option" == "python="* ]]; then
+      VIRTUALENV_PYTHON="${option#python=}"
+    else
+      VIRTUALENV_OPTIONS[${#VIRTUALENV_OPTIONS[*]}]="--$option"
+    fi
    ;;
  esac
 done

 if [[ "${#ARGUMENTS[@]}" == 0 ]]; then
-  echo "pyenv: no virtualenv name given." 1>&2
+  echo "pyenv-virtualenv: no virtualenv name given." 1>&2
  exit 1
 elif [[ "${#ARGUMENTS[@]}" == 1 ]]; then
  # If only one argument given, use current version as source version
@@ -184,11 +273,19 @@ if [ -z "${VERSION_NAME}" ] || [ -z "${VIRTUALENV_NAME}" ]; then
  usage 1
 fi

+if [ "$VIRTUALENV_NAME" != "${VIRTUALENV_NAME%[[:space:]]*}" ]; then
+  echo "pyenv-virtualenv: no whitespace allowed in virtualenv name." 1>&2
+  exit 1
+fi
+
 # Set VERSION_NAME as default version in this script
 export PYENV_VERSION="${VERSION_NAME}"

-# Source version must exists before creating virtualenv
-pyenv-prefix 1>/dev/null 2>&1 || usage 1
+# Source version must exist before creating virtualenv.
+if ! pyenv-prefix 1>/dev/null 2>&1; then
+  echo "pyenv-virtualenv: \`${PYENV_VERSION}' is not installed in pyenv." 1>&2
+  exit 1
+fi

 if [ -z "$TMPDIR" ]; then
  TMP="/tmp"
@@ -196,33 +293,75 @@ else
  TMP="${TMPDIR%/}"
 fi

-SEED="$(date "+%Y%m%d%H%M%S").$$"
-UPGRADE_PATH="${TMP}/pyenv-virtualenv.${SEED}"
-UPGRADE_LIST="${TMP}/pyenv-virtualenv.${SEED}.txt"
-
 VIRTUALENV_PATH="${PYENV_ROOT}/versions/${VIRTUALENV_NAME}"

-if virtualenv_is_pyvenv; then
-  # Unset some arguments not supported by pyvenv
-  unset QUIET
-  unset VERBOSE
-  if [ -n "$UPGRADE" ]; then
+unset HAS_VIRTUALENV
+unset HAS_PYVENV
+unset USE_PYVENV
+detect_venv
+
+SEED="$(date "+%Y%m%d%H%M%S").$$"
+VIRTUALENV_ORIG="${VIRTUALENV_PATH}.${SEED}"
+REQUIREMENTS="${TMP}/requirements.${SEED}.txt"
+
+# Upgrade existing virtualenv
+if [ -n "$UPGRADE" ]; then
+  FORCE=1
+  # pyvenv has `--upgrade` by default
+  if [ -n "${USE_PYVENV}" ]; then
    unset UPGRADE
    VIRTUALENV_OPTIONS[${#VIRTUALENV_OPTIONS[*]}]="--upgrade"
  fi
-else
-  pyenv-which "virtualenv" 1>/dev/null 2>&1 || {
-    VIRTUALENV_VERSION="==${VIRTUALENV_VERSION}"
-    pyenv-exec pip install $QUIET $VERBOSE "virtualenv${VIRTUALENV_VERSION%==}"
-    pyenv-rehash
-  }
 fi

-# Unset environment variables which starts with `VIRTUALENV_`.
+if [ -n "${USE_PYVENV}" ]; then
+  # Unset some arguments not supported by pyvenv
+  unset QUIET
+  unset VERBOSE
+  if [ -n "${VIRTUALENV_PYTHON}" ]; then
+    echo "pyenv-virtualenv: \`--python=${VIRTUALENV_PYTHON}' is not supported by pyvenv." 1>&2
+    exit 1
+  fi
+else
+  if [ -n "${VIRTUALENV_PYTHON}" ]; then
+    if [[ "${VIRTUALENV_PYTHON}" == "${VIRTUALENV_PYTHON##*/}" ]] || [[ "${VIRTUALENV_PYTHON}" == "${PYENV_ROOT}/shims/"* ]]; then
+      python="$(pyenv-which "${VIRTUALENV_PYTHON##*/}" 2>/dev/null || true)"
+      if [ -x "${python}" ]; then
+        VIRTUALENV_OPTIONS[${#VIRTUALENV_OPTIONS[*]}]="--python=${python}"
+      else
+        python="$(PYENV_VERSION="$(pyenv-whence "${VIRTUALENV_PYTHON##*/}" 2>/dev/null | tail -n 1 || true)" pyenv-which "${VIRTUALENV_PYTHON##*/}" 2>/dev/null || true)"
+        if [ -x "${python}" ]; then
+          VIRTUALENV_OPTIONS[${#VIRTUALENV_OPTIONS[*]}]="--python=${python}"
+        else
+          echo "pyenv-virtualenv: \`${VIRTUALENV_PYTHON##*/}' is not installed in pyenv." 1>&2
+          exit 1
+        fi
+      fi
+    else
+      VIRTUALENV_OPTIONS[${#VIRTUALENV_OPTIONS[*]}]="--python=${VIRTUALENV_PYTHON}"
+    fi
+  fi
+  if [ -z "${HAS_VIRTUALENV}" ]; then
+    VIRTUALENV_VERSION="==${VIRTUALENV_VERSION}"
+    pyenv-exec pip install $QUIET $VERBOSE "virtualenv${VIRTUALENV_VERSION%==}"
+    HAS_VIRTUALENV=1
+  fi
+fi
+
+# Unset environment variables which start with `VIRTUALENV_`.
 # These variables are reserved for virtualenv.
 unset VIRTUALENV_VERSION


+# Download specified version of ez_setup.py/get-pip.py.
+if [ -n "${SETUPTOOLS_VERSION}" ]; then
+  EZ_SETUP_URL="https://bitbucket.org/pypa/setuptools/raw/${SETUPTOOLS_VERSION}/ez_setup.py"
+fi
+if [ -n "${PIP_VERSION}" ]; then
+  GET_PIP_URL="https://raw.githubusercontent.com/pypa/pip/${PIP_VERSION}/contrib/get-pip.py"
+fi
+
+
 # Define `before_virtualenv` and `after_virtualenv` functions that allow
 # plugin hooks to register a string of code for execution before or
 # after the installation process.
@@ -239,9 +378,10 @@ after_virtualenv() {
 }

 # Load plugin hooks.
-for script in $(pyenv-hooks virtualenv); do
-  source "$script"
-done
+OLDIFS="$IFS"
+IFS=$'\n' scripts=(`pyenv-hooks virtualenv`)
+IFS="$OLDIFS"
+for script in "${scripts[@]}"; do source "$script"; done


 [ -d "${VIRTUALENV_PATH}" ] && PREFIX_EXISTS=1
@@ -250,7 +390,7 @@ done
 # the --force option was specified.
 if [ -d "${VIRTUALENV_PATH}/bin" ]; then
  if [ -z "$FORCE" ]; then
-    echo "pyenv: ${VIRTUALENV_PATH} already exists" 1>&2
+    echo "pyenv-virtualenv: ${VIRTUALENV_PATH} already exists" 1>&2
    read -p "continue with installation? (y/N) "

    case "$REPLY" in
@@ -260,8 +400,7 @@ if [ -d "${VIRTUALENV_PATH}/bin" ]; then
  fi

  if [ -n "$UPGRADE" ]; then
-    PYENV_VERSION="${VIRTUALENV_NAME}" pyenv-exec pip freeze >"${UPGRADE_LIST}"
-    mv -f "${VIRTUALENV_PATH}" "${UPGRADE_PATH}"
+    PYENV_VERSION="${VIRTUALENV_NAME}" prepare_requirements
  fi
 fi

@@ -277,47 +416,19 @@ trap cleanup SIGINT

 # Invoke virtualenv and record exit status in $STATUS.
 STATUS=0
-# virtualenv may download distribute/setuptools in current directory.
-# change to cache directory to reuse them between invocation.
+# virtualenv may download distribute/setuptools into the current directory.
+# Change to cache directory to reuse them between invocations.
 mkdir -p "${PYENV_VIRTUALENV_CACHE_PATH}"
 cd "${PYENV_VIRTUALENV_CACHE_PATH}"
-venv $QUIET $VERBOSE "${VIRTUALENV_OPTIONS[@]}" "${VIRTUALENV_PATH}" && {
-  if virtualenv_is_pyvenv; then
-    [ -n "${EZ_SETUP_URL}" ] || EZ_SETUP_URL="https://bitbucket.org/pypa/setuptools/raw/${SETUPTOOLS_VERSION:-0.7.4}/ez_setup.py"
-    PYENV_VERSION="${VIRTUALENV_NAME}" pyenv-exec python -c 'import setuptools' 1>/dev/null 2>&1 || {
-      echo "Installing setuptools from ${EZ_SETUP_URL}..." 1>&2
-      http get "${EZ_SETUP_URL}" | PYENV_VERSION="${VIRTUALENV_NAME}" pyenv-exec python
-    }
+venv $QUIET $VERBOSE "${VIRTUALENV_OPTIONS[@]}" "${VIRTUALENV_PATH}" || STATUS="$?"

-    [ -n "${GET_PIP_URL}" ] || GET_PIP_URL="https://raw.github.com/pypa/pip/${PIP_VERSION:-master}/contrib/get-pip.py"
-    PYENV_VERSION="${VIRTUALENV_NAME}" pyenv-which pip 1>/dev/null 2>&1 || {
-      echo "Installing pip from ${GET_PIP_URL}..." 1>&2
-      http get "${GET_PIP_URL}" | PYENV_VERSION="${VIRTUALENV_NAME}" pyenv-exec python
-    }
-  fi
-} || STATUS="$?"
+## Install setuptools and pip.
+PYENV_VERSION="${VIRTUALENV_NAME}" build_package_ensurepip

-## Migrate previously installed packages from requirements.txt
-if [ -n "$UPGRADE" ]; then
-  UPGRADE_STATUS=0
-  PYENV_VERSION="${VIRTUALENV_NAME}" pyenv-exec pip install $QUIET $VERBOSE --requirement "${UPGRADE_LIST}" || UPGRADE_STATUS=$?
-  if [ "$UPGRADE_STATUS" == "0" ]; then
-    rm -f "${UPGRADE_LIST}"
-    rm -fr "${UPGRADE_PATH}"
-  else
-    { echo
-      echo "UPGRADE FAILED"
-      echo
-      echo "Inspect or clean up the original tree at ${UPGRADE_PATH}"
-      echo
-      echo "Package list:"
-      cat "${UPGRADE_LIST}"
-    } 1>&2
-    STATUS="$UPGRADE_STATUS"
-  fi
-fi
+## Migrate previously installed packages from requirements.txt.
+PYENV_VERSION="${VIRTUALENV_NAME}" install_requirements || true

-# Execute `after_virtualenv` hooks
+# Execute `after_virtualenv` hooks.
 for hook in "${after_hooks[@]}"; do eval "$hook"; done

 # Run `pyenv-rehash` after a successful installation.
--- a/bin/pyenv-virtualenv-init
+++ b/bin/pyenv-virtualenv-init
@@ -0,0 +1,158 @@
+#!/usr/bin/env bash
+# Summary: Configure the shell environment for pyenv-virtualenv
+# Usage: eval "$(pyenv virtualenv-init - [<shell>])"
+#
+# Automatically activates a Python virtualenv environment based on current
+# pyenv version.
+#
+
+set -e
+[ -n "$PYENV_DEBUG" ] && set -x
+
+print=""
+for args in "$@"
+do
+  if [ "$args" = "-" ]; then
+    print=1
+    shift
+  fi
+done
+
+shell="${1:-$PYENV_SHELL}"
+if [ -z "$shell" ]; then
+  shell="$(ps -p "$PPID" -o 'args=' 2>/dev/null || true)"
+  shell="${shell##-}"
+  shell="${shell%% *}"
+  shell="${shell:-$SHELL}"
+  shell="${shell##*/}"
+fi
+
+if [ -z "$print" ]; then
+  case "$shell" in
+  bash )
+    profile='~/.bash_profile'
+    ;;
+  zsh )
+    profile='~/.zshrc'
+    ;;
+  ksh )
+    profile='~/.profile'
+    ;;
+  fish )
+    profile='~/.config/fish/config.fish'
+    ;;
+  * )
+    profile='your profile'
+    ;;
+  esac
+
+  { echo "# Load pyenv-virtualenv automatically by adding"
+    echo "# the following to ${profile}:"
+    echo
+    case "$shell" in
+    fish )
+      echo 'status --is-interactive; and . (pyenv virtualenv-init -|psub)'
+      ;;
+    * )
+      echo 'eval "$(pyenv virtualenv-init -)"'
+      ;;
+    esac
+    echo
+  } >&2
+
+  exit 1
+fi
+
+case "$shell" in
+fish )
+  echo "setenv PYENV_VIRTUALENV_INIT 1;"
+  ;;
+* )
+  echo "export PYENV_VIRTUALENV_INIT=1;"
+  ;;
+esac
+
+case "$shell" in
+fish )
+  cat <<EOS
+function _pyenv_virtualenv_hook --on-event fish_prompt;
+  set -l PYENV_PREFIX (pyenv prefix 2>/dev/null; or true)
+  if [ -n "\$PYENV_ACTIVATE" ]
+    if [ (pyenv version-name 2>/dev/null; or true) = "system" ]
+      pyenv deactivate --no-error --verbose
+      set -e PYENV_DEACTIVATE
+      return 0
+    end
+    if [ "\$PYENV_ACTIVATE" != "\$PYENV_PREFIX" ]
+      if pyenv deactivate --no-error --verbose
+        set -e PYENV_DEACTIVATE
+        pyenv activate --no-error --verbose; or set -e PYENV_DEACTIVATE
+      else
+        pyenv activate --no-error --verbose
+      end
+    end
+  else
+    if [ -z "\$VIRTUAL_ENV" ]; and [ "\$PYENV_DEACTIVATE" != "\$PYENV_PREFIX" ]
+      pyenv activate --no-error --verbose; or true
+    end
+  end
+end
+EOS
+ ;;
+ksh )
+  cat <<EOS
+function _pyenv_virtualenv_hook() {
+EOS
+  ;;
+* )
+  cat <<EOS
+_pyenv_virtualenv_hook() {
+EOS
+  ;;
+esac
+
+if [[ "$shell" != "fish" ]]; then
+  cat <<EOS
+  if [ -n "\$PYENV_ACTIVATE" ]; then
+    if [ "\$(pyenv version-name 2>/dev/null || true)" = "system" ]; then
+      eval "\$(pyenv sh-deactivate --no-error --verbose)"
+      unset PYENV_DEACTIVATE
+      return 0
+    fi
+    if [ "\$PYENV_ACTIVATE" != "\$(pyenv prefix 2>/dev/null || true)" ]; then
+      if eval "\$(pyenv sh-deactivate --no-error --verbose)"; then
+        unset PYENV_DEACTIVATE
+        eval "\$(pyenv sh-activate --no-error --verbose)" || unset PYENV_DEACTIVATE
+      else
+        eval "\$(pyenv sh-activate --no-error --verbose)"
+      fi
+    fi
+  else
+    if [ -z "\$VIRTUAL_ENV" ] && [ "\$PYENV_DEACTIVATE" != "\$(pyenv prefix 2>/dev/null || true)" ]; then
+      eval "\$(pyenv sh-activate --no-error --verbose)" || true
+    fi
+  fi
+};
+EOS
+
+  case "$shell" in
+  bash )
+    cat <<EOS
+if ! [[ "\$PROMPT_COMMAND" =~ _pyenv_virtualenv_hook ]]; then
+  PROMPT_COMMAND="_pyenv_virtualenv_hook;\$PROMPT_COMMAND";
+fi
+EOS
+    ;;
+  zsh )
+    cat <<EOS
+typeset -g -a precmd_functions
+if [[ -z \$precmd_functions[(r)_pyenv_virtualenv_hook] ]]; then
+  precmd_functions+=_pyenv_virtualenv_hook;
+fi
+EOS
+    ;;
+  * )
+    # FIXME: what should i do here??
+    ;;
+  esac
+fi
--- a/bin/pyenv-virtualenv-prefix
+++ b/bin/pyenv-virtualenv-prefix
@@ -31,15 +31,33 @@ base_prefix() { # pyvenv
 }

 VIRTUALENV_PREFIX_PATHS=()
-for version in "${versions[@]}"; do
+for version_string in "${versions[@]}"; do
+  version="${version_string%%/*}"
+  if [ "$version" = "system" ]; then
+    echo "pyenv-virtualenv: version \`${version}' is not a virtualenv" 1>&2
+    exit 1
+  fi
  PREFIX="$(pyenv-prefix "${version}")"
  if [ -f "${PREFIX}/bin/activate" ]; then
-    VIRTUALENV_PREFIX_PATH="$(real_prefix "${version}" || base_prefix "${version}" || true)"
-    if [ -d "${VIRTUALENV_PREFIX_PATH}" ]; then
+    # Anaconda has `activate` script nevertheless it is not a virtual environment (#65)
+    if [ -f "${PREFIX}/bin/conda" ]; then
+      if [[ "${version_string}" != "${version_string%/envs/*}" ]]; then
+        conda_env="${version_string##*/envs/}"
+        if [ -f "${PREFIX}/envs/${conda_env}/bin/conda" ]; then
+          VIRTUALENV_PREFIX_PATHS=("${VIRTUALENV_PREFIX_PATHS[@]}" "${PREFIX}")
+        else
+          echo "pyenv-virtualenv: version \`${version_string}' is not an environment of anaconda/miniconda" 1>&2
+          exit 1
+        fi
+      else
+        VIRTUALENV_PREFIX_PATHS=("${VIRTUALENV_PREFIX_PATHS[@]}" "${PREFIX}")
+      fi
+    else
+      VIRTUALENV_PREFIX_PATH="$(real_prefix "${version}" || base_prefix "${version}" || true)"
      VIRTUALENV_PREFIX_PATHS=("${VIRTUALENV_PREFIX_PATHS[@]}" "$VIRTUALENV_PREFIX_PATH")
    fi
  else
-    echo "pyenv: version \`${version}' is not a virtualenv" 1>&2
+    echo "pyenv-virtualenv: version \`${version}' is not a virtualenv" 1>&2
    exit 1
  fi
 done
--- a/bin/pyenv-virtualenvs
+++ b/bin/pyenv-virtualenvs
@@ -51,6 +51,15 @@ for version in $(pyenv-versions --bare); do
    virtualenv_prefix="$(pyenv-virtualenv-prefix "${version}" 2>/dev/null || true)"
    if [ -d "${virtualenv_prefix}" ]; then
      print_version "${version}" " (created from ${virtualenv_prefix})"
+      prefix="$(pyenv-prefix "${version}")"
+      if [ -f "${prefix}/bin/conda" ]; then
+        # envs of anaconda/miniconda
+        shopt -s nullglob
+        for conda_env in "${prefix}/envs/"*; do
+          print_version "${version##*/}${conda_env#${prefix}}" " (created from ${prefix})"
+        done
+        shopt -u nullglob
+      fi
    fi
  fi
 done
--- a/etc/pyenv.d/which/python-config.bash
+++ b/etc/pyenv.d/which/python-config.bash
@@ -0,0 +1,14 @@
+# some of libraries require `python-config` in PATH to build native extensions.
+# as a workaround, this hook will try to find the executable from the source
+# version of the virtualenv.
+# https://github.com/yyuu/pyenv/issues/397
+
+if [ ! -x "${PYENV_COMMAND_PATH}" ] && [[ "${PYENV_COMMAND_PATH##*/}" == "python"*"-config" ]]; then
+  virtualenv_prefix="$(pyenv-virtualenv-prefix 2>/dev/null || true)"
+  if [ -d "${virtualenv_prefix}" ]; then
+    virtualenv_command_path="${virtualenv_prefix}/bin/${PYENV_COMMAND_PATH##*/}"
+    if [ -x "${virtualenv_command_path}" ]; then
+      PYENV_COMMAND_PATH="${virtualenv_command_path}"
+    fi
+  fi
+fi
--- a/etc/pyenv.d/which/system-site-packages.bash
+++ b/etc/pyenv.d/which/system-site-packages.bash
@@ -0,0 +1,20 @@
+# if virtualenv is created with `--system-site-packages`,
+# looks up executables for source version as well if none is
+# installed in the virtualenv.
+# https://github.com/yyuu/pyenv-virtualenv/issues/62
+
+if [ ! -x "${PYENV_COMMAND_PATH}" ]; then
+  virtualenv_prefix="$(pyenv-virtualenv-prefix 2>/dev/null || true)"
+  if [ -d "${virtualenv_prefix}" ]; then
+    shopt -s nullglob
+    no_global_site_packages="$(echo "$(pyenv-prefix)/lib/"*"/no-global-site-packages.txt")"
+    shopt -u nullglob
+    if [ ! -f "${no_global_site_packages}" ]; then
+      # virtualenv is created with `--system-site-packages`
+      virtualenv_command_path="${virtualenv_prefix}/bin/${PYENV_COMMAND_PATH##*/}"
+      if [ -x "${virtualenv_command_path}" ]; then
+        PYENV_COMMAND_PATH="${virtualenv_command_path}"
+      fi
+    fi
+  fi
+fi
--- a/install.sh
+++ b/install.sh
@@ -1,17 +1,18 @@
 #!/bin/sh
+# Usage: PREFIX=/usr/local ./install.sh
+#
+# Installs pyenv-virtualenv under $PREFIX.

 set -e

+cd "$(dirname "$0")"
+
 if [ -z "${PREFIX}" ]; then
  PREFIX="/usr/local"
 fi

 BIN_PATH="${PREFIX}/bin"

-mkdir -p "${BIN_PATH}"
+mkdir -p "$BIN_PATH"

-for file in bin/*; do
-  cp "${file}" "${BIN_PATH}"
-done
-
-echo "Installed pyenv-virtualenv at ${PREFIX}"
+install -p bin/* "$BIN_PATH"
--- a/test/activate.bats
+++ b/test/activate.bats
@@ -0,0 +1,296 @@
+#!/usr/bin/env bats
+
+load test_helper
+
+setup() {
+  export HOME="${TMP}"
+  export PYENV_ROOT="${TMP}/pyenv"
+}
+
+@test "activate virtualenv from current version" {
+  export PYENV_VIRTUALENV_INIT=1
+
+  stub pyenv-version-name "echo venv"
+  stub pyenv-virtualenv-prefix "venv : echo \"${PYENV_ROOT}/versions/venv\""
+  stub pyenv-prefix "venv : echo \"${PYENV_ROOT}/versions/venv\""
+  stub pyenv-prefix "venv : echo \"${PYENV_ROOT}/versions/venv\""
+
+  PYENV_SHELL="bash" PYENV_VERSION="venv" run pyenv-sh-activate
+
+  unstub pyenv-version-name
+  unstub pyenv-virtualenv-prefix
+  unstub pyenv-prefix
+
+  assert_success
+  assert_output <<EOS
+unset PYENV_DEACTIVATE;
+export PYENV_ACTIVATE="${PYENV_ROOT}/versions/venv";
+. "${PYENV_ROOT}/versions/venv/bin/activate";
+EOS
+}
+
+@test "activate virtualenv from current version (verbose)" {
+  export PYENV_VIRTUALENV_INIT=1
+
+  stub pyenv-version-name "echo venv"
+  stub pyenv-virtualenv-prefix "venv : echo \"${PYENV_ROOT}/versions/venv\""
+  stub pyenv-prefix "venv : echo \"${PYENV_ROOT}/versions/venv\""
+  stub pyenv-prefix "venv : echo \"${PYENV_ROOT}/versions/venv\""
+
+  PYENV_SHELL="bash" PYENV_VERSION="venv" run pyenv-sh-activate --verbose
+
+  unstub pyenv-version-name
+  unstub pyenv-virtualenv-prefix
+  unstub pyenv-prefix
+
+  assert_success
+  assert_output <<EOS
+pyenv-virtualenv: activate venv
+unset PYENV_DEACTIVATE;
+export PYENV_ACTIVATE="${PYENV_ROOT}/versions/venv";
+. "${PYENV_ROOT}/versions/venv/bin/activate";
+EOS
+}
+
+@test "activate virtualenv from current version (without pyenv-virtualenv-init)" {
+  export PYENV_VIRTUALENV_INIT=
+
+  stub pyenv-version-name "echo venv"
+  stub pyenv-virtualenv-prefix "venv : echo \"${PYENV_ROOT}/versions/venv\""
+  stub pyenv-prefix "venv : echo \"${PYENV_ROOT}/versions/venv\""
+  stub pyenv-prefix "venv : echo \"${PYENV_ROOT}/versions/venv\""
+
+  PYENV_SHELL="bash" PYENV_VERSION="venv" run pyenv-sh-activate
+
+  unstub pyenv-version-name
+  unstub pyenv-virtualenv-prefix
+  unstub pyenv-prefix
+
+  assert_success
+  assert_output <<EOS
+# Load pyenv-virtualenv automatically by adding
+# the following to ~/.bash_profile:
+
+eval "\$(pyenv virtualenv-init -)"
+
+pyenv shell "venv";
+export PYENV_ACTIVATE_SHELL=1;
+unset PYENV_DEACTIVATE;
+export PYENV_ACTIVATE="${PYENV_ROOT}/versions/venv";
+. "${PYENV_ROOT}/versions/venv/bin/activate";
+EOS
+}
+
+@test "activate virtualenv from current version (fish)" {
+  export PYENV_VIRTUALENV_INIT=1
+
+  stub pyenv-version-name "echo venv"
+  stub pyenv-virtualenv-prefix "venv : echo \"${PYENV_ROOT}/versions/venv\""
+  stub pyenv-prefix "venv : echo \"${PYENV_ROOT}/versions/venv\""
+  stub pyenv-prefix "venv : echo \"${PYENV_ROOT}/versions/venv\""
+
+  PYENV_SHELL="fish" PYENV_VERSION="venv" run pyenv-sh-activate
+
+  unstub pyenv-version-name
+  unstub pyenv-virtualenv-prefix
+  unstub pyenv-prefix
+
+  assert_success
+  assert_output <<EOS
+set -e PYENV_DEACTIVATE;
+setenv PYENV_ACTIVATE "${PYENV_ROOT}/versions/venv";
+. "${PYENV_ROOT}/versions/venv/bin/activate.fish";
+EOS
+}
+
+@test "activate virtualenv from current version (fish) (without pyenv-virtualenv-init)" {
+  export PYENV_VIRTUALENV_INIT=
+
+  stub pyenv-version-name "echo venv"
+  stub pyenv-virtualenv-prefix "venv : echo \"${PYENV_ROOT}/versions/venv\""
+  stub pyenv-prefix "venv : echo \"${PYENV_ROOT}/versions/venv\""
+  stub pyenv-prefix "venv : echo \"${PYENV_ROOT}/versions/venv\""
+
+  PYENV_SHELL="fish" PYENV_VERSION="venv" run pyenv-sh-activate
+
+  unstub pyenv-version-name
+  unstub pyenv-virtualenv-prefix
+  unstub pyenv-prefix
+
+  assert_success
+  assert_output <<EOS
+# Load pyenv-virtualenv automatically by adding
+# the following to ~/.config/fish/config.fish:
+
+status --is-interactive; and . (pyenv virtualenv-init -|psub)
+
+pyenv shell "venv";
+setenv PYENV_ACTIVATE_SHELL 1;
+set -e PYENV_DEACTIVATE;
+setenv PYENV_ACTIVATE "${PYENV_ROOT}/versions/venv";
+. "${PYENV_ROOT}/versions/venv/bin/activate.fish";
+EOS
+}
+
+@test "activate virtualenv from command-line argument" {
+  export PYENV_VIRTUALENV_INIT=1
+
+  stub pyenv-virtualenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/venv27\""
+  stub pyenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/venv27\""
+  stub pyenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/venv27\""
+
+  PYENV_SHELL="bash" PYENV_VERSION="venv" run pyenv-sh-activate "venv27"
+
+  unstub pyenv-virtualenv-prefix
+  unstub pyenv-prefix
+
+  assert_success
+  assert_output <<EOS
+pyenv shell "venv27";
+export PYENV_ACTIVATE_SHELL=1;
+unset PYENV_DEACTIVATE;
+export PYENV_ACTIVATE="${PYENV_ROOT}/versions/venv27";
+. "${PYENV_ROOT}/versions/venv27/bin/activate";
+EOS
+}
+
+@test "activate virtualenv from command-line argument (without pyenv-virtualenv-init)" {
+  export PYENV_VIRTUALENV_INIT=
+
+  stub pyenv-virtualenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/venv27\""
+  stub pyenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/venv27\""
+  stub pyenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/venv27\""
+
+  PYENV_SHELL="bash" PYENV_VERSION="venv" run pyenv-sh-activate "venv27"
+
+  unstub pyenv-virtualenv-prefix
+  unstub pyenv-prefix
+
+  assert_success
+  assert_output <<EOS
+# Load pyenv-virtualenv automatically by adding
+# the following to ~/.bash_profile:
+
+eval "\$(pyenv virtualenv-init -)"
+
+pyenv shell "venv27";
+export PYENV_ACTIVATE_SHELL=1;
+unset PYENV_DEACTIVATE;
+export PYENV_ACTIVATE="${PYENV_ROOT}/versions/venv27";
+. "${PYENV_ROOT}/versions/venv27/bin/activate";
+EOS
+}
+
+@test "activate virtualenv from command-line argument (fish)" {
+  export PYENV_VIRTUALENV_INIT=1
+
+  stub pyenv-virtualenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/venv27\""
+  stub pyenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/venv27\""
+  stub pyenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/venv27\""
+
+  PYENV_SHELL="fish" PYENV_VERSION="venv" run pyenv-sh-activate "venv27"
+
+  unstub pyenv-virtualenv-prefix
+  unstub pyenv-prefix
+
+  assert_success
+  assert_output <<EOS
+pyenv shell "venv27";
+setenv PYENV_ACTIVATE_SHELL 1;
+set -e PYENV_DEACTIVATE;
+setenv PYENV_ACTIVATE "${PYENV_ROOT}/versions/venv27";
+. "${PYENV_ROOT}/versions/venv27/bin/activate.fish";
+EOS
+}
+
+@test "activate virtualenv from command-line argument (fish) (without pyenv-virtualenv-init)" {
+  export PYENV_VIRTUALENV_INIT=
+
+  stub pyenv-virtualenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/venv27\""
+  stub pyenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/venv27\""
+  stub pyenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/venv27\""
+
+  PYENV_SHELL="fish" PYENV_VERSION="venv" run pyenv-sh-activate "venv27"
+
+  unstub pyenv-virtualenv-prefix
+  unstub pyenv-prefix
+
+  assert_success
+  assert_output <<EOS
+# Load pyenv-virtualenv automatically by adding
+# the following to ~/.config/fish/config.fish:
+
+status --is-interactive; and . (pyenv virtualenv-init -|psub)
+
+pyenv shell "venv27";
+setenv PYENV_ACTIVATE_SHELL 1;
+set -e PYENV_DEACTIVATE;
+setenv PYENV_ACTIVATE "${PYENV_ROOT}/versions/venv27";
+. "${PYENV_ROOT}/versions/venv27/bin/activate.fish";
+EOS
+}
+
+@test "unset invokes deactivate" {
+  run pyenv-sh-activate --unset
+
+  assert_success
+  assert_output <<EOS
+pyenv deactivate
+EOS
+}
+
+@test "should fail if the version is not a virtualenv" {
+  stub pyenv-virtualenv-prefix "3.3.3 : false"
+  stub pyenv-prefix "3.3.3 : echo \"${PYENV_ROOT}/versions/3.3.3\""
+
+  run pyenv-sh-activate "3.3.3"
+
+  unstub pyenv-virtualenv-prefix
+  unstub pyenv-prefix
+
+  assert_failure
+  assert_output <<EOS
+pyenv-virtualenv: version \`3.3.3' is not a virtualenv
+false
+EOS
+}
+
+@test "should fail if the version is not a virtualenv (no-error)" {
+  stub pyenv-virtualenv-prefix "3.3.3 : false"
+  stub pyenv-prefix "3.3.3 : echo \"${PYENV_ROOT}/versions/3.3.3\""
+
+  run pyenv-sh-activate --no-error "3.3.3"
+
+  unstub pyenv-virtualenv-prefix
+  unstub pyenv-prefix
+
+  assert_failure
+  assert_output <<EOS
+false
+EOS
+}
+
+@test "should fail if there are multiple versions" {
+  run pyenv-sh-activate "venv" "venv27"
+
+  assert_failure
+  assert_output <<EOS
+pyenv-virtualenv: cannot activate multiple versions at once: venv venv27
+false
+EOS
+}
+
+@test "should fail if there are multiple versions (no-error)" {
+  run pyenv-sh-activate --no-error "venv" "venv27"
+
+  assert_failure
+  assert_output <<EOS
+false
+EOS
+}
+
+@test "should fail if activate is invoked as a command" {
+  run pyenv-activate
+
+  assert_failure
+}
--- a/test/conda-activate.bats
+++ b/test/conda-activate.bats
@@ -0,0 +1,149 @@
+#!/usr/bin/env bats
+
+load test_helper
+
+setup() {
+  export HOME="${TMP}"
+  export PYENV_ROOT="${TMP}/pyenv"
+}
+
+@test "activate conda root from current version" {
+  export PYENV_VIRTUALENV_INIT=1
+
+  create_conda "anaconda-2.3.0"
+  stub pyenv-version-name "echo anaconda-2.3.0"
+  stub pyenv-virtualenv-prefix "anaconda-2.3.0 : echo \"${PYENV_ROOT}/versions/anaconda-2.3.0\""
+  stub pyenv-prefix "anaconda-2.3.0 : echo \"${PYENV_ROOT}/versions/anaconda-2.3.0\""
+  stub pyenv-prefix "anaconda-2.3.0 : echo \"${PYENV_ROOT}/versions/anaconda-2.3.0\""
+
+  PYENV_SHELL="bash" PYENV_VERSION="anaconda-2.3.0" run pyenv-sh-activate
+
+  unstub pyenv-version-name
+  unstub pyenv-virtualenv-prefix
+  unstub pyenv-prefix
+
+  assert_success
+  assert_output <<EOS
+unset PYENV_DEACTIVATE;
+export PYENV_ACTIVATE="${PYENV_ROOT}/versions/anaconda-2.3.0";
+. "${PYENV_ROOT}/versions/anaconda-2.3.0/bin/activate" "root";
+EOS
+}
+
+@test "activate conda root from current version (fish)" {
+  export PYENV_VIRTUALENV_INIT=1
+
+  create_conda "anaconda-2.3.0"
+  stub pyenv-version-name "echo anaconda-2.3.0"
+  stub pyenv-virtualenv-prefix "anaconda-2.3.0 : echo \"${PYENV_ROOT}/versions/anaconda-2.3.0\""
+  stub pyenv-prefix "anaconda-2.3.0 : echo \"${PYENV_ROOT}/versions/anaconda-2.3.0\""
+  stub pyenv-prefix "anaconda-2.3.0 : echo \"${PYENV_ROOT}/versions/anaconda-2.3.0\""
+
+  PYENV_SHELL="fish" PYENV_VERSION="anaconda-2.3.0" run pyenv-sh-activate
+
+  unstub pyenv-version-name
+  unstub pyenv-virtualenv-prefix
+  unstub pyenv-prefix
+
+  assert_failure
+  assert_output <<EOS
+pyenv-virtualenv: Only bash and zsh are supported by Anaconda/Miniconda
+false
+EOS
+}
+
+@test "activate conda root from command-line argument" {
+  export PYENV_VIRTUALENV_INIT=1
+
+  create_conda "anaconda-2.3.0"
+  create_conda "miniconda-3.9.1"
+  stub pyenv-virtualenv-prefix "miniconda-3.9.1 : echo \"${PYENV_ROOT}/versions/miniconda-3.9.1\""
+  stub pyenv-prefix "miniconda-3.9.1 : echo \"${PYENV_ROOT}/versions/miniconda-3.9.1\""
+  stub pyenv-prefix "miniconda-3.9.1 : echo \"${PYENV_ROOT}/versions/miniconda-3.9.1\""
+
+  PYENV_SHELL="bash" PYENV_VERSION="anaconda-2.3.0" run pyenv-sh-activate "miniconda-3.9.1"
+
+  unstub pyenv-virtualenv-prefix
+  unstub pyenv-prefix
+
+  assert_success
+  assert_output <<EOS
+pyenv shell "miniconda-3.9.1";
+export PYENV_ACTIVATE_SHELL=1;
+unset PYENV_DEACTIVATE;
+export PYENV_ACTIVATE="${PYENV_ROOT}/versions/miniconda-3.9.1";
+. "${PYENV_ROOT}/versions/miniconda-3.9.1/bin/activate" "root";
+EOS
+}
+
+@test "activate conda env from current version" {
+  export PYENV_VIRTUALENV_INIT=1
+
+  create_conda "anaconda-2.3.0" "foo"
+  stub pyenv-version-name "echo anaconda-2.3.0/envs/foo"
+  stub pyenv-virtualenv-prefix "anaconda-2.3.0/envs/foo : echo \"${PYENV_ROOT}/versions/anaconda-2.3.0/envs/foo\""
+  stub pyenv-prefix "anaconda-2.3.0/envs/foo : echo \"${PYENV_ROOT}/versions/anaconda-2.3.0/envs/foo\""
+  stub pyenv-prefix "anaconda-2.3.0/envs/foo : echo \"${PYENV_ROOT}/versions/anaconda-2.3.0/envs/foo\""
+
+  PYENV_SHELL="bash" PYENV_VERSION="anaconda-2.3.0/envs/foo" run pyenv-sh-activate
+
+  unstub pyenv-version-name
+  unstub pyenv-virtualenv-prefix
+  unstub pyenv-prefix
+
+  assert_success
+  assert_output <<EOS
+unset PYENV_DEACTIVATE;
+export PYENV_ACTIVATE="${PYENV_ROOT}/versions/anaconda-2.3.0/envs/foo";
+. "${PYENV_ROOT}/versions/anaconda-2.3.0/bin/activate" "foo";
+EOS
+}
+
+@test "activate conda env from command-line argument" {
+  export PYENV_VIRTUALENV_INIT=1
+
+  create_conda "anaconda-2.3.0" "foo"
+  create_conda "miniconda-3.9.1" "bar"
+  stub pyenv-virtualenv-prefix "miniconda-3.9.1/envs/bar : echo \"${PYENV_ROOT}/versions/miniconda-3.9.1\""
+  stub pyenv-prefix "miniconda-3.9.1/envs/bar : echo \"${PYENV_ROOT}/versions/miniconda-3.9.1/envs/bar\""
+  stub pyenv-prefix "miniconda-3.9.1/envs/bar : echo \"${PYENV_ROOT}/versions/miniconda-3.9.1/envs/bar\""
+
+  PYENV_SHELL="bash" PYENV_VERSION="anaconda-2.3.0/envs/foo" run pyenv-sh-activate "miniconda-3.9.1/envs/bar"
+
+  unstub pyenv-virtualenv-prefix
+  unstub pyenv-prefix
+
+  assert_success
+  assert_output <<EOS
+pyenv shell "miniconda-3.9.1/envs/bar";
+export PYENV_ACTIVATE_SHELL=1;
+unset PYENV_DEACTIVATE;
+export PYENV_ACTIVATE="${PYENV_ROOT}/versions/miniconda-3.9.1/envs/bar";
+. "${PYENV_ROOT}/versions/miniconda-3.9.1/bin/activate" "bar";
+EOS
+}
+
+@test "activate conda env from command-line argument in short-form" {
+  export PYENV_VIRTUALENV_INIT=1
+
+  create_conda "miniconda-3.9.1" "bar"
+  stub pyenv-prefix "bar : false"
+  stub pyenv-version-name " : echo miniconda-3.9.1"
+  stub pyenv-virtualenv-prefix "miniconda-3.9.1/envs/bar : echo \"${PYENV_ROOT}/versions/miniconda-3.9.1/envs/bar\""
+  stub pyenv-prefix "miniconda-3.9.1/envs/bar : echo \"${PYENV_ROOT}/versions/miniconda-3.9.1/envs/bar\""
+
+  PYENV_SHELL="bash" PYENV_VERSION="miniconda-3.9.1" run pyenv-sh-activate "bar"
+
+  unstub pyenv-prefix
+  unstub pyenv-version-name
+  unstub pyenv-virtualenv-prefix
+
+  assert_success
+  assert_output <<EOS
+pyenv shell "miniconda-3.9.1/envs/bar";
+export PYENV_ACTIVATE_SHELL=1;
+unset PYENV_DEACTIVATE;
+export PYENV_ACTIVATE="${PYENV_ROOT}/versions/miniconda-3.9.1/envs/bar";
+. "${PYENV_ROOT}/versions/miniconda-3.9.1/bin/activate" "bar";
+EOS
+}
--- a/test/conda-deactivate.bats
+++ b/test/conda-deactivate.bats
@@ -0,0 +1,64 @@
+#!/usr/bin/env bats
+
+load test_helper
+
+setup() {
+  export PYENV_ROOT="${TMP}/pyenv"
+}
+
+@test "deactivate conda root" {
+  export PYENV_ACTIVATE="${PYENV_ROOT}/versions/anaconda-2.3.0"
+  export PYENV_ACTIVATE_SHELL=
+
+  create_conda "anaconda-2.3.0"
+
+  PYENV_SHELL="bash" run pyenv-sh-deactivate
+
+  assert_success
+  assert_output <<EOS
+if [ -f "${PYENV_ROOT}/versions/anaconda-2.3.0/bin/deactivate" ]; then
+  export PYENV_DEACTIVATE="$PYENV_ACTIVATE";
+  unset PYENV_ACTIVATE;
+  . "${PYENV_ROOT}/versions/anaconda-2.3.0/bin/deactivate";
+else
+  echo "pyenv-virtualenv: no virtualenv has been activated." 1>&2;
+  false;
+fi;
+EOS
+}
+
+@test "deactivate conda root (fish)" {
+  export PYENV_ACTIVATE="${PYENV_ROOT}/versions/anaconda-2.3.0"
+  export PYENV_ACTIVATE_SHELL=
+
+  create_conda "anaconda-2.3.0"
+
+  PYENV_SHELL="fish" run pyenv-sh-deactivate
+
+  assert_failure
+  assert_output <<EOS
+pyenv-virtualenv: Only bash and zsh are supported by Anaconda/Miniconda
+false
+EOS
+}
+
+@test "deactivate conda env" {
+  export PYENV_ACTIVATE="${PYENV_ROOT}/versions/anaconda-2.3.0/envs/foo"
+  export PYENV_ACTIVATE_SHELL=
+
+  create_conda "anaconda-2.3.0" "foo"
+
+  PYENV_SHELL="bash" run pyenv-sh-deactivate
+
+  assert_success
+  assert_output <<EOS
+if [ -f "${PYENV_ROOT}/versions/anaconda-2.3.0/bin/deactivate" ]; then
+  export PYENV_DEACTIVATE="$PYENV_ACTIVATE";
+  unset PYENV_ACTIVATE;
+  . "${PYENV_ROOT}/versions/anaconda-2.3.0/bin/deactivate";
+else
+  echo "pyenv-virtualenv: no virtualenv has been activated." 1>&2;
+  false;
+fi;
+EOS
+}
--- a/test/conda-virtualenv-prefix.bats
+++ b/test/conda-virtualenv-prefix.bats
@@ -0,0 +1,41 @@
+#!/usr/bin/env bats
+
+load test_helper
+
+setup() {
+  export PYENV_ROOT="${TMP}/pyenv"
+}
+
+@test "display conda root" {
+  create_conda "anaconda-2.3.0"
+
+  stub pyenv-version-name "echo anaconda-2.3.0"
+  stub pyenv-prefix "anaconda-2.3.0 : echo \"${PYENV_ROOT}/versions/anaconda-2.3.0\""
+
+  PYENV_VERSION="anaconda-2.3.0" run pyenv-virtualenv-prefix
+
+  unstub pyenv-version-name
+  unstub pyenv-prefix
+
+  assert_success
+  assert_output <<OUT
+${PYENV_ROOT}/versions/anaconda-2.3.0
+OUT
+}
+
+@test "display conda env" {
+  create_conda "anaconda-2.3.0" "foo"
+
+  stub pyenv-version-name "echo anaconda-2.3.0/envs/foo"
+  stub pyenv-prefix "anaconda-2.3.0 : echo \"${PYENV_ROOT}/versions/anaconda-2.3.0\""
+
+  PYENV_VERSION="anaconda-2.3.0/envs/foo" run pyenv-virtualenv-prefix
+
+  unstub pyenv-version-name
+  unstub pyenv-prefix
+
+  assert_success
+  assert_output <<OUT
+${PYENV_ROOT}/versions/anaconda-2.3.0
+OUT
+}
--- a/test/deactivate.bats
+++ b/test/deactivate.bats
@@ -0,0 +1,229 @@
+#!/usr/bin/env bats
+
+load test_helper
+
+setup() {
+  export PYENV_ROOT="${TMP}/pyenv"
+}
+
+@test "deactivate virtualenv" {
+  export PYENV_ACTIVATE="${PYENV_ROOT}/versions/venv"
+  export PYENV_ACTIVATE_SHELL=
+
+  PYENV_SHELL="bash" run pyenv-sh-deactivate
+
+  assert_success
+  assert_output <<EOS
+if declare -f deactivate 1>/dev/null 2>&1; then
+  export PYENV_DEACTIVATE="$PYENV_ACTIVATE";
+  unset PYENV_ACTIVATE;
+  deactivate;
+else
+  echo "pyenv-virtualenv: no virtualenv has been activated." 1>&2;
+  false;
+fi;
+EOS
+}
+
+@test "deactivate virtualenv (verbose)" {
+  export PYENV_ACTIVATE="${PYENV_ROOT}/versions/venv"
+  export PYENV_ACTIVATE_SHELL=
+
+  PYENV_SHELL="bash" run pyenv-sh-deactivate --verbose
+
+  assert_success
+  assert_output <<EOS
+if declare -f deactivate 1>/dev/null 2>&1; then
+  echo "pyenv-virtualenv: deactivate venv" 1>&2;
+  export PYENV_DEACTIVATE="$PYENV_ACTIVATE";
+  unset PYENV_ACTIVATE;
+  deactivate;
+else
+  echo "pyenv-virtualenv: no virtualenv has been activated." 1>&2;
+  false;
+fi;
+EOS
+}
+
+@test "deactivate virtualenv (no-error)" {
+  export PYENV_ACTIVATE="${PYENV_ROOT}/versions/venv"
+  export PYENV_ACTIVATE_SHELL=
+
+  PYENV_SHELL="bash" run pyenv-sh-deactivate --no-error
+
+  assert_success
+  assert_output <<EOS
+if declare -f deactivate 1>/dev/null 2>&1; then
+  export PYENV_DEACTIVATE="$PYENV_ACTIVATE";
+  unset PYENV_ACTIVATE;
+  deactivate;
+else
+  false;
+fi;
+EOS
+}
+
+@test "deactivate virtualenv (with shell activation)" {
+  export PYENV_ACTIVATE="${PYENV_ROOT}/versions/venv"
+  export PYENV_ACTIVATE_SHELL=1
+
+  PYENV_SHELL="bash" run pyenv-sh-deactivate
+
+  assert_success
+  assert_output <<EOS
+if declare -f deactivate 1>/dev/null 2>&1; then
+  pyenv shell --unset;
+  unset PYENV_ACTIVATE_SHELL;
+  export PYENV_DEACTIVATE="$PYENV_ACTIVATE";
+  unset PYENV_ACTIVATE;
+  deactivate;
+else
+  echo "pyenv-virtualenv: no virtualenv has been activated." 1>&2;
+  false;
+fi;
+EOS
+}
+
+@test "deactivate virtualenv (with shell activation) (no-error)" {
+  export PYENV_ACTIVATE="${PYENV_ROOT}/versions/venv"
+  export PYENV_ACTIVATE_SHELL=1
+
+  PYENV_SHELL="bash" run pyenv-sh-deactivate --no-error
+
+  assert_success
+  assert_output <<EOS
+if declare -f deactivate 1>/dev/null 2>&1; then
+  pyenv shell --unset;
+  unset PYENV_ACTIVATE_SHELL;
+  export PYENV_DEACTIVATE="$PYENV_ACTIVATE";
+  unset PYENV_ACTIVATE;
+  deactivate;
+else
+  false;
+fi;
+EOS
+}
+
+@test "deactivate virtualenv which has been activated manually" {
+  export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
+  export PYENV_ACTIVATE=
+  export PYENV_ACTIVATE_SHELL=
+
+  PYENV_SHELL="bash" run pyenv-sh-deactivate
+
+  assert_success
+  assert_output <<EOS
+if declare -f deactivate 1>/dev/null 2>&1; then
+  export PYENV_DEACTIVATE="$VIRTUAL_ENV";
+  unset PYENV_ACTIVATE;
+  deactivate;
+else
+  echo "pyenv-virtualenv: no virtualenv has been activated." 1>&2;
+  false;
+fi;
+EOS
+}
+
+@test "deactivate virtualenv (fish)" {
+  export PYENV_ACTIVATE="${PYENV_ROOT}/versions/venv"
+  export PYENV_ACTIVATE_SHELL=
+
+  PYENV_SHELL="fish" run pyenv-sh-deactivate
+
+  assert_success
+  assert_output <<EOS
+if functions -q deactivate;
+  setenv PYENV_DEACTIVATE "$PYENV_ACTIVATE";
+  set -e PYENV_ACTIVATE;
+  deactivate;
+else;
+  echo "pyenv-virtualenv: no virtualenv has been activated." 1>&2;
+  false;
+end;
+EOS
+}
+
+@test "deactivate virtualenv (fish) (no-error)" {
+  export PYENV_ACTIVATE="${PYENV_ROOT}/versions/venv"
+  export PYENV_ACTIVATE_SHELL=
+
+  PYENV_SHELL="fish" run pyenv-sh-deactivate --no-error
+
+  assert_success
+  assert_output <<EOS
+if functions -q deactivate;
+  setenv PYENV_DEACTIVATE "$PYENV_ACTIVATE";
+  set -e PYENV_ACTIVATE;
+  deactivate;
+else;
+  false;
+end;
+EOS
+}
+
+@test "deactivate virtualenv (fish) (with shell activation)" {
+  export PYENV_ACTIVATE="${PYENV_ROOT}/versions/venv"
+  export PYENV_ACTIVATE_SHELL=1
+
+  PYENV_SHELL="fish" run pyenv-sh-deactivate
+
+  assert_success
+  assert_output <<EOS
+if functions -q deactivate;
+  pyenv shell --unset;
+  set -e PYENV_ACTIVATE_SHELL;
+  setenv PYENV_DEACTIVATE "$PYENV_ACTIVATE";
+  set -e PYENV_ACTIVATE;
+  deactivate;
+else;
+  echo "pyenv-virtualenv: no virtualenv has been activated." 1>&2;
+  false;
+end;
+EOS
+}
+
+@test "deactivate virtualenv (fish) (with shell activation) (no-error)" {
+  export PYENV_ACTIVATE="${PYENV_ROOT}/versions/venv"
+  export PYENV_ACTIVATE_SHELL=1
+
+  PYENV_SHELL="fish" run pyenv-sh-deactivate --no-error
+
+  assert_success
+  assert_output <<EOS
+if functions -q deactivate;
+  pyenv shell --unset;
+  set -e PYENV_ACTIVATE_SHELL;
+  setenv PYENV_DEACTIVATE "$PYENV_ACTIVATE";
+  set -e PYENV_ACTIVATE;
+  deactivate;
+else;
+  false;
+end;
+EOS
+}
+
+@test "deactivate virtualenv which has been activated manually (fish)" {
+  export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
+  export PYENV_ACTIVATE=
+  export PYENV_ACTIVATE_SHELL=
+
+  PYENV_SHELL="fish" run pyenv-sh-deactivate
+
+  assert_success
+  assert_output <<EOS
+if functions -q deactivate;
+  setenv PYENV_DEACTIVATE "$VIRTUAL_ENV";
+  set -e PYENV_ACTIVATE;
+  deactivate;
+else;
+  echo "pyenv-virtualenv: no virtualenv has been activated." 1>&2;
+  false;
+end;
+EOS
+}
+
+@test "should fail if deactivate is invoked as a command" {
+  run pyenv-deactivate
+
+  assert_failure
+}
--- a/test/hooks.bats
+++ b/test/hooks.bats
@@ -0,0 +1,35 @@
+#!/usr/bin/env bats
+
+load test_helper
+
+setup() {
+  export PYENV_ROOT="${TMP}/pyenv"
+  export HOOK_PATH="${TMP}/i has hooks"
+  mkdir -p "$HOOK_PATH"
+}
+
+@test "pyenv-virtualenv hooks" {
+  cat > "${HOOK_PATH}/virtualenv.bash" <<OUT
+before_virtualenv 'echo before: \$VIRTUALENV_PATH'
+after_virtualenv 'echo after: \$STATUS'
+OUT
+  stub pyenv-prefix "echo '${PYENV_ROOT}/versions/3.2.1'"
+  stub pyenv-prefix "echo '${PYENV_ROOT}/versions/3.2.1'"
+  stub pyenv-prefix "echo '${PYENV_ROOT}/versions/3.2.1'"
+  stub pyenv-hooks "virtualenv : echo '$HOOK_PATH'/virtualenv.bash"
+  stub pyenv-exec "echo PYENV_VERSION=3.2.1 \"\$@\""
+  stub pyenv-rehash "echo rehashed"
+
+  create_executable "3.2.1" "virtualenv"
+  remove_executable "3.2.1" "pyvenv"
+
+  run pyenv-virtualenv "3.2.1" venv
+
+  assert_success
+  assert_output <<-OUT
+before: ${PYENV_ROOT}/versions/venv
+PYENV_VERSION=3.2.1 virtualenv ${PYENV_ROOT}/versions/venv
+after: 0
+rehashed
+OUT
+}
--- a/test/init.bats
+++ b/test/init.bats
@@ -0,0 +1,141 @@
+#!/usr/bin/env bats
+
+load test_helper
+
+@test "detect parent shell" {
+  unset PYENV_SHELL
+  SHELL=/bin/false run pyenv-virtualenv-init -
+  assert_success
+  assert_output_contains '  PROMPT_COMMAND="_pyenv_virtualenv_hook;$PROMPT_COMMAND";'
+}
+
+@test "detect parent shell from script (sh)" {
+  unset PYENV_SHELL
+  printf '#!/bin/sh\necho "$(pyenv-virtualenv-init -)"' > "${TMP}/script.sh"
+  chmod +x ${TMP}/script.sh
+  run ${TMP}/script.sh
+  assert_success
+  assert_output_contains_not '  PROMPT_COMMAND="_pyenv_virtualenv_hook;$PROMPT_COMMAND";'
+  rm -f "${TMP}/script.sh"
+}
+
+@test "detect parent shell from script (bash)" {
+  unset PYENV_SHELL
+  printf '#!/bin/bash\necho "$(pyenv-virtualenv-init -)"' > "${TMP}/script.sh"
+  chmod +x ${TMP}/script.sh
+  run ${TMP}/script.sh
+  assert_success
+  assert_output_contains '  PROMPT_COMMAND="_pyenv_virtualenv_hook;$PROMPT_COMMAND";'
+  rm -f "${TMP}/script.sh"
+}
+
+@test "sh-compatible instructions" {
+  run pyenv-virtualenv-init bash
+  assert [ "$status" -eq 1 ]
+  assert_output_contains 'eval "$(pyenv virtualenv-init -)"'
+
+  run pyenv-virtualenv-init zsh
+  assert [ "$status" -eq 1 ]
+  assert_output_contains 'eval "$(pyenv virtualenv-init -)"'
+}
+
+@test "fish instructions" {
+  run pyenv-virtualenv-init fish
+  assert [ "$status" -eq 1 ]
+  assert_output_contains 'status --is-interactive; and . (pyenv virtualenv-init -|psub)'
+}
+
+@test "outputs bash-specific syntax" {
+  run pyenv-virtualenv-init - bash
+  assert_success
+  assert_output <<EOS
+export PYENV_VIRTUALENV_INIT=1;
+_pyenv_virtualenv_hook() {
+  if [ -n "\$PYENV_ACTIVATE" ]; then
+    if [ "\$(pyenv version-name 2>/dev/null || true)" = "system" ]; then
+      eval "\$(pyenv sh-deactivate --no-error --verbose)"
+      unset PYENV_DEACTIVATE
+      return 0
+    fi
+    if [ "\$PYENV_ACTIVATE" != "\$(pyenv prefix 2>/dev/null || true)" ]; then
+      if eval "\$(pyenv sh-deactivate --no-error --verbose)"; then
+        unset PYENV_DEACTIVATE
+        eval "\$(pyenv sh-activate --no-error --verbose)" || unset PYENV_DEACTIVATE
+      else
+        eval "\$(pyenv sh-activate --no-error --verbose)"
+      fi
+    fi
+  else
+    if [ -z "\$VIRTUAL_ENV" ] && [ "\$PYENV_DEACTIVATE" != "\$(pyenv prefix 2>/dev/null || true)" ]; then
+      eval "\$(pyenv sh-activate --no-error --verbose)" || true
+    fi
+  fi
+};
+if ! [[ "\$PROMPT_COMMAND" =~ _pyenv_virtualenv_hook ]]; then
+  PROMPT_COMMAND="_pyenv_virtualenv_hook;\$PROMPT_COMMAND";
+fi
+EOS
+}
+
+@test "outputs fish-specific syntax" {
+  run pyenv-virtualenv-init - fish
+  assert_success
+  assert_output <<EOS
+setenv PYENV_VIRTUALENV_INIT 1;
+function _pyenv_virtualenv_hook --on-event fish_prompt;
+  set -l PYENV_PREFIX (pyenv prefix 2>/dev/null; or true)
+  if [ -n "\$PYENV_ACTIVATE" ]
+    if [ (pyenv version-name 2>/dev/null; or true) = "system" ]
+      pyenv deactivate --no-error --verbose
+      set -e PYENV_DEACTIVATE
+      return 0
+    end
+    if [ "\$PYENV_ACTIVATE" != "\$PYENV_PREFIX" ]
+      if pyenv deactivate --no-error --verbose
+        set -e PYENV_DEACTIVATE
+        pyenv activate --no-error --verbose; or set -e PYENV_DEACTIVATE
+      else
+        pyenv activate --no-error --verbose
+      end
+    end
+  else
+    if [ -z "\$VIRTUAL_ENV" ]; and [ "\$PYENV_DEACTIVATE" != "\$PYENV_PREFIX" ]
+      pyenv activate --no-error --verbose; or true
+    end
+  end
+end
+EOS
+}
+
+@test "outputs zsh-specific syntax" {
+  run pyenv-virtualenv-init - zsh
+  assert_success
+  assert_output <<EOS
+export PYENV_VIRTUALENV_INIT=1;
+_pyenv_virtualenv_hook() {
+  if [ -n "\$PYENV_ACTIVATE" ]; then
+    if [ "\$(pyenv version-name 2>/dev/null || true)" = "system" ]; then
+      eval "\$(pyenv sh-deactivate --no-error --verbose)"
+      unset PYENV_DEACTIVATE
+      return 0
+    fi
+    if [ "\$PYENV_ACTIVATE" != "\$(pyenv prefix 2>/dev/null || true)" ]; then
+      if eval "\$(pyenv sh-deactivate --no-error --verbose)"; then
+        unset PYENV_DEACTIVATE
+        eval "\$(pyenv sh-activate --no-error --verbose)" || unset PYENV_DEACTIVATE
+      else
+        eval "\$(pyenv sh-activate --no-error --verbose)"
+      fi
+    fi
+  else
+    if [ -z "\$VIRTUAL_ENV" ] && [ "\$PYENV_DEACTIVATE" != "\$(pyenv prefix 2>/dev/null || true)" ]; then
+      eval "\$(pyenv sh-activate --no-error --verbose)" || true
+    fi
+  fi
+};
+typeset -g -a precmd_functions
+if [[ -z \$precmd_functions[(r)_pyenv_virtualenv_hook] ]]; then
+  precmd_functions+=_pyenv_virtualenv_hook;
+fi
+EOS
+}
--- a/test/installer.bats
+++ b/test/installer.bats
@@ -0,0 +1,48 @@
+#!/usr/bin/env bats
+
+load test_helper
+
+@test "installs pyenv-virtualenv into PREFIX" {
+  cd "$TMP"
+  PREFIX="${PWD}/usr" run "${BATS_TEST_DIRNAME}/../install.sh"
+  assert_success ""
+
+  cd usr
+
+  assert [ -x bin/pyenv-activate ]
+  assert [ -x bin/pyenv-deactivate ]
+  assert [ -x bin/pyenv-sh-activate ]
+  assert [ -x bin/pyenv-sh-deactivate ]
+  assert [ -x bin/pyenv-virtualenv ]
+  assert [ -x bin/pyenv-virtualenv-init ]
+  assert [ -x bin/pyenv-virtualenv-prefix ]
+  assert [ -x bin/pyenv-virtualenvs ]
+}
+
+@test "overwrites old installation" {
+  cd "$TMP"
+  mkdir -p bin
+  touch bin/pyenv-virtualenv
+
+  PREFIX="$PWD" run "${BATS_TEST_DIRNAME}/../install.sh"
+  assert_success ""
+
+  assert [ -x bin/pyenv-virtualenv ]
+  run grep "virtualenv" bin/pyenv-virtualenv
+  assert_success
+}
+
+@test "unrelated files are untouched" {
+  cd "$TMP"
+  mkdir -p bin share/bananas
+  chmod g-w bin
+  touch bin/bananas
+
+  PREFIX="$PWD" run "${BATS_TEST_DIRNAME}/../install.sh"
+  assert_success ""
+
+  assert [ -e bin/bananas ]
+
+  run ls -ld bin
+  assert_equal "r-x" "${output:4:3}"
+}
--- a/test/pip.bats
+++ b/test/pip.bats
@@ -0,0 +1,74 @@
+#!/usr/bin/env bats
+
+load test_helper
+
+setup() {
+  export PYENV_ROOT="${TMP}/pyenv"
+}
+
+stub_pyenv() {
+  stub pyenv-version-name "echo \${PYENV_VERSION}"
+  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
+  stub pyenv-hooks "virtualenv : echo"
+  stub pyenv-rehash " : echo rehashed"
+}
+
+unstub_pyenv() {
+  unstub pyenv-version-name
+  unstub pyenv-prefix
+  unstub pyenv-hooks
+  unstub pyenv-rehash
+}
+
+@test "install pip with ensurepip" {
+  export PYENV_VERSION="3.4.1"
+  stub_pyenv "${PYENV_VERSION}"
+  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
+  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
+  stub pyenv-exec "pyvenv ${PYENV_ROOT}/versions/venv : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\";mkdir -p \${PYENV_ROOT}/versions/venv/bin"
+  stub pyenv-exec "python -s -m ensurepip : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\";touch \${PYENV_ROOT}/versions/venv/bin/pip"
+
+  remove_executable "3.4.1" "virtualenv"
+  create_executable "3.4.1" "pyvenv"
+
+  run pyenv-virtualenv venv
+
+  assert_success
+  assert_output <<OUT
+PYENV_VERSION=3.4.1 pyvenv ${PYENV_ROOT}/versions/venv
+PYENV_VERSION=venv python -s -m ensurepip
+rehashed
+OUT
+  assert [ -e "${PYENV_ROOT}/versions/venv/bin/pip" ]
+
+  unstub_pyenv
+  unstub pyenv-exec
+}
+
+@test "install pip without using ensurepip" {
+  export PYENV_VERSION="3.3.5"
+  stub_pyenv "${PYENV_VERSION}"
+  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
+  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
+  stub pyenv-exec "pyvenv ${PYENV_ROOT}/versions/venv : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\";mkdir -p \${PYENV_ROOT}/versions/venv/bin"
+  stub pyenv-exec "python -s -m ensurepip : false"
+  stub pyenv-exec "python -s */get-pip.py : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\";touch \${PYENV_ROOT}/versions/venv/bin/pip"
+  stub curl true
+
+  remove_executable "3.3.5" "virtualenv"
+  create_executable "3.3.5" "pyvenv"
+
+  run pyenv-virtualenv venv
+
+  assert_success
+  assert_output <<OUT
+PYENV_VERSION=3.3.5 pyvenv ${PYENV_ROOT}/versions/venv
+Installing pip from https://bootstrap.pypa.io/get-pip.py...
+PYENV_VERSION=venv python -s ${TMP}/pyenv/cache/get-pip.py
+rehashed
+OUT
+  assert [ -e "${PYENV_ROOT}/versions/venv/bin/pip" ]
+
+  unstub_pyenv
+  unstub pyenv-exec
+}
--- a/test/python.bats
+++ b/test/python.bats
@@ -0,0 +1,101 @@
+#!/usr/bin/env bats
+
+load test_helper
+
+setup() {
+  export PYENV_ROOT="${TMP}/pyenv"
+  export PYENV_VERSION="2.7.8"
+  create_executable "${PYENV_VERSION}" "virtualenv"
+  remove_executable "${PYENV_VERSION}" "pyvenv"
+  stub pyenv-prefix "echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
+  stub pyenv-prefix "echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
+  stub pyenv-prefix "echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
+  stub pyenv-hooks "virtualenv : echo"
+  stub pyenv-rehash " : true"
+  stub pyenv-version-name "echo \${PYENV_VERSION}"
+  stub curl true
+}
+
+teardown() {
+  unstub curl
+  unstub pyenv-version-name
+  unstub pyenv-prefix
+  unstub pyenv-hooks
+  unstub pyenv-rehash
+  rm -fr "$TMP"/*
+}
+
+@test "resolve python executable from enabled version" {
+  remove_executable "2.7.7" "python2.7"
+  create_executable "2.7.8" "python2.7"
+  remove_executable "2.7.9" "python2.7"
+
+  stub pyenv-exec "virtualenv --verbose --python=${PYENV_ROOT}/versions/2.7.8/bin/python2.7 ${PYENV_ROOT}/versions/venv : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
+  stub pyenv-exec "python -s -m ensurepip : true"
+  stub pyenv-which "python2.7 : echo ${PYENV_ROOT}/versions/2.7.8/bin/python2.7"
+
+  run pyenv-virtualenv --verbose --python=python2.7 venv
+
+  assert_output <<OUT
+PYENV_VERSION=2.7.8 virtualenv --verbose --python=${PYENV_ROOT}/versions/2.7.8/bin/python2.7 ${PYENV_ROOT}/versions/venv
+OUT
+  assert_success
+
+  unstub pyenv-which
+  unstub pyenv-exec
+
+  remove_executable "2.7.7" "python2.7"
+  remove_executable "2.7.8" "python2.7"
+  remove_executable "2.7.9" "python2.7"
+}
+
+@test "resolve python executable from other versions" {
+  remove_executable "2.7.7" "python2.7"
+  remove_executable "2.7.8" "python2.7"
+  create_executable "2.7.9" "python2.7"
+
+  stub pyenv-exec "virtualenv --verbose --python=${PYENV_ROOT}/versions/2.7.9/bin/python2.7 ${PYENV_ROOT}/versions/venv : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
+  stub pyenv-exec "python -s -m ensurepip : true"
+  stub pyenv-which "python2.7 : false"
+  stub pyenv-whence "python2.7 : echo 2.7.7; echo 2.7.8; echo 2.7.9"
+  stub pyenv-which "python2.7 : echo ${PYENV_ROOT}/versions/2.7.9/bin/python2.7"
+
+  run pyenv-virtualenv --verbose --python=python2.7 venv
+
+  assert_output <<OUT
+PYENV_VERSION=2.7.8 virtualenv --verbose --python=${PYENV_ROOT}/versions/2.7.9/bin/python2.7 ${PYENV_ROOT}/versions/venv
+OUT
+  assert_success
+
+  unstub pyenv-which
+  unstub pyenv-whence
+  unstub pyenv-exec
+
+  remove_executable "2.7.7" "python2.7"
+  remove_executable "2.7.8" "python2.7"
+  remove_executable "2.7.9" "python2.7"
+}
+
+@test "cannot resolve python executable" {
+  remove_executable "2.7.7" "python2.7"
+  remove_executable "2.7.8" "python2.7"
+  remove_executable "2.7.9" "python2.7"
+
+  stub pyenv-which "python2.7 : false"
+  stub pyenv-whence "python2.7 : false"
+  stub pyenv-which "python2.7 : false"
+
+  run pyenv-virtualenv --verbose --python=python2.7 venv
+
+  assert_output <<OUT
+pyenv-virtualenv: \`python2.7' is not installed in pyenv.
+OUT
+  assert_failure
+
+  unstub pyenv-which
+  unstub pyenv-whence
+
+  remove_executable "2.7.7" "python2.7"
+  remove_executable "2.7.8" "python2.7"
+  remove_executable "2.7.9" "python2.7"
+}
--- a/test/pyvenv.bats
+++ b/test/pyvenv.bats
@@ -0,0 +1,175 @@
+#!/usr/bin/env bats
+
+load test_helper
+
+setup() {
+  export PYENV_ROOT="${TMP}/pyenv"
+}
+
+stub_pyenv() {
+  stub pyenv-version-name "echo \${PYENV_VERSION}"
+  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
+  stub pyenv-hooks "virtualenv : echo"
+  stub pyenv-rehash " : echo rehashed"
+}
+
+unstub_pyenv() {
+  unstub pyenv-version-name
+  unstub pyenv-prefix
+  unstub pyenv-hooks
+  unstub pyenv-rehash
+}
+
+@test "use pyvenv if virtualenv is not available" {
+  export PYENV_VERSION="3.4.1"
+  stub_pyenv "${PYENV_VERSION}"
+  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
+  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
+  stub pyenv-exec "pyvenv ${PYENV_ROOT}/versions/venv : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
+  stub pyenv-exec "python -s -m ensurepip : true"
+
+  remove_executable "3.4.1" "virtualenv"
+  create_executable "3.4.1" "pyvenv"
+
+  run pyenv-virtualenv venv
+
+  assert_success
+  assert_output <<OUT
+PYENV_VERSION=3.4.1 pyvenv ${PYENV_ROOT}/versions/venv
+rehashed
+OUT
+
+  unstub_pyenv
+  unstub pyenv-exec
+}
+
+@test "not use pyvenv if virtualenv is available" {
+  export PYENV_VERSION="3.4.1"
+  stub_pyenv "${PYENV_VERSION}"
+  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
+  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
+  stub pyenv-exec "virtualenv ${PYENV_ROOT}/versions/venv : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
+  stub pyenv-exec "python -s -m ensurepip : true"
+
+  create_executable "3.4.1" "virtualenv"
+  create_executable "3.4.1" "pyvenv"
+
+  run pyenv-virtualenv venv
+
+  assert_success
+  assert_output <<OUT
+PYENV_VERSION=3.4.1 virtualenv ${PYENV_ROOT}/versions/venv
+rehashed
+OUT
+
+  unstub_pyenv
+  unstub pyenv-exec
+}
+
+@test "install virtualenv if pyvenv is not avaialble" {
+  export PYENV_VERSION="3.2.1"
+  stub_pyenv "${PYENV_VERSION}"
+  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
+  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
+  stub pyenv-exec "pip install virtualenv : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
+  stub pyenv-exec "virtualenv ${PYENV_ROOT}/versions/venv : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
+  stub pyenv-exec "python -s -m ensurepip : false"
+  stub pyenv-exec "python -s */get-pip.py : true"
+  stub curl true
+
+  remove_executable "3.2.1" "virtualenv"
+  remove_executable "3.2.1" "pyvenv"
+
+  run pyenv-virtualenv venv
+
+  assert_success
+  assert_output <<OUT
+PYENV_VERSION=3.2.1 pip install virtualenv
+PYENV_VERSION=3.2.1 virtualenv ${PYENV_ROOT}/versions/venv
+Installing pip from https://bootstrap.pypa.io/get-pip.py...
+rehashed
+OUT
+
+  unstub_pyenv
+  unstub pyenv-exec
+  unstub curl
+}
+
+@test "install virtualenv if -p has given" {
+  export PYENV_VERSION="3.4.1"
+  stub_pyenv "${PYENV_VERSION}"
+  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
+  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
+  stub pyenv-exec "pip install virtualenv : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
+  stub pyenv-exec "virtualenv --python=${TMP}/python3 ${PYENV_ROOT}/versions/venv : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
+  stub pyenv-exec "python -s -m ensurepip : true"
+
+  remove_executable "3.4.1" "virtualenv"
+  create_executable "3.4.1" "pyvenv"
+
+  run pyenv-virtualenv -p ${TMP}/python3 venv
+
+  assert_output <<OUT
+PYENV_VERSION=3.4.1 pip install virtualenv
+PYENV_VERSION=3.4.1 virtualenv --python=${TMP}/python3 ${PYENV_ROOT}/versions/venv
+rehashed
+OUT
+  assert_success
+
+  unstub_pyenv
+  unstub pyenv-exec
+}
+
+@test "install virtualenv if --python has given" {
+  export PYENV_VERSION="3.4.1"
+  stub_pyenv "${PYENV_VERSION}"
+  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
+  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
+  stub pyenv-exec "pip install virtualenv : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
+  stub pyenv-exec "virtualenv --python=${TMP}/python3 ${PYENV_ROOT}/versions/venv : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
+  stub pyenv-exec "python -s -m ensurepip : true"
+
+  remove_executable "3.4.1" "virtualenv"
+  create_executable "3.4.1" "pyvenv"
+
+  run pyenv-virtualenv --python=${TMP}/python3 venv
+
+  assert_output <<OUT
+PYENV_VERSION=3.4.1 pip install virtualenv
+PYENV_VERSION=3.4.1 virtualenv --python=${TMP}/python3 ${PYENV_ROOT}/versions/venv
+rehashed
+OUT
+  assert_success
+
+  unstub_pyenv
+  unstub pyenv-exec
+}
+
+@test "install virtualenv with unsetting troublesome pip options" {
+  export PYENV_VERSION="3.2.1"
+  stub_pyenv "${PYENV_VERSION}"
+  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
+  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
+  stub pyenv-exec "pip install virtualenv : echo PIP_REQUIRE_VENV=\${PIP_REQUIRE_VENV} PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
+  stub pyenv-exec "virtualenv ${PYENV_ROOT}/versions/venv : echo PIP_REQUIRE_VENV=\${PIP_REQUIRE_VENV} PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
+  stub pyenv-exec "python -s -m ensurepip : false"
+  stub pyenv-exec "python -s */get-pip.py : true"
+  stub curl true
+
+  remove_executable "3.2.1" "virtualenv"
+  remove_executable "3.2.1" "pyvenv"
+
+  PIP_REQUIRE_VENV="true" run pyenv-virtualenv venv
+
+  assert_success
+  assert_output <<OUT
+PIP_REQUIRE_VENV= PYENV_VERSION=3.2.1 pip install virtualenv
+PIP_REQUIRE_VENV= PYENV_VERSION=3.2.1 virtualenv ${PYENV_ROOT}/versions/venv
+Installing pip from https://bootstrap.pypa.io/get-pip.py...
+rehashed
+OUT
+
+  unstub_pyenv
+  unstub pyenv-exec
+  unstub curl
+}
--- a/test/stubs/stub
+++ b/test/stubs/stub
@@ -0,0 +1,109 @@
+#!/usr/bin/env bash
+set -e
+
+status=0
+program="${0##*/}"
+PROGRAM="$(echo "$program" | tr a-z- A-Z_)"
+[ -n "$TMPDIR" ] || TMPDIR="/tmp"
+
+_STUB_PLAN="${PROGRAM}_STUB_PLAN"
+_STUB_RUN="${PROGRAM}_STUB_RUN"
+_STUB_INDEX="${PROGRAM}_STUB_INDEX"
+_STUB_RESULT="${PROGRAM}_STUB_RESULT"
+_STUB_END="${PROGRAM}_STUB_END"
+_STUB_DEBUG="${PROGRAM}_STUB_DEBUG"
+
+if [ -n "${!_STUB_DEBUG}" ]; then
+  echo "$program" "$@" >&${!_STUB_DEBUG}
+fi
+
+[ -e "${!_STUB_PLAN}" ] || exit 1
+[ -n "${!_STUB_RUN}" ] || eval "${_STUB_RUN}"="${TMPDIR}/${program}-stub-run"
+
+
+# Initialize or load the stub run information.
+eval "${_STUB_INDEX}"=1
+eval "${_STUB_RESULT}"=0
+[ ! -e "${!_STUB_RUN}" ] || source "${!_STUB_RUN}"
+
+
+# Loop over each line in the plan.
+index=0
+while IFS= read -r line; do
+  index=$(($index + 1))
+
+  if [ -z "${!_STUB_END}" ] && [ $index -eq "${!_STUB_INDEX}" ]; then
+    # We found the plan line we're interested in.
+    # Start off by assuming success.
+    result=0
+
+    # Split the line into an array of arguments to
+    # match and a command to run to produce output.
+    command=" $line"
+    if [ "$command" != "${command/ : }" ]; then
+      patterns="${command%% : *}"
+      command="${command#* : }"
+    fi
+
+    # Naively split patterns by whitespace for now.
+    # In the future, use a sed script to split while
+    # respecting quoting.
+    set -f
+    patterns=($patterns)
+    set +f
+    arguments=("$@")
+
+    # Match the expected argument patterns to actual
+    # arguments.
+    for (( i=0; i<${#patterns[@]}; i++ )); do
+      pattern="${patterns[$i]}"
+      argument="${arguments[$i]}"
+
+      case "$argument" in
+        $pattern ) ;;
+        * ) result=1 ;;
+      esac
+    done
+
+    # If the arguments matched, evaluate the command
+    # in a subshell. Otherwise, log the failure.
+    if [ $result -eq 0 ] ; then
+      set +e
+      ( eval "$command" )
+      status="$?"
+      set -e
+    else
+      eval "${_STUB_RESULT}"=1
+    fi
+  fi
+done < "${!_STUB_PLAN}"
+
+
+if [ -n "${!_STUB_END}" ]; then
+  # Clean up the run file.
+  rm -f "${!_STUB_RUN}"
+
+  # If the number of lines in the plan is larger than
+  # the requested index, we failed.
+  if [ $index -ge "${!_STUB_INDEX}" ]; then
+    eval "${_STUB_RESULT}"=1
+  fi
+
+  # Return the result.
+  exit "${!_STUB_RESULT}"
+
+else
+  # If the requested index is larger than the number
+  # of lines in the plan file, we failed.
+  if [ "${!_STUB_INDEX}" -gt $index ]; then
+    eval "${_STUB_RESULT}"=1
+  fi
+
+  # Write out the run information.
+  { echo "${_STUB_INDEX}=$((${!_STUB_INDEX} + 1))"
+    echo "${_STUB_RESULT}=${!_STUB_RESULT}"
+  } > "${!_STUB_RUN}"
+
+  exit "$status"
+
+fi
--- a/test/test_helper.bash
+++ b/test/test_helper.bash
@@ -0,0 +1,134 @@
+export TMP="$BATS_TEST_DIRNAME/tmp"
+
+PATH=/usr/bin:/usr/sbin:/bin/:/sbin
+PATH="$BATS_TEST_DIRNAME/../bin:$PATH"
+PATH="$TMP/bin:$PATH"
+export PATH
+
+teardown() {
+  rm -fr "$TMP"/*
+}
+
+stub() {
+  local program="$1"
+  local prefix="$(echo "$program" | tr a-z- A-Z_)"
+  shift
+
+  export "${prefix}_STUB_PLAN"="${TMP}/${program}-stub-plan"
+  export "${prefix}_STUB_RUN"="${TMP}/${program}-stub-run"
+  export "${prefix}_STUB_END"=
+
+  mkdir -p "${TMP}/bin"
+  ln -sf "${BATS_TEST_DIRNAME}/stubs/stub" "${TMP}/bin/${program}"
+
+  touch "${TMP}/${program}-stub-plan"
+  for arg in "$@"; do printf "%s\n" "$arg" >> "${TMP}/${program}-stub-plan"; done
+}
+
+unstub() {
+  local program="$1"
+  local prefix="$(echo "$program" | tr a-z- A-Z_)"
+  local path="${TMP}/bin/${program}"
+
+  export "${prefix}_STUB_END"=1
+
+  local STATUS=0
+  "$path" || STATUS="$?"
+
+  rm -f "$path"
+  rm -f "${TMP}/${program}-stub-plan" "${TMP}/${program}-stub-run"
+  return "$STATUS"
+}
+
+assert() {
+  if ! "$@"; then
+    flunk "failed: $@"
+  fi
+}
+
+flunk() {
+  { if [ "$#" -eq 0 ]; then cat -
+    else echo "$@"
+    fi
+  } | sed "s:${TMP}:\${TMP}:g" >&2
+  return 1
+}
+
+assert_success() {
+  if [ "$status" -ne 0 ]; then
+    { echo "command failed with exit status $status"
+      echo "output: $output"
+    } | flunk
+  elif [ "$#" -gt 0 ]; then
+    assert_output "$1"
+  fi
+}
+
+assert_failure() {
+  if [ "$status" -eq 0 ]; then
+    flunk "expected failed exit status"
+  elif [ "$#" -gt 0 ]; then
+    assert_output "$1"
+  fi
+}
+
+assert_equal() {
+  if [ "$1" != "$2" ]; then
+    { echo "expected: $1"
+      echo "actual:   $2"
+    } | flunk
+  fi
+}
+
+assert_output() {
+  local expected
+  if [ $# -eq 0 ]; then expected="$(cat -)"
+  else expected="$1"
+  fi
+  assert_equal "$expected" "$output"
+}
+
+assert_output_contains() {
+  local expected="$1"
+  echo "$output" | grep -F "$expected" >/dev/null || {
+    { echo "expected output to contain $expected"
+      echo "actual: $output"
+    } | flunk
+  }
+}
+
+assert_output_contains_not() {
+  local expected="$1"
+  echo "$output" | grep -F "$expected" >/dev/null && {
+    { echo "expected output to not contain $expected"
+      echo "actual: $output"
+    } | flunk; return
+  }
+  return 0
+}
+
+create_executable() {
+  mkdir -p "${PYENV_ROOT}/versions/$1/bin"
+  touch "${PYENV_ROOT}/versions/$1/bin/$2"
+  chmod +x "${PYENV_ROOT}/versions/$1/bin/$2"
+}
+
+remove_executable() {
+  rm -f "${PYENV_ROOT}/versions/$1/bin/$2"
+}
+
+create_conda() {
+  local version="$1"
+  shift 1
+  mkdir -p "${PYENV_ROOT}/versions/$version/bin"
+  touch "${PYENV_ROOT}/versions/$version/bin/activate"
+  touch "${PYENV_ROOT}/versions/$version/bin/conda"
+  chmod +x "${PYENV_ROOT}/versions/$version/bin/conda"
+  local conda_env
+  for conda_env; do
+    mkdir -p "${PYENV_ROOT}/versions/$version/envs/$conda_env/bin"
+    touch "${PYENV_ROOT}/versions/$version/envs/$conda_env/bin/activate"
+    touch "${PYENV_ROOT}/versions/$version/envs/$conda_env/bin/conda"
+    chmod +x "${PYENV_ROOT}/versions/$version/envs/$conda_env/bin/conda"
+  done
+}
--- a/test/tmp/.gitignore
+++ b/test/tmp/.gitignore
@@ -0,0 +1 @@
+*
--- a/test/version.bats
+++ b/test/version.bats
@@ -0,0 +1,43 @@
+#!/usr/bin/env bats
+
+load test_helper
+
+setup() {
+  export PYENV_ROOT="${TMP}/pyenv"
+  export PYENV_VIRTUALENV_VERSION="20151006"
+}
+
+@test "display virtualenv version" {
+  stub pyenv-prefix "echo '${PYENV_ROOT}/versions/2.7.7'"
+  stub pyenv-prefix "echo '${PYENV_ROOT}/versions/2.7.7'"
+  stub pyenv-exec "virtualenv --version : echo \"1.11\""
+
+  create_executable "2.7.7" "virtualenv"
+  remove_executable "2.7.7" "pyvenv"
+
+  run pyenv-virtualenv --version
+
+  assert_success
+  assert_output "pyenv-virtualenv ${PYENV_VIRTUALENV_VERSION} (virtualenv 1.11)"
+
+  unstub pyenv-prefix
+  unstub pyenv-exec
+}
+
+@test "display pyvenv version" {
+  stub pyenv-prefix "echo '${PYENV_ROOT}/versions/3.4.1'"
+  stub pyenv-prefix "echo '${PYENV_ROOT}/versions/3.4.1'"
+  stub pyenv-which "pyvenv : echo \"${PYENV_ROOT}/versions/3.4.1/bin/pyvenv\""
+  stub pyenv-root "echo \"${PYENV_ROOT}\""
+
+  remove_executable "3.4.1" "virtualenv"
+  create_executable "3.4.1" "pyvenv"
+
+  run pyenv-virtualenv --version
+
+  assert_success
+  assert_output "pyenv-virtualenv ${PYENV_VIRTUALENV_VERSION} (pyvenv 3.4.1)"
+
+  unstub pyenv-prefix
+  unstub pyenv-root
+}
--- a/test/virtualenv-prefix.bats
+++ b/test/virtualenv-prefix.bats
@@ -0,0 +1,158 @@
+#!/usr/bin/env bats
+
+load test_helper
+
+setup() {
+  export PYENV_ROOT="${TMP}/pyenv"
+}
+
+create_virtualenv() {
+  mkdir -p "${PYENV_ROOT}/versions/$1/bin"
+  touch "${PYENV_ROOT}/versions/$1/bin/activate"
+}
+
+remove_virtualenv() {
+  rm -fr "${PYENV_ROOT}/versions/$1"
+}
+
+@test "display prefix with using sys.real_prefix" {
+  stub pyenv-version-name "echo venv27"
+  stub pyenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/venv27\""
+  stub pyenv-exec "echo \"${PYENV_ROOT}/versions/2.7.6\""
+  create_virtualenv "venv27"
+
+  PYENV_VERSION="venv27" run pyenv-virtualenv-prefix
+
+  unstub pyenv-version-name
+  unstub pyenv-prefix
+  unstub pyenv-exec
+  remove_virtualenv "venv27"
+
+  assert_success
+  assert_output <<OUT
+${PYENV_ROOT}/versions/2.7.6
+OUT
+}
+
+@test "display prefixes with using sys.real_prefix" {
+  stub pyenv-version-name "echo venv27:venv32"
+  stub pyenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/venv27\"" \
+                    "venv32 : echo \"${PYENV_ROOT}/versions/venv32\""
+  stub pyenv-exec "echo \"${PYENV_ROOT}/versions/2.7.6\"" \
+                  "echo \"${PYENV_ROOT}/versions/3.2.1\""
+  create_virtualenv "venv27"
+  create_virtualenv "venv32"
+
+  PYENV_VERSION="venv27:venv32" run pyenv-virtualenv-prefix
+
+  unstub pyenv-version-name
+  unstub pyenv-prefix
+  unstub pyenv-exec
+  remove_virtualenv "venv27"
+  remove_virtualenv "venv32"
+
+  assert_success
+  assert_output <<OUT
+${PYENV_ROOT}/versions/2.7.6:${PYENV_ROOT}/versions/3.2.1
+OUT
+}
+
+@test "display prefix with using sys.base_prefix" {
+  stub pyenv-version-name "echo venv33"
+  stub pyenv-prefix "venv33 : echo \"${PYENV_ROOT}/versions/venv33\""
+  stub pyenv-exec "false" \
+                  "echo \"${PYENV_ROOT}/versions/3.3.3\""
+  create_virtualenv "venv33"
+
+  PYENV_VERSION="venv33" run pyenv-virtualenv-prefix
+
+  unstub pyenv-version-name
+  unstub pyenv-prefix
+  unstub pyenv-exec
+  remove_virtualenv "venv33"
+
+  assert_success
+  assert_output <<OUT
+${PYENV_ROOT}/versions/3.3.3
+OUT
+}
+
+@test "display prefixes with using sys.base_prefix" {
+  stub pyenv-version-name "echo venv33:venv34"
+  stub pyenv-prefix "venv33 : echo \"${PYENV_ROOT}/versions/venv33\"" \
+                    "venv34 : echo \"${PYENV_ROOT}/versions/venv34\""
+  stub pyenv-exec "false" \
+                  "echo \"${PYENV_ROOT}/versions/3.3.3\"" \
+                  "false" \
+                  "echo \"${PYENV_ROOT}/versions/3.4.0\""
+  create_virtualenv "venv33"
+  create_virtualenv "venv34"
+
+  PYENV_VERSION="venv33:venv34" run pyenv-virtualenv-prefix
+
+  unstub pyenv-version-name
+  unstub pyenv-prefix
+  unstub pyenv-exec
+  remove_virtualenv "venv33"
+  remove_virtualenv "venv34"
+
+  assert_success
+  assert_output <<OUT
+${PYENV_ROOT}/versions/3.3.3:${PYENV_ROOT}/versions/3.4.0
+OUT
+}
+
+@test "should fail if the version is the system" {
+  stub pyenv-version-name "echo system"
+
+  PYENV_VERSION="system" run pyenv-virtualenv-prefix
+
+  unstub pyenv-version-name
+
+  assert_failure
+  assert_output <<OUT
+pyenv-virtualenv: version \`system' is not a virtualenv
+OUT
+}
+
+@test "should fail if the version is not a virtualenv" {
+  stub pyenv-version-name "echo 3.4.0"
+  stub pyenv-prefix "3.4.0 : echo \"${PYENV_ROOT}/versions/3.4.0\""
+  mkdir -p "${PYENV_ROOT}/versions/3.4.0"
+
+  PYENV_VERSION="3.4.0" run pyenv-virtualenv-prefix
+
+  unstub pyenv-version-name
+  unstub pyenv-prefix
+  rmdir "${PYENV_ROOT}/versions/3.4.0"
+
+  assert_failure
+  assert_output <<OUT
+pyenv-virtualenv: version \`3.4.0' is not a virtualenv
+OUT
+}
+
+@test "should fail if one of the versions is not a virtualenv" {
+  stub pyenv-version-name "echo venv33:3.4.0"
+  stub pyenv-prefix "venv33 : echo \"${PYENV_ROOT}/versions/venv33\"" \
+                    "3.4.0 : echo \"${PYENV_ROOT}/versions/3.4.0\""
+  stub pyenv-exec "false" \
+                  "echo \"${PYENV_ROOT}/versions/3.3.3\""
+  create_virtualenv "venv33"
+  mkdir -p "${PYENV_ROOT}/versions/3.4.0"
+
+  PYENV_VERSION="venv33:3.4.0" run pyenv-virtualenv-prefix
+
+  unstub pyenv-version-name
+  unstub pyenv-prefix
+  unstub pyenv-exec
+  remove_virtualenv "venv33"
+  rmdir "${PYENV_ROOT}/versions/3.4.0"
+
+  assert_failure
+  assert_output <<OUT
+pyenv-virtualenv: version \`3.4.0' is not a virtualenv
+OUT
+}
+
+
--- a/test/virtualenv.bats
+++ b/test/virtualenv.bats
@@ -0,0 +1,136 @@
+#!/usr/bin/env bats
+
+load test_helper
+
+setup() {
+  export PYENV_ROOT="${TMP}/pyenv"
+}
+
+stub_pyenv() {
+  create_executable "${PYENV_VERSION}" "virtualenv"
+  remove_executable "${PYENV_VERSION}" "pyvenv"
+
+  stub pyenv-prefix "echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
+  stub pyenv-prefix "echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
+  stub pyenv-prefix "echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
+  stub pyenv-hooks "virtualenv : echo"
+  stub pyenv-rehash " : echo rehashed"
+}
+
+unstub_pyenv() {
+  unstub pyenv-prefix
+  unstub pyenv-hooks
+  unstub pyenv-rehash
+}
+
+@test "create virtualenv from given version" {
+  export PYENV_VERSION="3.2.1"
+  stub_pyenv "${PYENV_VERSION}"
+  stub pyenv-exec "virtualenv ${PYENV_ROOT}/versions/venv : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
+  stub pyenv-exec "python -s -m ensurepip : false"
+  stub pyenv-exec "python -s */get-pip.py : true"
+  stub curl true
+
+  run pyenv-virtualenv "3.2.1" "venv"
+
+  assert_success
+  assert_output <<OUT
+PYENV_VERSION=3.2.1 virtualenv ${PYENV_ROOT}/versions/venv
+Installing pip from https://bootstrap.pypa.io/get-pip.py...
+rehashed
+OUT
+
+  unstub_pyenv
+  unstub pyenv-exec
+  unstub curl
+}
+
+@test "create virtualenv from current version" {
+  export PYENV_VERSION="3.2.1"
+  stub_pyenv "${PYENV_VERSION}"
+  stub pyenv-version-name "echo \${PYENV_VERSION}"
+  stub pyenv-exec "virtualenv ${PYENV_ROOT}/versions/venv : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
+  stub pyenv-exec "python -s -m ensurepip : false"
+  stub pyenv-exec "python -s */get-pip.py : true"
+  stub curl true
+
+  run pyenv-virtualenv venv
+
+  assert_success
+  assert_output <<OUT
+PYENV_VERSION=3.2.1 virtualenv ${PYENV_ROOT}/versions/venv
+Installing pip from https://bootstrap.pypa.io/get-pip.py...
+rehashed
+OUT
+
+  unstub_pyenv
+  unstub pyenv-version-name
+  unstub pyenv-exec
+  unstub curl
+}
+
+@test "create virtualenv with short options" {
+  export PYENV_VERSION="3.2.1"
+  stub_pyenv "${PYENV_VERSION}"
+  stub pyenv-version-name "echo \${PYENV_VERSION}"
+  stub pyenv-exec "virtualenv --verbose --python=${TMP}/python ${PYENV_ROOT}/versions/venv : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
+  stub pyenv-exec "python -s -m ensurepip : false"
+  stub pyenv-exec "python -s */get-pip.py : true"
+  stub curl true
+
+  run pyenv-virtualenv -v -p ${TMP}/python venv
+
+  assert_output <<OUT
+PYENV_VERSION=3.2.1 virtualenv --verbose --python=${TMP}/python ${PYENV_ROOT}/versions/venv
+Installing pip from https://bootstrap.pypa.io/get-pip.py...
+rehashed
+OUT
+  assert_success
+
+  unstub_pyenv
+  unstub pyenv-version-name
+  unstub pyenv-exec
+  unstub curl
+}
+
+@test "create virtualenv with long options" {
+  export PYENV_VERSION="3.2.1"
+  stub_pyenv "${PYENV_VERSION}"
+  stub pyenv-version-name "echo \${PYENV_VERSION}"
+  stub pyenv-exec "virtualenv --verbose --python=${TMP}/python ${PYENV_ROOT}/versions/venv : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
+  stub pyenv-exec "python -s -m ensurepip : false"
+  stub pyenv-exec "python -s */get-pip.py : true"
+  stub curl true
+
+  run pyenv-virtualenv --verbose --python=${TMP}/python venv
+
+  assert_output <<OUT
+PYENV_VERSION=3.2.1 virtualenv --verbose --python=${TMP}/python ${PYENV_ROOT}/versions/venv
+Installing pip from https://bootstrap.pypa.io/get-pip.py...
+rehashed
+OUT
+  assert_success
+
+  unstub_pyenv
+  unstub pyenv-version-name
+  unstub pyenv-exec
+  unstub curl
+}
+
+@test "no whitespace allowed in virtualenv name" {
+  run pyenv-virtualenv "3.2.1" "foo bar"
+
+  assert_failure
+  assert_output <<OUT
+pyenv-virtualenv: no whitespace allowed in virtualenv name.
+OUT
+}
+
+@test "no tab allowed in virtualenv name" {
+  run pyenv-virtualenv "3.2.1" "foo	bar baz"
+
+  assert_failure
+  assert_output <<OUT
+pyenv-virtualenv: no whitespace allowed in virtualenv name.
+OUT
+}
--- a/test/virtualenvs.bats
+++ b/test/virtualenvs.bats
@@ -0,0 +1,77 @@
+#!/usr/bin/env bats
+
+load test_helper
+
+setup() {
+  export PYENV_ROOT="${TMP}/pyenv"
+  mkdir -p "${PYENV_ROOT}/versions/2.7.6"
+  mkdir -p "${PYENV_ROOT}/versions/3.3.3"
+  mkdir -p "${PYENV_ROOT}/versions/venv27"
+  mkdir -p "${PYENV_ROOT}/versions/venv33"
+}
+
+@test "list virtual environments only" {
+  stub pyenv-version-name ": echo system"
+  stub pyenv-versions "--bare : echo \"system\";echo \"2.7.6\";echo \"3.3.3\";echo \"venv27\";echo \"venv33\""
+  stub pyenv-virtualenv-prefix "2.7.6 : false"
+  stub pyenv-virtualenv-prefix "3.3.3 : false"
+  stub pyenv-virtualenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/2.7.6\""
+  stub pyenv-virtualenv-prefix "venv33 : echo \"${PYENV_ROOT}/versions/3.3.3\""
+  stub pyenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/2.7.6\""
+  stub pyenv-prefix "venv33 : echo \"${PYENV_ROOT}/versions/3.3.3\""
+
+  run pyenv-virtualenvs
+
+  unstub pyenv-version-name
+  unstub pyenv-versions
+  unstub pyenv-virtualenv-prefix
+  unstub pyenv-prefix
+
+  assert_success
+  assert_output <<OUT
+  venv27 (created from ${PYENV_ROOT}/versions/2.7.6)
+  venv33 (created from ${PYENV_ROOT}/versions/3.3.3)
+OUT
+}
+
+@test "list virtual environments with hit prefix" {
+  stub pyenv-version-name ": echo venv33"
+  stub pyenv-versions "--bare : echo \"system\";echo \"venv27\";echo \"venv33\""
+  stub pyenv-virtualenv-prefix "venv27 : echo \"/usr\""
+  stub pyenv-virtualenv-prefix "venv33 : echo \"/usr\""
+  stub pyenv-prefix "venv27 : echo \"/usr\""
+  stub pyenv-prefix "venv33 : echo \"/usr\""
+
+  run pyenv-virtualenvs
+
+  unstub pyenv-version-name
+  unstub pyenv-versions
+  unstub pyenv-virtualenv-prefix
+  unstub pyenv-prefix
+
+  assert_success
+  assert_output <<OUT
+  venv27 (created from /usr)
+* venv33 (created from /usr)
+OUT
+}
+
+@test "list virtual environments with --bare" {
+  stub pyenv-versions "--bare : echo \"system\";echo \"venv27\";echo \"venv33\""
+  stub pyenv-virtualenv-prefix "venv27 : echo \"/usr\""
+  stub pyenv-virtualenv-prefix "venv33 : echo \"/usr\""
+  stub pyenv-prefix "venv27 : echo \"/usr\""
+  stub pyenv-prefix "venv33 : echo \"/usr\""
+
+  run pyenv-virtualenvs --bare
+
+  unstub pyenv-versions
+  unstub pyenv-virtualenv-prefix
+  unstub pyenv-prefix
+
+  assert_success
+  assert_output <<OUT
+venv27
+venv33
+OUT
+}