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
27 changed files with 2065 additions and 424 deletions
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,3 +1,4 @@
+sudo: false
 install: git clone https://github.com/sstephenson/bats.git
 script: bats/bin/bats --tap test
 language: c
--- 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,205 +1,216 @@
 # pyenv-virtualenv

-[![Build Status](https://travis-ci.org/yyuu/pyenv-virtualenv.png)](https://travis-ci.org/yyuu/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 https://github.com/yyuu/pyenv-virtualenv.git ~/.pyenv/plugins/pyenv-virtualenv
-    $ exec "$SHELL"
-
 This will install the latest development version of pyenv-virtualenv into
 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.
+
+**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.
+ - 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
+[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 recommended method of installation if you installed pyenv
+*This is the recommended method of installation if you installed pyenv
 with Homebrew.*

-    brew install pyenv-virtualenv
+```
+$ brew install pyenv-virtualenv
+```

 Or, if you would like to install the latest development release:

-    brew install --HEAD pyenv-virtualenv
+```
+$ 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
+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.6 my-virtual-env-2.7.6
+```
+$ pyenv virtualenv 2.7.10 my-virtual-env-2.7.10
+```

-will create a virtualenv based on Python 2.7.6
-under `~/.pyenv/versions` in a folder called `my-virtual-env-2.7.6`. 
+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.3 (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.6)
-      venv33 (created from /home/yyuu/.pyenv/versions/3.3.3)
+```
+$ 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.
-`pyenv activate` lets you to activate the virtualenv into your shell.
+Some external tools (e.g. [jedi](https://github.com/davidhalter/jedi)) might
+require you to `activate` the virtualenv and `conda` environments.

-    $ pyenv activate venv27
+`pyenv-virtualenv` will automatically activate/deactivate the virtualenv if
+the `eval "$(pyenv virtualenv-init -)"` is properly configured in your shell.

-`pyenv activate` acts almost like following commands.
-The activate'd virtualenv will be persisted as _shell_ version.
+You can also activate and deactivate a pyenv virtualenv manually:

-    $ pyenv shell venv27
-    $ source "$(pyenv prefix venv27)/bin/activate"
+```sh
+pyenv activate <name>
+pyenv deactivate
+```

-### Deactivate virtualenv

-You can `deactivate` the activate'd virtualenv by `pyenv deactivate`.
+### Delete existing virtualenv

-    $ pyenv deactivate
+Removing the directory in `~/.pyenv/versions` will delete the virtualenv, or you can run:

-Or, there is an alias in `activate` command.
-This is prepared for similality between other `pyenv` commands like `shell` and `local`.
+```sh
+pyenv uninstall my-virtual-env
+```

-    $ pyenv activate --unset

-`pyenv deactivate` acts almost like following commands.
-You can also use virtualenv's `deactivate` in place of `pyenv deactivate`,
-but be careful with the _shell_ version because it will be persisted even if `deactivate` has invoked.
+### 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
+```

-    $ deactivate
-    $ pyenv shell --unset

 ### 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` and `GET_PIP`, if set and pyvenv is preferred than virtualenv,
-  use `ez_setup.py` and `get_pip.py` at specified location.
-* `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

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

- * 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.

 ### License

--- a/bin/pyenv-sh-activate
+++ b/bin/pyenv-sh-activate
@@ -14,35 +14,139 @@
 set -e
 [ -n "$PYENV_DEBUG" ] && set -x

-# Provide pyenv completions
-if [ "$1" = "--complete" ]; then
-  echo --unset
-  exec pyenv-virtualenvs --bare
-fi
+unset NOERROR
+unset VERBOSE

-if [ "$1" = "--unset" ]; then
-  echo "pyenv deactivate"
-  exit
-fi
+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=("$@")
-shell="$(basename "${PYENV_SHELL:-$SHELL}")"
-
-if [ -z "$versions" ]; then
+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
-  echo "pyenv-virtualenv: cannot activate multiple versions at once: ${versions[@]}" 1>&2
+  [ -n "$NOERROR" ] || echo "pyenv-virtualenv: cannot activate multiple versions at once: ${versions[@]}" 1>&2
+  echo "false"
  exit 1
 fi

-pyenv-virtualenv-prefix "${versions}" 1>/dev/null
+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

-echo "pyenv shell \"${versions}\""
-case "$shell" in
-fish ) echo ". \"$(pyenv-prefix "${versions}")/bin/activate.fish\"" ;;
-*    ) echo "source \"$(pyenv-prefix "${versions}")/bin/activate\"" ;;
-esac
+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
@@ -9,9 +9,112 @@
 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 "functions -q deactivate; and deactivate";;
-*    ) echo "declare -f deactivate 1>/dev/null 2>&1 && deactivate";;
+fish )
+  echo "end;"
+  ;;
+*    )
+  echo "fi;"
+  ;;
 esac
-echo "pyenv shell --unset"
--- 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="20140421"
+PYENV_VIRTUALENV_VERSION="20151006"

 set -e
 [ -n "$PYENV_DEBUG" ] && set -x
@@ -124,10 +122,12 @@ usage() {
 }

 detect_venv() {
-  if pyenv-which "virtualenv" 1>/dev/null 2>&1; then
+  # 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 pyenv-which "pyvenv" 1>/dev/null 2>&1; then
+  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
@@ -140,110 +140,72 @@ venv() {
  local args=("$@")
  if [ -n "${USE_PYVENV}" ]; then
    pyenv-exec pyvenv "${args[@]}"
-
-    local last="${args[${#args[@]}-1]}"
-    ensurepip "${last##*/}"
  else
    pyenv-exec virtualenv "${args[@]}"
  fi
 }

-install_setuptools() {
-  local version="$1"
+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
-      if [ -n "$VERBOSE" ]; then
-        echo "Installing setuptools from ${EZ_SETUP}..." 1>&2
-      fi
+      echo "Installing setuptools from ${EZ_SETUP}..." 1>&2
      cat "${EZ_SETUP}"
    else
-      [ -n "${EZ_SETUP_URL}" ] || {
-        if [ -n "${SETUPTOOLS_VERSION}" ]; then
-          EZ_SETUP_URL="https://bitbucket.org/pypa/setuptools/raw/${SETUPTOOLS_VERSION}/ez_setup.py"
-        else
-          EZ_SETUP_URL="https://bitbucket.org/pypa/setuptools/downloads/ez_setup.py"
-        fi
-      }
-      if [ -n "$VERBOSE" ]; then
-        echo "Installing setuptools from ${EZ_SETUP_URL}..." 1>&2
-      fi
+      [ -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
-  } | PYENV_VERSION="${version}" pyenv-exec python
+  } 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
+  }
 }

-install_pip() {
-  local version="$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
-      if [ -n "$VERBOSE" ]; then
-        echo "Installing pip from ${GET_PIP}..." 1>&2
-      fi
+      echo "Installing pip from ${GET_PIP}..." 1>&2
      cat "${GET_PIP}"
    else
-      [ -n "${GET_PIP_URL}" ] || {
-        if [ -n "${PIP_VERSION}" ]; then
-          GET_PIP_URL="https://raw.github.com/pypa/pip/${PIP_VERSION}/contrib/get-pip.py"
-        else
-          GET_PIP_URL="https://raw.github.com/pypa/pip/master/contrib/get-pip.py"
-        fi
-      }
-      if [ -n "$VERBOSE" ]; then
-        echo "Installing pip from ${GET_PIP_URL}..." 1>&2
-      fi
+      [ -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
-  } | PYENV_VERSION="${version}" pyenv-exec python
+  } 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
+  }
 }

-install_virtualenv() {
-  local version="$1"
-  VIRTUALENV_VERSION="==${VIRTUALENV_VERSION}"
-  PYENV_VERSION="${version}" pyenv-exec pip install $QUIET $VERBOSE "virtualenv${VIRTUALENV_VERSION%==}"
+build_package_ensurepip() {
+  pyenv-exec python -s -m ensurepip 2>/dev/null || build_package_get_pip "$@" || return 1
 }

-ensurepip() {
-  local version="$1"
-  if PYENV_VERSION="${version}" pyenv-exec python -m ensurepip 2>/dev/null; then
-    local PREFIX_PATH="$(pyenv-prefix "${version}")"
-    if [ ! -e "${PREFIX_PATH}/bin/pip" ]; then
-      local pip="$(PYENV_VERSION="${version}" pyenv-exec python -c 'import sys;v=sys.version_info;sys.stdout.write("pip%d.%d"%(v[0],v[1]))')"
-      if [ -e "${PREFIX_PATH}/bin/${pip}" ]; then
-        ( cd "${PREFIX_PATH}/bin" && ln -fs "${pip}" "pip" )
-      fi
-    fi
-  else
-    PYENV_VERSION="${version}" pyenv-exec python -c "import setuptools" 1>/dev/null 2>&1 || {
-      install_setuptools "${version}"
-    } 1>&2
-    PYENV_VERSION="${version}" pyenv-which pip 1>/dev/null 2>&1 || {
-      install_pip "${version}"
-    } 1>&2
-  fi
+prepare_requirements() {
+  pyenv-exec pip freeze > "${REQUIREMENTS}"
+  mv -f "${VIRTUALENV_PATH}" "${VIRTUALENV_ORIG}"
 }

-prepare_upgrade() {
-  local version="$1"
-  local prefix="$2"
-  PYENV_VERSION="${version}" pyenv-exec pip freeze >"${UPGRADE_LIST}"
-  mv -f "${prefix}" "${UPGRADE_PATH}"
-}
-
-upgrade() {
-  local version="$1"
-  local prefix="$2"
-  ## Migrate previously installed packages from requirements.txt
-  if ! PYENV_VERSION="${version}" pyenv-exec pip install $QUIET $VERBOSE --requirement "${UPGRADE_LIST}"; then
-    { echo
-      echo "UPGRADE FAILED"
+install_requirements() {
+  if [ -f "${REQUIREMENTS}" ]; then
+    ## Migrate previously installed packages from requirements.txt
+    pyenv-exec pip install $QUIET $VERBOSE --requirement "${REQUIREMENTS}" || {
      echo
-      echo "Inspect or clean up the original tree at ${UPGRADE_PATH}"
+      echo "PIP INSTALL FAILED"
+      echo
+      echo "Inspect or clean up the original tree at ${VIRTUALENV_ORIG}"
      echo
      echo "Package list:"
-      cat "${UPGRADE_LIST}"
+      cat "${REQUIREMENTS}" | sed 's/^/ * /'
+      return 1
    } 1>&2
-    return 1
+    rm -f "${REQUIREMENTS}"
+    rm -fr "${VIRTUALENV_ORIG}"
  fi
-  rm -f "${UPGRADE_LIST}"
-  rm -fr "${UPGRADE_PATH}"
 }

 PYENV_VIRTUALENV_ROOT="$(abs_dirname "$0")/.."
@@ -311,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"
@@ -323,10 +293,6 @@ 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}"

 unset HAS_VIRTUALENV
@@ -334,29 +300,68 @@ 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
+fi
+
 if [ -n "${USE_PYVENV}" ]; then
  # Unset some arguments not supported by pyvenv
  unset QUIET
  unset VERBOSE
-  if [ -n "$UPGRADE" ]; then
-    unset UPGRADE
-    VIRTUALENV_OPTIONS[${#VIRTUALENV_OPTIONS[*]}]="--upgrade"
+  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
-    VIRTUALENV_OPTIONS[${#VIRTUALENV_OPTIONS[*]}]="--python=${VIRTUALENV_PYTHON}"
+    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
-    install_virtualenv "${PYENV_VERSION}"
+    VIRTUALENV_VERSION="==${VIRTUALENV_VERSION}"
+    pyenv-exec pip install $QUIET $VERBOSE "virtualenv${VIRTUALENV_VERSION%==}"
    HAS_VIRTUALENV=1
  fi
 fi

-# Unset environment variables which starts with `VIRTUALENV_`.
+# 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.
@@ -395,7 +400,7 @@ if [ -d "${VIRTUALENV_PATH}/bin" ]; then
  fi

  if [ -n "$UPGRADE" ]; then
-    prepare_upgrade "${VIRTUALENV_NAME}" "${VIRTUALENV_PATH}"
+    PYENV_VERSION="${VIRTUALENV_NAME}" prepare_requirements
  fi
 fi

@@ -411,18 +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}" || STATUS="$?"

-## Migrate previously installed packages from requirements.txt
-if [ -n "$UPGRADE" ]; then
-  upgrade "${VIRTUALENV_NAME}" "${VIRTUALENV_PATH}" || STATUS="$?"
-fi
+## Install setuptools and pip.
+PYENV_VERSION="${VIRTUALENV_NAME}" build_package_ensurepip

-# Execute `after_virtualenv` hooks
+## Migrate previously installed packages from requirements.txt.
+PYENV_VERSION="${VIRTUALENV_NAME}" install_requirements || true
+
+# 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,11 +31,31 @@ 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)"
-    VIRTUALENV_PREFIX_PATHS=("${VIRTUALENV_PREFIX_PATHS[@]}" "$VIRTUALENV_PREFIX_PATH")
+    # 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-virtualenv: version \`${version}' is not a virtualenv" 1>&2
    exit 1
--- 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/test/activate.bats
+++ b/test/activate.bats
@@ -3,13 +3,17 @@
 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

@@ -19,15 +23,71 @@ setup() {

  assert_success
  assert_output <<EOS
-pyenv shell "venv"
-source "${PYENV_ROOT}/versions/venv/bin/activate"
+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

@@ -37,24 +97,136 @@ EOS

  assert_success
  assert_output <<EOS
-pyenv shell "venv"
-. "${PYENV_ROOT}/versions/venv/bin/activate.fish"
+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\""

-  run pyenv-sh-activate "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"
-source "${PYENV_ROOT}/versions/venv27/bin/activate"
+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
 }

@@ -69,12 +241,33 @@ 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" {
@@ -83,6 +276,16 @@ EOS
  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
 }

--- 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
@@ -7,22 +7,218 @@ setup() {
 }

@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
-declare -f deactivate 1>/dev/null 2>&1 && deactivate
-pyenv shell --unset
+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
-functions -q deactivate; and deactivate
-pyenv shell --unset
+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
 }

--- a/test/hooks.bats
+++ b/test/hooks.bats
@@ -13,14 +13,16 @@ setup() {
 before_virtualenv 'echo before: \$VIRTUALENV_PATH'
 after_virtualenv 'echo after: \$STATUS'
 OUT
-  stub pyenv-prefix "echo '${PYENV_ROOT}/versions/\${PYENV_VERSION}'"
-  stub pyenv-which "virtualenv : echo '${PYENV_ROOT}/versions/bin/virtualenv'" \
-                   "pyvenv : false"
+  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=\${PYENV_VERSION} \"\$@\""
+  stub pyenv-exec "echo PYENV_VERSION=3.2.1 \"\$@\""
  stub pyenv-rehash "echo rehashed"

-  mkdir -p "${PYENV_ROOT}/versions/3.2.1"
+  create_executable "3.2.1" "virtualenv"
+  remove_executable "3.2.1" "pyvenv"
+
  run pyenv-virtualenv "3.2.1" venv

  assert_success
--- 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
@@ -9,9 +9,12 @@ load test_helper

  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 ]
 }
--- 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
@@ -7,185 +7,169 @@ setup() {
 }

 stub_pyenv() {
-  export PYENV_VERSION="$1"
  stub pyenv-version-name "echo \${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() {
-  unset PYENV_VERSION
  unstub pyenv-version-name
  unstub pyenv-prefix
  unstub pyenv-hooks
  unstub pyenv-rehash
 }

-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"
-  
-}
-
@test "use pyvenv if virtualenv is not available" {
-  stub_pyenv "3.4.0"
-  stub pyenv-which "virtualenv : false" \
-                   "pyvenv : echo '${PYENV_ROOT}/versions/bin/pyvenv'"
-  stub pyenv-exec "echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\"" \
-                  "bin=\"${PYENV_ROOT}/versions/venv/bin\";mkdir -p \"\$bin\";touch \"\$bin/pip3.4\";echo PYENV_VERSION=\${PYENV_VERSION} ensurepip" \
-                  "echo pip3.4"
-  stub pyenv-prefix "venv : echo '${PYENV_ROOT}/versions/venv'"
+  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

-  unstub_pyenv
-  unstub pyenv-which
-  unstub pyenv-exec
-
  assert_success
  assert_output <<OUT
-PYENV_VERSION=3.4.0 pyvenv ${PYENV_ROOT}/versions/venv
-PYENV_VERSION=venv ensurepip
+PYENV_VERSION=3.4.1 pyvenv ${PYENV_ROOT}/versions/venv
 rehashed
 OUT
-  assert [ -e "${PYENV_ROOT}/versions/venv/bin/pip" ]
+
+  unstub_pyenv
+  unstub pyenv-exec
 }

@test "not use pyvenv if virtualenv is available" {
-  stub_pyenv "3.4.0"
-  stub pyenv-which "virtualenv : echo '${PYENV_ROOT}/versions/bin/virtualenv'" \
-                   "pyvenv : echo '${PYENV_ROOT}/versions/bin/pyvenv"
-  stub pyenv-exec "echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
+  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

-  unstub_pyenv
-  unstub pyenv-which
-  unstub pyenv-exec
-
  assert_success
  assert_output <<OUT
-PYENV_VERSION=3.4.0 virtualenv ${PYENV_ROOT}/versions/venv
+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" {
-  stub_pyenv "3.2.1"
-  stub pyenv-which "virtualenv : false" \
-                   "pyvenv : false"
-  stub pyenv-exec "echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\"" \
-                  "echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
+  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

-  unstub_pyenv
-  unstub pyenv-which
-  unstub pyenv-exec
-
  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" {
-  stub_pyenv "3.4.0"
-  stub pyenv-which "virtualenv : false"
-  stub pyenv-which "pyvenv : echo '${PYENV_ROOT}/versions/bin/pyvenv'"
-  stub pyenv-exec "echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
-  stub pyenv-exec "echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
+  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"

-  run pyenv-virtualenv -p python3 venv
+  remove_executable "3.4.1" "virtualenv"
+  create_executable "3.4.1" "pyvenv"

-  unstub_pyenv
-  unstub pyenv-which
-  unstub pyenv-exec
+  run pyenv-virtualenv -p ${TMP}/python3 venv

-  assert_success
  assert_output <<OUT
-PYENV_VERSION=3.4.0 pip install virtualenv
-PYENV_VERSION=3.4.0 virtualenv --python=python3 ${PYENV_ROOT}/versions/venv
+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" {
-  stub_pyenv "3.4.0"
-  stub pyenv-which "virtualenv : false"
-  stub pyenv-which "pyvenv : echo '${PYENV_ROOT}/versions/bin/pyvenv'"
-  stub pyenv-exec "echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
-  stub pyenv-exec "echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
+  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"

-  run pyenv-virtualenv --python=python3 venv
+  remove_executable "3.4.1" "virtualenv"
+  create_executable "3.4.1" "pyvenv"

-  unstub_pyenv
-  unstub pyenv-which
-  unstub pyenv-exec
+  run pyenv-virtualenv --python=${TMP}/python3 venv

-  assert_success
  assert_output <<OUT
-PYENV_VERSION=3.4.0 pip install virtualenv
-PYENV_VERSION=3.4.0 virtualenv --python=python3 ${PYENV_ROOT}/versions/venv
+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" {
-  stub_pyenv "3.2.1"
-  stub pyenv-which "virtualenv : false" \
-                   "pyvenv : false"
-  stub pyenv-exec "echo PIP_REQUIRE_VENV=\${PIP_REQUIRE_VENV} PYENV_VERSION=\${PYENV_VERSION} \"\$@\"" \
-                  "echo PIP_REQUIRE_VENV=\${PIP_REQUIRE_VENV} PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
+  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

-  unstub_pyenv
-  unstub pyenv-which
-  unstub pyenv-exec
-
  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
-}
-
-@test "install pip without using ensurepip" {
-  stub_pyenv "3.3.0"
-  stub pyenv-which "virtualenv : false" \
-                   "pyvenv : echo '${PYENV_ROOT}/versions/bin/pyvenv'" \
-                   "pip : echo no pip; false"
-  stub pyenv-exec "echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\"" \
-                  "echo PYENV_VERSION=\${PYENV_VERSION} no ensurepip; false" \
-                  "echo PYENV_VERSION=\${PYENV_VERSION} no setuptools; false" \
-                  "echo PYENV_VERSION=\${PYENV_VERSION} setuptools" \
-                  "bin=\"${PYENV_ROOT}/versions/venv/bin\";mkdir -p \"\$bin\";touch \"\$bin/pip\";echo PYENV_VERSION=\${PYENV_VERSION} pip"
-  stub curl "echo ez_setup.py" \
-            "echo get_pip.py"
-
-  run pyenv-virtualenv venv

  unstub_pyenv
-  unstub pyenv-which
  unstub pyenv-exec
-
-  assert_success
-  assert_output <<OUT
-PYENV_VERSION=3.3.0 pyvenv ${PYENV_ROOT}/versions/venv
-PYENV_VERSION=venv no ensurepip
-PYENV_VERSION=venv setuptools
-PYENV_VERSION=venv pip
-rehashed
-OUT
-  assert [ -e "${PYENV_ROOT}/versions/venv/bin/pip" ]
+  unstub curl
 }
--- a/test/test_helper.bash
+++ b/test/test_helper.bash
@@ -96,3 +96,39 @@ assert_output_contains() {
    } | 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/version.bats
+++ b/test/version.bats
@@ -4,34 +4,40 @@ load test_helper

 setup() {
  export PYENV_ROOT="${TMP}/pyenv"
-  export PYENV_VIRTUALENV_VERSION="20140421"
+  export PYENV_VIRTUALENV_VERSION="20151006"
 }

@test "display virtualenv version" {
-  stub pyenv-which "virtualenv : true"
-  stub pyenv-which "pyvenv : true"
+  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\""

-  run pyenv-virtualenv --version
+  create_executable "2.7.7" "virtualenv"
+  remove_executable "2.7.7" "pyvenv"

-  unstub pyenv-which
-  unstub pyenv-exec
+  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-which "virtualenv : false"
-  stub pyenv-which "pyvenv : echo \"${PYENV_ROOT}/versions/3.3.3/bin/pyvenv\""
-  stub pyenv-which "pyvenv : echo \"${PYENV_ROOT}/versions/3.3.3/bin/pyvenv\""
+  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

-  unstub pyenv-which
-  unstub pyenv-root
-
  assert_success
-  assert_output "pyenv-virtualenv ${PYENV_VIRTUALENV_VERSION} (pyvenv 3.3.3)"
+  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
@@ -102,6 +102,19 @@ ${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\""
--- a/test/virtualenv.bats
+++ b/test/virtualenv.bats
@@ -7,88 +7,130 @@ setup() {
 }

 stub_pyenv() {
-  export PYENV_VERSION="$1"
-  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/\${PYENV_VERSION}'"
-  stub pyenv-which "virtualenv : echo '${PYENV_ROOT}/versions/bin/virtualenv'" \
-                   "pyvenv : false"
+  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() {
-  unset PYENV_VERSION
  unstub pyenv-prefix
-  unstub pyenv-which
  unstub pyenv-hooks
  unstub pyenv-rehash
 }

@test "create virtualenv from given version" {
-  stub_pyenv "3.2.1"
-  stub pyenv-exec "echo PYENV_VERSION=\${PYENV_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"

-  unstub_pyenv
-  unstub pyenv-exec
-
  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" {
-  stub_pyenv "3.2.1"
+  export PYENV_VERSION="3.2.1"
+  stub_pyenv "${PYENV_VERSION}"
  stub pyenv-version-name "echo \${PYENV_VERSION}"
-  stub pyenv-exec "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

  run pyenv-virtualenv venv

-  unstub_pyenv
-  unstub pyenv-version-name
-  unstub pyenv-exec
-
  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" {
-  stub_pyenv "3.2.1"
+  export PYENV_VERSION="3.2.1"
+  stub_pyenv "${PYENV_VERSION}"
  stub pyenv-version-name "echo \${PYENV_VERSION}"
-  stub pyenv-exec "echo PYENV_VERSION=\${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 python venv
+  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
-
-  assert_success
-  assert_output <<OUT
-PYENV_VERSION=3.2.1 virtualenv --verbose --python=python ${PYENV_ROOT}/versions/venv
-rehashed
-OUT
+  unstub curl
 }

@test "create virtualenv with long options" {
-  stub_pyenv "3.2.1"
+  export PYENV_VERSION="3.2.1"
+  stub_pyenv "${PYENV_VERSION}"
  stub pyenv-version-name "echo \${PYENV_VERSION}"
-  stub pyenv-exec "echo PYENV_VERSION=\${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=python venv
+  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
+}

-  assert_success
+@test "no whitespace allowed in virtualenv name" {
+  run pyenv-virtualenv "3.2.1" "foo bar"
+
+  assert_failure
  assert_output <<OUT
-PYENV_VERSION=3.2.1 virtualenv --verbose --python=python ${PYENV_ROOT}/versions/venv
-rehashed
+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
@@ -17,12 +17,15 @@ setup() {
  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
@@ -36,12 +39,15 @@ OUT
  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
@@ -54,11 +60,14 @@ OUT
  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
Author	SHA1	Message	Date
Yamashita, Yuu	6a6947659a	v20151006	2015-10-06 14:06:58 +00:00
Yamashita, Yuu	d0c77019cc	use container-based infrastructure on travis-ci.org	2015-10-06 14:04:10 +00:00
Yamashita, Yuu	164925ca3c	change to SVG build status	2015-10-06 14:02:49 +00:00
Yamashita, Yuu	249759aa04	add foolproof for `-p` argument. find proper source version from pyenv if the given executable is only basename or is a shim script.	2015-10-06 13:53:43 +00:00
Yamashita, Yuu	e34a8bbee4	Merge pull request #98 from jerr0328/master pyenv-virtualenv-init fix for fish	2015-09-24 21:56:18 +09:00
Jeremy	d86fd13797	Fix test to not have quotes expected in command eval for Fish	2015-09-24 14:39:24 +02:00
Jeremy	a242067435	Fix pyenv-virtualenv-init script for fish where command was in string and not being evaluated	2015-09-24 14:06:20 +02:00
Yamashita, Yuu	45c73f9073	fix broken pattern matching to `pythonX.Y-config`	2015-09-22 23:49:04 +09:00
Yamashita, Yuu	cce1b9535d	Merge branch 'find-python-config-from-source-version'	2015-09-22 22:57:36 +09:00
Yamashita, Yuu	1ca0c84ed6	find `python-config` from source version if current version is a virtualenv	2015-09-22 22:56:34 +09:00
Yamashita, Yuu	d1a0f2c66d	Merge pull request #93 from aristiden7o/patch-1 update init step in brew installation instructions	2015-07-28 08:03:07 +09:00
Aristide Niyungeko	4776fe4e04	update init step in brew installation instructions This fixes issue: https://github.com/yyuu/pyenv-virtualenv/issues/36	2015-07-27 14:58:46 -07:00
Yamashita, Yuu	d27504b315	Merge pull request #92 from keik/master Apply code blocks style	2015-07-24 09:48:04 +09:00
keik	662b3e7d2f	Apply code blocks style	2015-07-24 09:46:23 +09:00
Yamashita, Yuu	15e4f651ae	Merge branch 'issue89' (fixes #89 )	2015-07-21 15:31:57 +09:00
Yamashita, Yuu	856098bf55	Separate change log from README	2015-07-21 10:14:48 +09:00
Yamashita, Yuu	7b34f7234e	Fix broken test	2015-07-20 19:14:57 +09:00
Yamashita, Yuu	e535faea4d	Ignore user's site-packages on ensurepip/get-pip (#89 ) https://www.python.org/dev/peps/pep-0370/	2015-07-20 19:05:52 +09:00
Yamashita, Yuu	b5c4131993	fix markdown	2015-07-19 21:37:50 +09:00
Yamashita, Yuu	90531a6a48	v20150719	2015-07-19 18:22:34 +09:00
Yamashita, Yuu	a04522204d	Update README	2015-07-19 18:17:49 +09:00
Yamashita, Yuu	c97ae36376	Merge pull request #91 from yyuu/conda-envs Manage Anaconda/Miniconda environment as a pyenv version	2015-07-19 15:11:14 +09:00
Yamashita, Yuu	b32d357353	Add tests for conda	2015-07-19 15:01:04 +09:00
Yamashita, Yuu	cdbf7c9972	activate "root" environment of anaconda/miniconda if environment name is not given	2015-07-19 04:19:34 +09:00
Yamashita, Yuu	25395f0331	activate: look for a conda environment if given name is not a pyenv's prefix	2015-07-19 03:38:48 +09:00
Yamashita, Yuu	be6701e7b6	Fix `Error: too many arguments.` on deactivating anaconda env	2015-07-19 01:04:23 +09:00
Yamashita, Yuu	e1523811fb	fix broken test	2015-07-19 00:08:12 +09:00
Yamashita, Yuu	65c74dbf2d	activate/deactivate anaconda/miniconda envs	2015-07-19 00:08:09 +09:00
Yamashita, Yuu	6132f4228e	EXPERIMENTAL a support for _envs_ created by anaconda/miniconda	2015-07-19 00:07:59 +09:00
Yamashita, Yuu	21239c9342	If the current virtualenv is created with `--system-site-packages` and an executable is not found in it, automatically look up the executable for source Python version. (fixes #62)	2015-07-18 20:39:56 +09:00
Yamashita, Yuu	1608344c56	Merge pull request #79 from blueyed/fix-shell-detection init: fix shell detection when invoked from a script	2015-06-27 04:03:58 +09:00
Daniel Hahler	8ca45c0e0a	init: fix shell detection when invoked from a script - fixes `ps` command to lookup parent process - adds `assert_output_contains_not` test helper Ref: https://github.com/yyuu/pyenv/issues/373	2015-06-26 20:47:08 +02:00
Yamashita Yuu	69fee6855d	Show error message if the source version is not installed (#83 )	2015-06-27 02:19:28 +09:00
Yamashita Yuu	e261806f96	Skip installing `setuptools` explicitly with using `ez_setup.py` (yyuu/pyenv#381 ) It will be done by `get-pip.py` and we don't have to do anything explicitly.	2015-05-27 00:06:16 +09:00
Yamashita Yuu	9a52f9fb5d	v20150526 First release after my son's birth....	2015-05-27 00:01:13 +09:00
Yamashita, Yuu	0ca01826e8	Merge pull request #78 from blueyed/shell-no-note-if-init activate: do not display note if initialized already	2015-05-17 12:23:37 +09:00
Yamashita, Yuu	4fa9c7b220	Merge pull request #75 from blueyed/fix-zsh-typeset-precmd_functions Use `typeset -g` with `precmd_functions`	2015-05-17 12:12:12 +09:00
Daniel Hahler	2571a2b973	activate: display setup instructions only with PYENV_VIRTUALENV_INIT=0 This fixes displaying the note, in case "init" has been run manually and/or the init is not in the expected place. It removes the unnecessary calls to "grep". pyenv-virtualenv-init will look at `$PYENV_SHELL` now, too. Tests have been adjusted/fixed.	2015-05-10 17:47:46 +02:00
Daniel Hahler	95fa7a35ad	shell: do not use basename, but bash	2015-05-10 17:36:03 +02:00
Yamashita, Yuu	47cd86a165	Merge pull request #74 from blueyed/help-version-is-optional Usage: version is optional	2015-04-28 17:19:46 +09:00
Yamashita, Yuu	d9c3f9a2f5	Merge pull request #73 from blueyed/fix-comments minor: fix comments	2015-04-28 17:19:10 +09:00
Daniel Hahler	6bc0253d17	minor: fix comments	2015-04-28 10:17:02 +02:00
Daniel Hahler	c184c01174	Usage: version is optional	2015-04-28 10:13:59 +02:00
Yamashita, Yuu	55189357e2	Merge pull request #72 from sfilipov/patch-1 Link to English venv documentation	2015-04-24 10:15:15 +09:00
Simeon Filipov	9544c8b178	Link to English venv documentation Currently the link to venv points to the Japanese version of the Python documentation. Change this link to the English version of the Python documentation.	2015-04-24 01:51:15 +01:00
Yamashita, Yuu	bcb7abdf93	Merge pull request #68 from jawshooah/ignore-error-code Ignore failure of pyenv activate	2015-03-19 12:18:19 +09:00
Josh Hagins	5953ddaf64	Ignore failure of pyenv activate When the current pyenv environment is not a virtualenv, this line exits with a return code of 1. This is annoying for those of us who report the last return code in our own PROMPT_COMMAND, so ignore the output of `pyenv activate` if we're not currently using a virtualenv.	2015-03-18 22:30:19 -04:00
Daniel Hahler	2ab9483116	Use `typeset -g` with `precmd_functions` This makes it possible to use `eval "$(pyenv virtualenv-init -)"` from a function.	2015-03-14 02:37:14 +01:00
Yamashita Yuu	32e5a73345	v20150119	2015-01-19 00:53:19 +09:00
Yamashita Yuu	0fc9441f09	Anaconda has `activate` script nevertheless it is not a virtual environment (#65 )	2015-01-18 20:15:44 +09:00
Yamashita, Yuu	0fe9aef635	Merge pull request #64 from wwwjfy/master fix wrong output in test in fish, refs `240a1de`	2015-01-06 14:05:52 +09:00
Tony Wang	e04a6f88fe	fix wrong output in test in fish, refs `240a1de` "(any command)" is not supported in test in fish, we have to set a variable and then use that	2015-01-06 11:10:43 +08:00
Yamashita, Yuu	08c2e6aee4	Merge pull request #63 from wwwjfy/master fix warns for virtualenv-init corner case on fish	2015-01-06 10:20:53 +09:00
Tony Wang	cc7c9d22b5	fix failed tests running under fish	2015-01-05 23:28:14 +08:00
Tony Wang	240a1de6e5	fix warns for virtualenv-init corner case on fish The situation is when in a directory containing python binary, `pyenv prefix' will return empty (caused by `pyenv which' returning "./python"). This change adds quotes for `test', otherwise `test' will warn about missing argument.	2015-01-05 23:23:43 +08:00
Yamashita Yuu	9d71e67401	Merge branch 'issue61'	2014-12-28 18:50:25 +09:00
Yamashita Yuu	191e806ba9	shell version set in `activate` should be unset in `deactivate` (#61 )	2014-12-23 11:21:52 +09:00
Yamashita Yuu	4b198663c7	Merge branch 'pr60' (#60 )	2014-12-16 23:05:01 +09:00
Yamashita Yuu	ad0fa82329	Fix broken fish test (#60 )	2014-12-16 23:04:35 +09:00
Tony Wang	f681df6f20	fix incorrect fish syntax in pyenv-virtualenv-init	2014-12-16 17:53:26 +08:00
Yamashita, Yuu	593268b988	Merge pull request #59 from blueyed/doc-fixes Some doc fixes: typos, grammar, clarification and formatting	2014-12-14 20:51:29 +09:00
Yamashita Yuu	e774464ced	ignore error from `pyenv-version-name` since it might fail if there is configuration error (yyuu/pyenv#291 )	2014-12-14 14:15:18 +09:00
Yamashita, Yuu	6d46b6ab53	Merge pull request #58 from pygeek/patch-1 Update read to include pyenv-init - note.	2014-12-14 14:14:55 +09:00
Clinton Christian	11a86ad7d7	Remove white space.	2014-12-13 16:44:03 -05:00
Daniel Hahler	99145752f3	Some doc fixes: typos, grammar, clarification and formatting	2014-12-12 02:41:04 +01:00
Clinton Christian	1da2fe09c2	Update read to include pyenv-init - note.	2014-12-11 16:18:43 -05:00
Yamashita Yuu	ad644e83b5	v20141106	2014-11-06 09:47:54 -08:00
Yamashita Yuu	0786c7c5b6	The `pyenv virtualenv-init` is not always necessary (#42 ) It is necessary only if user want automatic fashion of activation. If the users of pyenv-virtualenv doesn't need the feature, they can omit the configuration safely.	2014-11-03 08:48:42 -08:00
Yamashita Yuu	58e93f9e0d	Fix test which has broken by `2060c43387`	2014-10-27 11:04:42 +09:00
Yamashita Yuu	2060c43387	Stop buzzy errors from embeded shell functions	2014-10-27 10:36:10 +09:00
Yamashita Yuu	a02eb0a396	Calling `create_symlinks` after `ensurepip` is unnecessary Install script of setuptools-6.1/pip-1.5.6 will create those links if needed	2014-10-19 10:59:52 +09:00
Yamashita Yuu	1d36ef2f68	v20141012	2014-10-12 21:55:47 +09:00
Yamashita Yuu	5795eabaac	Merge branch 'bcb-master' (fixed #47 )	2014-10-12 21:41:43 +09:00
Yamashita Yuu	e655abbd41	Fix broken tests (#47 )	2014-10-12 21:37:10 +09:00
Yamashita Yuu	d6671249b7	Should not persist `PYENV_DEACTIVATE` after automatic deactivation (#47 , #48 )	2014-10-12 21:34:18 +09:00
Beau Barker	79bfc9d362	When changing from a virtualenv to "system", unset PYENV_DEACTIVATE. Previously the var remained set, which made it impossible to reactivate the previous virtualenv	2014-09-17 19:50:41 +10:00
Yamashita, Yuu	5252cd0777	Merge pull request #46 from NegaMorgan/add-virtualenv-delete-instructions added instructions for deleting virtualenvs	2014-09-06 01:28:53 +09:00
Morgan Evans	909e4de414	added instructions for deleting virtualenvs	2014-09-05 12:09:33 -04:00
Yamashita, Yuu	215bda7032	Merge pull request #44 from blueyed/no-whitespace-in-name Do not allow whitespace in VIRTUALENV_NAME	2014-09-04 08:56:44 +09:00
Daniel Hahler	86046fd4e8	Do not allow whitespace in VIRTUALENV_NAME While this could work in general, it fails in the end, because whitespace is not allowed/supported in the shebang line with the scripts in the created virtualenv.	2014-09-03 23:28:46 +02:00
Yamashita, Yuu	2cc21f112c	Merge pull request #40 from s0undt3ch/master Fix weird bash code issue which made bash complain about "then"	2014-08-14 10:03:35 +09:00
Pedro Algarvio	81736da905	Indent to 2 spaces.	2014-08-13 19:51:22 +01:00
Pedro Algarvio	7304608e0f	Adapt tests to new output	2014-08-13 03:58:32 +01:00
Pedro Algarvio	3ebb00414f	`if [ pyenv deactivate --no-error --verbose ]` is not bourne shell compatible	2014-08-13 03:40:02 +01:00
Yamashita Yuu	c9bcef656c	Use `.` instead of `source` to support POSIX sh	2014-08-13 10:54:18 +09:00
Pedro Algarvio	2662b5807c	Fix weird bash code issue which made bash complain about "then"	2014-08-13 00:55:04 +01:00
Yamashita Yuu	fa04d6f9df	Add notes on `pyvenv` in README	2014-07-11 20:30:43 +09:00
Yamashita Yuu	a3c86f013b	Deactivate virtualenv even if it has been activated manually	2014-07-11 20:24:58 +09:00
Yamashita Yuu	7aa5d13633	v20140705	2014-07-05 17:26:53 +09:00
Yamashita Yuu	aef2546319	Fix broken fish's `if` statement	2014-07-05 07:30:53 +09:00
Yamashita Yuu	6b4d6249a0	No need to use `eval` in fish init script	2014-07-05 07:27:12 +09:00
Yamashita Yuu	0de2cdbbc3	Should not persist `PYENV_DEACTIVATE` after failed attempt to deactivate and activate	2014-07-05 06:53:46 +09:00
Yamashita Yuu	abfda4bac9	Fix issues with manual activation of virtual environments (#34 )	2014-07-04 22:55:06 +09:00
Yamashita Yuu	be18fd294e	Fix `virtualenv-prefix` when the version is `system`	2014-07-04 22:44:08 +09:00
Yamashita Yuu	d4ce853e94	Display information on automatic (de)?activation	2014-07-04 22:44:05 +09:00
Yamashita Yuu	58ed045796	s/QUIET/NOERROR/g	2014-07-04 22:10:35 +09:00
Yamashita Yuu	c2b5bbd19a	Fix fish syntax error at `else`	2014-07-04 20:51:31 +09:00
Yamashita Yuu	f0c400b669	Add `--quiet` option to `activate` and `deactivate`	2014-07-04 20:47:10 +09:00
Yamashita Yuu	5b3b909089	Exit as error on deactivation failures	2014-07-04 20:33:37 +09:00
Yamashita Yuu	0b5e0cf592	Unset shell version only if the `deactivate` has invoked	2014-07-04 20:27:55 +09:00
Yamashita Yuu	c09a6d3d6c	Exit as error on activation failures	2014-07-04 20:23:29 +09:00
Yamashita Yuu	e2e69b3b38	Create backup of original virtualenv within `$(pyenv root)/versions` when `--upgrade`	2014-07-01 21:24:54 +09:00
Yamashita Yuu	008a9820bb	Refactor `--upgrade` feature with virtualenv	2014-07-01 21:23:37 +09:00
Yamashita, Yuu	c68685a12f	Merge pull request #33 from yyuu/restore-deactivate Use `PYENV_DEACTIVATE` to store which virtualenv has been deactivated (fixes #32)	2014-07-01 12:21:59 +09:00
Yamashita Yuu	08b4c94f85	Use `PYENV_DEACTIVATE` to store which virtualenv has been deactivated (#32 )	2014-06-30 23:03:37 +09:00
Yamashita Yuu	7079cbe979	Fix broken `setenv` in `pyenv-virtualenv-init`	2014-06-30 21:35:53 +09:00
Yamashita Yuu	763696b3fb	Expand `install_virtualenv` for code simplicity	2014-06-28 19:13:04 +09:00
Yamashita Yuu	0580d566d4	Remove a call of `create_symlinks` after the upgrade of existing virtualenv. The `pyenv-virtualenv` only takes care about the name of executables of `python`, `setuptools` and `pip`.	2014-06-28 17:53:02 +09:00
Yamashita, Yuu	1a4fa48106	Merge pull request #31 from yyuu/remove-virtualenv-upgrade Remove `--upgrade` feature since it is less useful	2014-06-28 17:51:27 +09:00
Yamashita Yuu	7a6325f8a4	Display deprecated warnings when `--upgrade` has given with virtualenv	2014-06-28 17:49:43 +09:00
Yamashita Yuu	1944479bdf	Merge branch 'ensurepip'	2014-06-28 01:04:56 +09:00
Yamashita Yuu	bad4507541	Run _ensurepip_ after the every creation of virtualenv/pyvenv	2014-06-28 01:03:33 +09:00
Yamashita Yuu	7c8805c343	Use same _ensurepip_ logic as python-build	2014-06-28 00:49:04 +09:00
Yamashita, Yuu	467e9da3a8	Merge pull request #30 from danse/patch-1 Add manual activation example	2014-06-26 11:20:51 +09:00
danse	5168aacdc0	Add manual activation example	2014-06-25 18:41:46 +02:00
Yamashita Yuu	877aba8ae7	Refactoring around `SETUPTOOLS_VERSION` and `PIP_VERSION`	2014-06-21 02:05:14 +09:00
Yamashita, Yuu	f5cfc95809	Merge pull request #27 from yyuu/bootstrap.pypa.io Download ez_setup.py and get-pip.py from https://bootstrap.pypa.io/	2014-06-16 11:28:43 +09:00
Yamashita Yuu	2fc7e62b78	Use https://bootstrap.pypa.io/ez_setup.py and https://bootstrap.pypa.io/get-pip.py	2014-06-16 11:22:39 +09:00
Yamashita Yuu	ea18a1b283	v20140615 (fixes #26 )	2014-06-15 20:20:29 +09:00
Yamashita Yuu	dcb5371f07	Merge branch 'workaround-for-pyenv-which-ext'	2014-06-15 20:16:25 +09:00
Yamashita Yuu	56a3225d6c	Merge branch 'issue26'	2014-06-15 20:16:09 +09:00
Yamashita Yuu	dc12a345d8	Workaround for the issue with pyenv-which-ext (refs #26 )	2014-06-15 18:36:21 +09:00
Yamashita Yuu	d9e3adc108	Performe as same as before v20140614 if `pyenv virtualenv-init` is not configured (#26 )	2014-06-15 16:43:50 +09:00
Yamashita Yuu	4a6ef11349	v20140614	2014-06-14 14:45:57 +09:00
Yamashita Yuu	21e999cc7c	Fix deactivation issue with `system` version $ pyenv global system $ pyenv shell venv (venv) $ pyenv shell --unset (venv) $ pyenv version system (set by /home/yamashita/.pyenv/version) (venv) $ pyenv which python /home/yamashita/.pyenv/versions/venv/bin/python # <-- should be `/usr/bin/python` (system)	2014-06-13 19:30:37 +09:00
Yamashita Yuu	e853f74b26	Fix test cases around `create_symlinks`	2014-06-12 20:35:46 +09:00
Yamashita Yuu	fe5e69846e	Create symlinks for executables with version suffix	2014-06-12 20:35:44 +09:00
Yamashita Yuu	c17e4ec9a4	style	2014-06-05 19:31:10 +09:00
Yamashita Yuu	7828a15066	Use `pyenv-virtualenv-init` to show caveats	2014-06-05 00:17:06 +09:00
Yamashita Yuu	55a2a9e482	Read shell profile from `$TMP` during tests	2014-06-05 00:16:41 +09:00
Yamashita Yuu	b258bfa907	Display notice about `virtualenv-init` in `activate`	2014-06-05 00:08:21 +09:00
Yamashita, Yuu	8838bae3bc	Merge pull request #24 from yyuu/automatic-activation Automatic activation	2014-06-04 20:51:05 +09:00
Yamashita Yuu	b7535395e8	Update README	2014-06-04 20:48:22 +09:00
Yamashita Yuu	6761ed09cd	Add test for `pyenv-virtualenv-init`	2014-06-04 20:48:22 +09:00
Yamashita Yuu	8a837758dc	activate: invoke `pyenv shell` only if the arguments passed	2014-06-04 15:24:36 +09:00
Yamashita Yuu	ea120da0c5	fish: Suppress annoying stderr outputs from `pyenv-sh-activate`	2014-06-04 15:24:34 +09:00
Yamashita Yuu	af6c157a79	Add `eval "$(pyenv virtualenv-init -)"` to setup _precmd_ for user's shell	2014-06-04 15:24:12 +09:00
Yamashita Yuu	c9043920db	v20140602	2014-06-02 21:42:27 +09:00
Yamashita Yuu	26f2004abb	Add semicolon for the `deactivate` scripts for non-fish	2014-06-02 16:02:39 +09:00
Yamashita, Yuu	b9e2fc6acb	Merge pull request #23 from fgimian/fish-activation-fix Repaired virtualenv activation and deactivation for the fish shell	2014-05-31 14:19:02 +09:00
Fotis Gimian	21a8745bcf	Updated tests to correctly pass for fish shell bug fix	2014-05-31 15:15:45 +10:00
Fotis Gimian	f7da0c5808	Repaired virtualenv activation and deactivation for the fish shell	2014-05-31 12:29:19 +10:00
Yamashita Yuu	3f5171e2fc	Use new style GH raw url to avoid redirects (raw.github.com -> raw.githubusercontent.com)	2014-04-30 11:52:15 +09:00