2026-09-11 15:56:28 -04:00
49 changed files with 1125 additions and 4589 deletions
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@ -1,12 +0,0 @@
 # These are supported funding model platforms
 github: [pyenv] # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
 patreon: # Replace with a single Patreon username
 open_collective: pyenv # Replace with a single Open Collective username
 ko_fi: # Replace with a single Ko-fi username
 tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
 community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
 liberapay: # Replace with a single Liberapay username
 issuehunt: # Replace with a single IssueHunt username
 otechie: # Replace with a single Otechie username
 custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@ -1,46 +0,0 @@
 ---
 name: Bug report
 about: Create a report to help us improve
 title: ''
 labels: ''
 assignees: ''
 ---
 ### Prerequisite
 * [ ] Make sure no duplicated issue has already been reported in [the pyenv-virtualenv issues](https://github.com/pyenv/pyenv-virtualenv/issues). You should look in closed issues, too.
 * [ ] Make sure you are reporting a problem in Pyenv-Virtualenv and not seeking consultation with Pyenv-Virtualenv use.
  * GitHub issues are intended mainly for Pyenv-Virtualenv development purposes. If you are seeking help with Pyenv-Virtualenv use, check [Pyenv-Virtualenv documentation](https://github.com/pyenv/pyenv-virtualenv?tab=readme-ov-file#usage), go to a user community site like [Gitter](https://gitter.im/yyuu/pyenv), [StackOverflow](https://stackoverflow.com/questions/tagged/pyenv), etc, or to [Discussions](https://github.com/orgs/pyenv/discussions).
 * [ ] Make sure your problem is not derived from packaging (e.g. [Homebrew](https://brew.sh)).
  * Please refer to the package documentation for the installation issues, etc.
 * [ ] Make sure your problem is not derived from other plugins.
  * This repository is maintaining the `pyenv-virtualenv` plugin only. Please refrain from reporting issues of other plugins here.
 ### Describe the bug
 A clear and concise description of what the bug is.
 Do specify what the expected behaviour is if that's not obvious from the bug's nature.
 #### Reproduction steps
 Listing the commands to run in a new console session and their output is usually sufficient.
 Please use a Markdown code block (three backticks on a line by themselves before and after the text) to denote a console output excerpt.
 #### Diagnostic details
 - [ ] Platform information (e.g. Ubuntu Linux 20.04):
 - [ ] OS architecture (e.g. amd64):
 - [ ] pyenv version:
 - [ ] pyenv-virtualenv version:
 - [ ] Python version:
 - [ ] virtualenv version (if installed):
 - [ ] Please attach the debug log of a faulty Pyenv invocation as a gist
  * If the problem happens in a Pyenv invocation, you can turn on debug logging by setting `PYENV_DEBUG=1`, e.g. `env PYENV_DEBUG=1 pyenv install -v 3.6.4`
  * If the problem happens outside of a Pyenv invocation, get the debug log like this:
     ```bash
     # for Bash
     export PS4='+(${BASH_SOURCE}:${LINENO}): ${FUNCNAME[0]:+${FUNCNAME[0]}(): }'
     # for Zsh
     export PS4='+(%x:%I): %N(%i): '
     set -x
     <reproduce the problem>
     set +x
     ```
--- a/.github/ISSUE_TEMPLATE/feature_request.md
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@ -1,24 +0,0 @@
 ---
 name: Feature request
 about: Suggest an idea for this project
 title: ''
 labels: ''
 assignees: ''
 ---
 **Describe the intended use case**
 * What your general environment is if it's relevant to the feature request and is not a generic console with a typical Pyenv installation (CI, server with a custom setup, cloud environment, IDE)
 * What you are trying to achieve
 * What specifically you are doing for that regarding Pyenv
 * Where you are stuck
 **Describe the solution you'd like**
 A clear and concise description of what you want to happen.
 **Describe alternatives you've considered**
 A clear and concise description of any alternative solutions or features you've considered.
 [ ] In particular, did you consider [writing a plugin](https://github.com/pyenv/pyenv/blob/master/README.md#pyenv-plugins)? Note that if your plugin has general applicability, you can publish it in the 3rd-party plugin catalog on the Pyenv Wiki as per the link above.
 **Additional context**
 Add any other context or screenshots about the feature request here.
--- a/.github/no-response.yml
+++ b/.github/no-response.yml
@ -1,13 +0,0 @@
 # Configuration for probot-no-response - https://github.com/probot/no-response
 # Number of days of inactivity before an Issue is closed for lack of response
 daysUntilClose: 30
 # Label requiring a response
 responseRequiredLabel: need-feedback
 # Comment to post when closing an Issue for lack of response. Set to `false` to disable
 closeComment: >
  This issue has been automatically closed because there has been no response
  to our request for more information from the original author. With only the
  information that is currently in the issue, we don't have enough information
  to take action. Please reach out if you have or find the answers we need so
  that we can investigate further.
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@ -1,19 +0,0 @@
 name: tests
 on: [pull_request, push]
 jobs:
  tests:
    strategy:
      fail-fast: false
      matrix:
        os:
          - ubuntu-22.04
          - ubuntu-24.04
          - macos-14
          - macos-15
          - macos-15-intel
          - macos-26
    runs-on: ${{ matrix.os }}
    steps:
      - uses: actions/checkout@v2
      - run: git clone https://github.com/bats-core/bats-core.git --depth=1 -b v1.10.0 bats
      - run: bats/bin/bats --tap test
--- a/.gitignore
+++ b/.gitignore
@ -1,4 +1,3 @@
 /bats/
 /libexec/pyenv-virtualenv/*/*.class
 /libexec/pyenv-virtualenv/*/*.pyc
 /libexec/pyenv-virtualenv/*/*.pyo
--- a/.travis.yml
+++ b/.travis.yml
@ -1,14 +1,6 @@
-sudo: false
+install: git clone https://github.com/sstephenson/bats.git
 install: git clone --depth=1 https://github.com/sstephenson/bats.git
 script: bats/bin/bats --tap test
 language: c
 notifications:
  email:
    on_success: never
 deploy:
  provider: releases
  api_key:
    secure: DsGAt0UmTSGVfsNJ6LmM+LvsV6FYmvX4FcET82XrskPiQW+N8+8JZR8WuZxfmwdJZu+dkkdoq6gYgL2xF7m4LxRG7aw3B5TtbMTrJQeW0hdtCSBwbbYyvwcp2m7ywE8lGAfZQITaGj1R6f2Cgh8cgtcrErjcF0KJsYlVlgNv+/M=
  on:
    repo: pyenv/pyenv-virtualenv
    tags: true
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,272 +0,0 @@
 ## Version History
 ## v1.4.0
 * Fix POSIX sh (dash) compatibility in pyenv-virtualenv-init by @chrisolof in https://github.com/pyenv/pyenv-virtualenv/pull/526
 * Improve performance and output of `pyenv virtualenvs` by @samdoran in https://github.com/pyenv/pyenv-virtualenv/pull/502
 ## v1.3.0
 * CI: cleanup by @native-api in https://github.com/pyenv/pyenv-virtualenv/pull/521
 * CI: tests: use Bats 1.10; support concurrent, out-of-order and multiple-times execution of stub commands; fix race condition between concurrent stubs by @native-api in https://github.com/pyenv/pyenv-virtualenv/pull/520
 * Drastically speed up precommand hook by caching active version to skip redundant `activate` calls by @jakelodwick in https://github.com/pyenv/pyenv-virtualenv/pull/523
 ## v1.2.6
 * Fix changelog and version numbers
 ## v1.2.5
 * Add prompt customization by @jimenezj8 in https://github.com/pyenv/pyenv-virtualenv/pull/476
 * README: fix and distinguish syntax highlighting in Bash vs Fish snippets by @diericx in https://github.com/pyenv/pyenv-virtualenv/pull/489
 * Fix pyenv-virtualenv using a different Python version in a conda environment by @native-api in https://github.com/pyenv/pyenv-virtualenv/pull/492
 * Fix confusing activate/deactivate error messages when Pyenv is not installed as a shell function by @native-api in https://github.com/pyenv/pyenv-virtualenv/pull/495
 * Fix errorneously creating a symlink inside env directory if running w… by @native-api in https://github.com/pyenv/pyenv-virtualenv/pull/496
 * Update LICENSE, fix copyright license year by @JasonnnW3000 in https://github.com/pyenv/pyenv-virtualenv/pull/499
 * docs: add WSL note about core.autocrlf to prevent CRLF issues by @stoneHee99 in https://github.com/pyenv/pyenv-virtualenv/pull/512
 * docs: fix the link to Pyenv shell setup steps by @cshen-dev in https://github.com/pyenv/pyenv-virtualenv/pull/516
 * Convert issue template to new Github format by @native-api in https://github.com/pyenv/pyenv-virtualenv/pull/519
 * Prevent loss of data on `virtualenv-delete -f` if the env doesn't exist and the PREFIX envvar is set elsewhere by @SabriRamadanTNG in https://github.com/pyenv/pyenv-virtualenv/pull/518
 ## v1.2.4
 * Fix failing to detect `-m venv` when "python" is not provided by the distro by @native-api in https://github.com/pyenv/pyenv-virtualenv/pull/479
 * README: Remove dollar signs from commands that are meant to be copied by @galonsky in https://github.com/pyenv/pyenv-virtualenv/pull/481
 * Reflect pyenv-latest switch change in 2.4.8 by @native-api in https://github.com/pyenv/pyenv-virtualenv/pull/484
 ## v1.2.3
 * Fix: add `colorize` helper by @silverjam in https://github.com/pyenv/pyenv-virtualenv/pull/470
 * Bump pyenv-virtualenv reporting version to match release by @ushuz in https://github.com/pyenv/pyenv-virtualenv/pull/471
 * Add fish prompt changing by @romirk in https://github.com/pyenv/pyenv-virtualenv/pull/475
 * Don't activate if a 3rd-party venv is activated over ours by @native-api in https://github.com/pyenv/pyenv-virtualenv/pull/478
 ## v1.2.2
 * Prompt removal was never done and is not planned anymore by @native-api in https://github.com/pyenv/pyenv-virtualenv/pull/447
 * Update PYENV_VIRTUALENV_VERSION by @jack-mcivor in https://github.com/pyenv/pyenv-virtualenv/pull/449
 * Add activate/deactivate hooks by @joshfrench in https://github.com/pyenv/pyenv-virtualenv/pull/452
 * More helpful error message when requesting a nonexistent base version by @MarcinKonowalczyk in https://github.com/pyenv/pyenv-virtualenv/pull/454
 * Add fish install oneliner by @ElijahLynn in https://github.com/pyenv/pyenv-virtualenv/pull/322
 * Link python*-config into VE by @native-api in https://github.com/pyenv/pyenv-virtualenv/pull/460
 ## v1.2.1
 * Support prefixes resolved by pyenv-latest as base version names by @native-api in https://github.com/pyenv/pyenv-virtualenv/pull/446
 ## v1.2.0
 * ~/.*rc should be modified instead of ~/.*profile by @native-api in https://github.com/pyenv/pyenv-virtualenv/pull/384
 * Fixes #394 - update pyenv virtualenvs to list virtualenvs start with dot prefixes by @Gauravtalreja1 in https://github.com/pyenv/pyenv-virtualenv/pull/395
 * Fix installation steps to allow for Pyenv 2 by @native-api in https://github.com/pyenv/pyenv-virtualenv/pull/388
 * Fix get-pip.py URLs for older versions of Python by @jivanf in https://github.com/pyenv/pyenv-virtualenv/pull/403
 * Add (y/N) prompt help text by @sh-cho in https://github.com/pyenv/pyenv-virtualenv/pull/404
 * perf(sh-activate): avoid a pyenv-version-name call by @scop in https://github.com/pyenv/pyenv-virtualenv/pull/380
 * Fix unbound variable errors when running `pyenv activate` with `set -u` Use default empty value. This fixes #422. by @ackalker in https://github.com/pyenv/pyenv-virtualenv/pull/423
 * Fix another unbound variable error by @ackalker in https://github.com/pyenv/pyenv-virtualenv/pull/424
 * Update `get-pip.py` URLs in `pyenv-virtualenv` by @mcdonnnj in https://github.com/pyenv/pyenv-virtualenv/pull/426
 * Deduplicate shims in $PATH for the fish shell during initialization by @ericvw in https://github.com/pyenv/pyenv-virtualenv/pull/430
 * Upgrade uninstall hook after pyenv/pyenv#2432 by @laggardkernel in https://github.com/pyenv/pyenv-virtualenv/pull/438
 * Stop delete force failing when virtualenv does not exist by @eganjs in https://github.com/pyenv/pyenv-virtualenv/pull/330
 * fix: relative path to pyenv-realpath.dylib by @scop in https://github.com/pyenv/pyenv-virtualenv/pull/378
 * Spelling fixes by @scop in https://github.com/pyenv/pyenv-virtualenv/pull/352
 * Clone bats with --depth=1, gitignore it by @scop in https://github.com/pyenv/pyenv-virtualenv/pull/351
 * set -u fixes by @scop in https://github.com/pyenv/pyenv-virtualenv/pull/350
 * Set up Github Actions CI by @native-api in https://github.com/pyenv/pyenv-virtualenv/pull/440
 * Enhance documentation about options for `pyenv virtualenv` by @pylipp in https://github.com/pyenv/pyenv-virtualenv/pull/425
 * Return control to pyenv-uninstall in uninstall/envs.bash by @aiguofer in https://github.com/pyenv/pyenv-virtualenv/pull/321
 * Use realpath of scripts to determine relative locations by @andrew-christianson in https://github.com/pyenv/pyenv-virtualenv/pull/308
 * Shell detect improvements by @scop in https://github.com/pyenv/pyenv-virtualenv/pull/377
 ## v1.1.5
 * Fix install script (#290, #302)
 ## v1.1.4
 * Support newer conda (#290)
 * Prefer `python3.x` executable if available (#206, #282, #296)
 ## v1.1.3
 * No code changes since 1.1.2
 ## v1.1.2
 * Use custom get-pip URL based on the target version (#253, #254, #255)
 * Source conda 4.4.4 shell files (#251)
 * Evaluate force flag before testing if venv exists (#232)
 ## v1.1.1
 * Set `CONDA_PREFIX` to make is useable in conda activate/deactivate scripts (#224)
 * Generate `pydoc` executable after creating new virtualenv (#197, #230)
 ## v1.1.0
 * fish: use "set -gx" instead of "setenv" (#215, #216, #217, #218)
 ## v1.0.0
 * Use similar versioning scheme as pyenv; YYYYMMDD -> X.Y.Z
 ## v20160716
 * Suppress activate/deactivate messages by default (#169, #170, #171)
 * Source conda package activate/deactivat scripts if exist (#173)
 * Use `source` in favor of `.` for `fish` (#175)
 * Use `python -m venv` instead of `pyvenv` due to deprecation of `pyvenv` after 3.6 (#184, #185)
 ## v20160315
 * Evaluate `${PATH}` when outputted code is eval'd. (#154)
 * Set proper `CONDA_DEFAULT_ENV` for shorter name (#160)
 ## v20160202
 * Install virtualenv 13.1.2 for CPython/Stackless 3.2.x (yyuu/pyenv#531)
 ## v20160112
 * Fix problem with `virtualenv` to look up executables from source version with `--system-site-packages` (#62)
 ## v20151229
 * Fix `deactivate` error on `fish` (#136)
 ## v20151222
 * Improved interoperability with Anaconda/Miniconda (#103, #106, #107, #108)
 * Create `virtualenv` inside `envs` directory of source version, like Anaconda/Miniconda (#103, #107)
 * Rewrite `pyenv activate` and `pyenv deactivate` without using scripts provided by virtualenv and conda (#51, #69, #103, #104, #121)
 * Improve the `pyenv activate` behaviour on multiple versions (#105, #111)
 * Reject creating a virtualenv named `system` (yyuu/pyenv#475)
 * Add `--skip-aliases` to `pyenv virtualenvs` (#120)
 * Stop showing `version not installed` warning messages in precmd (#49)
 ## v20151103
 * Passing return value from executed command. (#100)
 * Add workaround for commands installed in a virtual environment created by `pyvenv` (#62)
 * init: zsh: prepend hook to `precmd_functions` (#101)
 ## v20151006
 * 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)
 ## v20150719
 * 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)
 ## v20150526
 * Use `typeset -g` with `precmd_functions` (#75)
 * activate: display setup instructions only with `PYENV_VIRTUALENV_INIT=0` (#78)
 * Ignore failure of pyenv activate (#68)
 ## v20150119
 * 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)
 ## v20141106
 * Stop creating after `ensurepip` since it has done by `ensurepip` itself
 * Suppress some useless warnings from `pyenv virtualenv-init`
 ## v20141012
 * 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)
 ## v20140705
 * 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`
 ## v20140615
 * Fix incompatibility issue of `pyenv activate` and `pyenv deactivate` (#26)
 * Workaround for the issue with pyenv-which-ext (#26)
 ## v20140614
 * Add `pyenv virtualenv-init` to enable auto-activation feature (#24)
 * Create symlinks for executables with version suffix (yyuu/pyenv#182)
 ## v20140602
 * 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)
 ## v20140421
 * 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)
 ## v20140123
 * 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
 ## v20140110.1
 * Fix install script
 ## v20140110
 * Support environment variables of `EZ_SETUP` and `GET_PIP`.
 * Support a short option `-p` of `virtualenv`.
 ## v20131216
 * Use latest release of setuptools and pip if the version not given via environment variables.
 ## v20130622
 * 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`.
 ## v20130614
 * Add `pyenv virtualenvs` to list all virtualenv versions.
 * *EXPERIMENTAL*: Add `--upgrade` option to re-create virtualenv with migrating packages
 ## v20130527
 * 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.
 ## v20130507
 * Display virtualenv information in `--help` and `--version`
 * Update virtualenv version; 1.8.4 -> 1.9.1
 ## v20130307
 * 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
 ## v20130218
 * Add pyenv 0.2.x (rbenv 0.4.x) style help messages.
 ## v20121023
 * 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.
 ## v20120927
 * Initial public release.
--- a/2
+++ b/2
@ -1,4 +1,4 @@
-Copyright (c) 2025 Yamashita, Yuu
+Copyright (c) 2013 Yamashita, Yuu
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
--- a/MAINTENANCE.md
+++ b/MAINTENANCE.md
@ -1,15 +0,0 @@
 Creating a release
 ==================
 The release of the new version of Pyenv is done via GitHub Releases.
 Release checklist:
 * Start [drafting a new release on GitHub](https://github.com/pyenv/pyenv-virtualenv/releases) to generate a summary of changes. Save the summary locally.
  * The summary may need editing. E.g. rephrase entries, delete/merge entries that are too minor or irrelevant to the users (e.g. typo fixes, CI)
 * Push the version number in `bin/pyenv-virtualenv`
  * Minor version is pushed if there are significant functional changes (not e.g. bugfixes/formula adaptations/supporting niche use cases).
  * Major version is pushed if there are breaking changes
 * Update `CHANGELOG.md` with the new version number and the edited summary (only the changes section), reformatting it like the rest of the changelog sections
 * Commit the changes locally into `master`
 * Create a new tag with the new version number and push the changes including the tag
 * Create a new release on GitHub based on the tag, using the saved summary
--- a/README.md
+++ b/README.md
@ -1,266 +1,263 @@
 # pyenv-virtualenv
-[![Join the chat at https://gitter.im/yyuu/pyenv-virtualenv](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/yyuu/pyenv-virtualenv?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![Build Status](https://travis-ci.org/yyuu/pyenv-virtualenv.png)](https://travis-ci.org/yyuu/pyenv-virtualenv)
-[![Build Status](https://travis-ci.org/pyenv/pyenv-virtualenv.svg?branch=master)](https://travis-ci.org/pyenv/pyenv-virtualenv)
+pyenv-virtualenv is a [pyenv](https://github.com/yyuu/pyenv) plugin
-
+that provides a `pyenv virtualenv` command to create virtualenv for Python
-pyenv-virtualenv is a [pyenv](https://github.com/pyenv/pyenv) plugin
+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/pyenv/pyenv-virtualenvwrapper) may help you
+and you love it, [pyenv-virtualenvwrapper](https://github.com/yyuu/pyenv-virtualenvwrapper) may help you
-(additionally) to manage your virtualenvs.)
+to manage your virtualenvs.)
 ## Installation
 ### Installing as a pyenv plugin
 This will install the latest development version of pyenv-virtualenv into
-the `$(pyenv root)/plugins/pyenv-virtualenv` directory.
+the `~/.pyenv/plugins/pyenv-virtualenv` directory. 
-**Important note:**  If you installed pyenv into a non-standard directory, make
+**Important note:**  If you installed pyenv into a non-standard directory, make sure that you clone this
-sure that you clone this repo into the 'plugins' directory of wherever you
+repo into the 'plugins' directory of wherever you installed into.
 installed into.
 From inside that directory you can:
- - Check out a specific release tag.
+ - Check out a specific release tag. 
- - Get the latest development release by running `git pull` to download the
+ - Get the latest development release by running `git pull` to download the latest changes.
   latest changes.
 💡 **WSL note:** If you're using WSL, we recommend setting Git to use Unix-style line endings to prevent script execution errors:
 ```sh
 git config --global core.autocrlf input
 ```
 1. **Check out pyenv-virtualenv into plugin directory**
-    ```bash
+        $ git clone https://github.com/yyuu/pyenv-virtualenv.git ~/.pyenv/plugins/pyenv-virtualenv
    git clone https://github.com/pyenv/pyenv-virtualenv.git $(pyenv root)/plugins/pyenv-virtualenv
    ```
-    For the Fish shell:
+2. **Add `pyenv virtualenv-init` to your shell** to enable activation of virtualenv. This is entirely optional but pretty useful.
-    ```fish
+        $ echo 'eval "$(pyenv virtualenv-init -)"' >> ~/.bash_profile
    git clone https://github.com/pyenv/pyenv-virtualenv.git (pyenv root)/plugins/pyenv-virtualenv
    ```
-2. (OPTIONAL) **Add `pyenv virtualenv-init` to your shell** to enable auto-activation of virtualenvs. This is entirely optional but pretty useful. See "Activate virtualenv" below.
+    **Zsh note**: Modify your `~/.zshenv` file instead of `~/.bash_profile`.
-    ```bash
+3. **Restart your shell to the enable pyenv-virtualenv**
    echo 'eval "$(pyenv virtualenv-init -)"' >> ~/.bashrc
    ```
-    **Fish shell note**:  Add this to your `~/.config/fish/config.fish`
+        $ exec "$SHELL"
    ```fish
    status --is-interactive; and pyenv virtualenv-init - | source
    ```
    **Zsh note**: Modify your `~/.zshrc` file instead of `~/.bashrc`.
 3. **Restart your shell to enable pyenv-virtualenv**
    ```bash
    exec "$SHELL"
    ```
-### Installing with Homebrew (for macOS users)
+### Installing with Homebrew (for OS X users)
-macOS users can install pyenv-virtualenv with the
+Mac OS X users can install pyenv-virtualenv with the
-[Homebrew](https://brew.sh) package manager.
+[Homebrew](http://brew.sh) package manager. This
-This will give you access to the `pyenv-virtualenv` command. If you have pyenv
+will give you access to the `pyenv-virtualenv` command. If you have pyenv
 installed, you will also be able to use the `pyenv virtualenv` command.
-*This is the recommended method of installation if you installed pyenv
+*This is recommended method of installation if you installed pyenv
 with Homebrew.*
-```sh
+```
-brew install pyenv-virtualenv
+$ brew install pyenv-virtualenv
 ```
 Or, if you would like to install the latest development release:
-```sh
+```
-brew install --HEAD pyenv-virtualenv
+$ brew install --HEAD pyenv-virtualenv
 ```
-After installation, you'll still need to do
+After installation, you'll still need to add `eval "$(pyenv virtualenv-init -)"` to your
-[Pyenv shell setup steps](https://github.com/pyenv/pyenv#b-set-up-your-shell-environment-for-pyenv)
+profile (as stated in the caveats). You'll only ever have to do this once.
 then add 
 ```sh
 eval "$(pyenv virtualenv-init -)"
 ```
 to your shell's `.rc` file (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 used with pyenv, run
+To create a virtualenv for the Python version use with pyenv, run
 `pyenv virtualenv`, specifying the Python version you want and the name
 of the virtualenv directory. For example,
-```sh
+```
-pyenv virtualenv 2.7.10 my-virtual-env-2.7.10
+$ pyenv virtualenv 2.7.7 my-virtual-env-2.7.7
 ```
-will create a virtualenv based on Python 2.7.10 under `$(pyenv root)/versions` in a
+will create a virtualenv based on Python 2.7.7
-folder called `my-virtual-env-2.7.10`.
+under `~/.pyenv/versions` in a folder called `my-virtual-env-2.7.7`. 
 `pyenv virtualenv` forwards any options to the underlying command that actually
 creates the virtual environment (`conda`, `virtualenv`, or `python -m venv`).
 See the output of `pyenv virtualenv --help` for details.
 ### Create virtualenv from current version
-If there is only one argument given to `pyenv virtualenv`, the virtualenv will
+If there is only one argument is given to `pyenv virtualenv`,
-be created with the given name based on the current pyenv Python version.
+virtualenv will be created with given name based on current
 version.
-```sh
+```
 $ pyenv version
-3.4.3 (set by /home/yyuu/.pyenv/version)
+3.4.1 (set by /home/yyuu/.pyenv/version)
 $ pyenv virtualenv venv34
 ```
 ### List existing virtualenvs
-`pyenv virtualenvs` shows you the list of existing virtualenvs and `conda` environments.
+`pyenv virtualenvs` shows you the list of existing virtualenvs.
 ```sh
 $ pyenv shell venv34
 $ 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)
  2.7.10/envs/my-virtual-env-2.7.10 (created from /home/yyuu/.pyenv/versions/2.7.10)
  3.4.3/envs/venv34 (created from /home/yyuu/.pyenv/versions/3.4.3)
  my-virtual-env-2.7.10 (created from /home/yyuu/.pyenv/versions/2.7.10)
 * venv34 (created from /home/yyuu/.pyenv/versions/3.4.3)
 ```
-
+$ pyenv shell venv27
-There are two entries for each virtualenv, and the shorter one is just a symlink.
+$ pyenv virtualenvs
 * venv27 (created from /home/yyuu/.pyenv/versions/2.7.7)
  venv34 (created from /home/yyuu/.pyenv/versions/3.4.1)
 ```
 ### Activate virtualenv
-Some external tools (e.g. [jedi](https://github.com/davidhalter/jedi)) might
+Some external tools (e.g. [jedi](https://github.com/davidhalter/jedi)) might require you to `activate` the virtualenv.
-require you to `activate` the virtualenv and `conda` environments.
+The `pyenv-virtualenv` will automatically activate/deactivate the virtualenv if the `eval "$(pyenv virtualenv-init -)"` is properly configured in your shell.
-If `eval "$(pyenv virtualenv-init -)"` is configured in your shell, `pyenv-virtualenv` will automatically activate/deactivate virtualenvs on entering/leaving directories which contain a `.python-version` file that contains the name of a valid virtual environment as shown in the output of `pyenv virtualenvs` (e.g., `venv34` or `3.4.3/envs/venv34` in example above) . `.python-version` files are used by pyenv to denote local Python versions and can be created and deleted with the [`pyenv local`](https://github.com/pyenv/pyenv/blob/master/COMMANDS.md#pyenv-local) command.
+You can also activate and deactivate a pyenv virtualenv this way:
-You can also activate and deactivate a pyenv virtualenv manually:
+    pyenv activate <name>
-
+    pyenv deactivate
 ```sh
 pyenv activate <name>
 pyenv deactivate
 ```
 ### Delete existing virtualenv
-Removing the directories in `$(pyenv root)/versions` and `$(pyenv root)/versions/{version}/envs` will delete the virtualenv, or you can run:
+Removing the directory in `~/.pyenv/versions` will delete the virtualenv, or you can run:
-```sh
+    pyenv uninstall my-virtual-env
-pyenv uninstall my-virtual-env
+    
 ```
-You can also delete existing virtualenvs by using `virtualenv-delete` command, e.g. you can run:
+### virtualenv and pyvenv
 ```sh
 pyenv virtualenv-delete my-virtual-env
 ```
 This will delete virtualenv called `my-virtual-env`.
 There is [venv](http://docs.python.jp/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.
-### virtualenv and venv
+The `pyenv-virtualenv` uses `pyvenv` if it is available and the `virtualenv` is not available.
 There is a [venv](http://docs.python.org/3/library/venv.html) module available
 for CPython 3.3 and newer.
 It provides an executable module `venv` which is the successor of `virtualenv`
 and distributed by default.
 `pyenv-virtualenv` uses `python -m venv` if it is available and the `virtualenv`
 command is not available.
 ### Anaconda and Miniconda
 You can manage `conda` environments by `conda create` as same manner as standard Anaconda/Miniconda installations.
 To use those environments, you can use `pyenv activate` and `pyenv deactivate`.
 ```sh
 $ pyenv version
 miniconda3-3.9.1 (set by /home/yyuu/.pyenv/version)
 $ 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
 $ pyenv activate miniconda3-3.9.1/envs/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
 $ python --version
 Python 3.4.3 :: Continuum Analytics, Inc.
 $ pyenv deactivate
 discarding /home/yyuu/.pyenv/versions/miniconda3-3.9.1/envs/myenv/bin from PATH
 ```
 If `conda` is available, `pyenv virtualenv` will use it to create environment by `conda create`.
 ```sh
 $ pyenv version
 miniconda3-3.9.1 (set by /home/yyuu/.pyenv/version)
 $ pyenv virtualenv myenv2
 $ conda env list
 # conda environments:
 #
 myenv                    /home/yyuu/.pyenv/versions/miniconda3-3.9.1/envs/myenv
 myenv                    /home/yyuu/.pyenv/versions/miniconda3-3.9.1/envs/myenv2
 root                  *  /home/yyuu/.pyenv/versions/miniconda3-3.9.1
 ```
 You can use version like `miniconda3-3.9.1/envs/myenv` to specify `conda` environment as a version in pyenv.
 ```sh
 $ pyenv version
 miniconda3-3.9.1 (set by /home/yyuu/.pyenv/version)
 $ pyenv shell miniconda3-3.9.1/envs/myenv
 $ which python
 /home/yyuu/.pyenv/versions/miniconda3-3.9.1/envs/myenv/bin/python
 ```
 ### Special environment variables
-You can set certain environment variables to control pyenv-virtualenv.
+You can set certain environment variables to control the 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 the desired
+* `VIRTUALENV_VERSION`, if set, forces pyenv-virtualenv to install desired
-  version of virtualenv. If `virtualenv` has not been installed,
+  version of virtualenv. If the virtualenv has not been installed,
  pyenv-virtualenv will try to install the given version of virtualenv.
-* `GET_PIP`, if set and `venv` is preferred over `virtualenv`,
+* `EZ_SETUP` and `GET_PIP`, if set and pyvenv is preferred than virtualenv,
-  use `get_pip.py` from the specified location.
+  use `ez_setup.py` and `get_pip.py` at specified location.
-* `GET_PIP_URL`, if set and `venv` is preferred over
+* `EZ_SETUP_URL` and `GET_PIP_URL`, if set and pyvenv is preferred
-  `virtualenv`, download `get_pip.py` from the specified URL.
+  than virtualenv, download `ez_setup.py` and `get_pip.py` from specified URL.
-* `PIP_VERSION`, if set and `venv` is preferred
+* `SETUPTOOLS_VERSION` and `PIP_VERSION`, if set and pyvenv is preferred
-  over `virtualenv`, install the specified version of pip.
+  than virtualenv, install specified version of setuptools and pip.
-* `PYENV_VIRTUALENV_VERBOSE_ACTIVATE`, if set, shows some verbose outputs on activation and deactivation
+
 * `PYENV_VIRTUALENV_PROMPT`, if set, allows users to customize how `pyenv-virtualenv` modifies their shell prompt. The default prompt ("(venv)") is overwritten with any user-specified text. Specify the location of the virtual environment name with the string `{venv}`. For example, the default prompt string would be `({venv})`.
 ## Version History
-See [CHANGELOG.md](CHANGELOG.md).
+#### 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.
 ### License
-[(The MIT License)](LICENSE)
+(The MIT License)
-* Copyright (c) 2015 Yamashita, Yuu
+* Copyright (c) 2013 Yamashita, Yuu
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
--- a/bin/pyenv-activate
+++ b/bin/pyenv-activate
@ -22,8 +22,10 @@ fi
 { printf "\x1B[31;1m"
  echo
-  echo "\`pyenv activate' requires Pyenv and Pyenv-Virtualenv to be loaded into your shell."
+  echo "Failed to activate virtualenv."
-  echo "Check your shell configuration and Pyenv and Pyenv-Virtualenv installation instructions."
+  echo
  echo "Perhaps pyenv-virtualenv has not been loaded into your shell properly."
  echo "Please restart current shell and try again."
  echo
  printf "\x1B[0m"
 } 1>&2
--- a/bin/pyenv-deactivate
+++ b/bin/pyenv-deactivate
@ -11,8 +11,10 @@ set -e
 { printf "\x1B[31;1m"
  echo
-  echo "\`pyenv deactivate' requires Pyenv and Pyenv-Virtualenv to be loaded into your shell."
+  echo "Failed to deactivate virtualenv."
-  echo "Check your shell configuration and Pyenv and Pyenv-Virtualenv installation instructions."
+  echo
  echo "Perhaps pyenv-virtualenv has not been loaded into your shell properly."
  echo "Please restart current shell and try again."
  echo
  printf "\x1B[0m"
 } 1>&2
--- a/bin/pyenv-sh-activate
+++ b/bin/pyenv-sh-activate
@ -14,37 +14,8 @@
 set -e
 [ -n "$PYENV_DEBUG" ] && set -x
-if [ -z "${PYENV_ROOT}" ]; then
+unset NOERROR
-  PYENV_ROOT="$(pyenv-root)"
+unset VERBOSE
 fi
 resolve_link() {
  $(type -p greadlink readlink | head -1) "$1"
 }
 unset FORCE
 unset QUIET
 # Define `before_activate` and `after_activate` functions that allow
 # plugin hooks to register a string of code for execution before or
 # after activating a virtualenv.
 declare -a before_hooks after_hooks
 before_activate() {
  local hook="$1"
  before_hooks["${#before_hooks[@]}"]="$hook"
 }
 after_activate() {
  local hook="$1"
  after_hooks["${#after_hooks[@]}"]="$hook"
 }
 # Load plugin hooks.
 OLDIFS="$IFS"
 IFS=$'\n' scripts=(`pyenv-hooks activate`)
 IFS="$OLDIFS"
 for script in "${scripts[@]}"; do source "$script"; done
 while [ $# -gt 0 ]; do
  case "$1" in
@ -53,18 +24,15 @@ while [ $# -gt 0 ]; do
    echo --unset
    exec pyenv-virtualenvs --bare
    ;;
-  "-f" | "--force" )
+  "--no-error" )
-    FORCE=1
+    NOERROR=1
    ;;
  "-q" | "--quiet" )
    QUIET=1
    ;;
  "--unset" )
-    exec pyenv-sh-deactivate
+    echo "pyenv deactivate"
    exit
    ;;
-  "-v" | "--verbose" )
+  "--verbose" )
-    unset QUIET
+    VERBOSE=1
    PYENV_VIRTUALENV_VERBOSE_ACTIVATE=1
    ;;
  * )
    break
@ -73,18 +41,12 @@ while [ $# -gt 0 ]; do
  shift 1
 done
 get_current_versions() {
  local IFS=:
  current_versions=($(pyenv-version-name 2>/dev/null))
 }
 no_shell=
 versions=("$@")
-current_versions=()
+if [ -z "$versions" ]; then
 if [ -z "${versions}" ]; then
  no_shell=1
-  get_current_versions
+  OLDIFS="$IFS"
-  versions=("${current_versions[@]}")
+  IFS=: versions=($(pyenv-version-name))
  IFS="$OLDIFS"
 fi
 if [ -z "${PYENV_VIRTUALENV_INIT}" ]; then
@ -93,213 +55,64 @@ if [ -z "${PYENV_VIRTUALENV_INIT}" ]; then
  no_shell=
 fi
-venv="${versions}"
+if [ "${#versions[@]}" -gt 1 ]; then
-
+  [ -n "$NOERROR" ] || echo "pyenv-virtualenv: cannot activate multiple versions at once: ${versions[@]}" 1>&2
-if [ -n "${VIRTUAL_ENV}" ]; then
+  echo "false"
-  # exit as success if a non-pyenv virtualenv is active
+  exit 1
  if [[ -z $PYENV_VIRTUAL_ENV || $PYENV_VIRTUAL_ENV != "$VIRTUAL_ENV" ]]; then
    if [ -z "${FORCE}" ]; then
      if [ -z "${QUIET}" ]; then
        echo "pyenv-virtualenv: virtualenv \`${VIRTUAL_ENV}' is already activated" 1>&2
      fi
      echo "true"
      exit 0
    fi
  fi
 fi
-if ! pyenv-virtualenv-prefix "${venv}" 1>/dev/null 2>&1; then
+if ! pyenv-virtualenv-prefix "${versions}" 1>/dev/null 2>&1; then
-  # fallback to virtualenv of current version
+  [ -n "$NOERROR" ] || echo "pyenv-virtualenv: version \`${versions}' is not a virtualenv" 1>&2
-  [ -n "${current_versions}" ] || get_current_versions
+  echo "false"
-  new_venv="${current_versions%/envs/*}/envs/${venv}"
+  exit 1
  if pyenv-virtualenv-prefix "${new_venv}" 1>/dev/null 2>&1; then
    venv="${new_venv}"
    versions[0]="${new_venv}"
  else
    if [ -z "${QUIET}" ]; then
      echo "pyenv-virtualenv: version \`${venv}' is not a virtualenv" 1>&2
    fi
    echo "false"
    exit 1
  fi
 fi
-# exit as error if there are multiple virtualenvs
+shell="$(basename "${PYENV_SHELL:-$SHELL}")"
-# https://github.com/yyuu/pyenv-virtualenv/issues/105
+case "$shell" in
-for version in "${versions[@]}"; do
+bash )
-  if [[ "${version}" != "${venv}" ]]; then
+  profile="$HOME/.bash_profile"
-    if pyenv-virtualenv-prefix "${version}" 1>/dev/null 2>&1; then
+  ;;
-      if [ -z "${QUIET}" ]; then
+zsh )
-        echo "pyenv-virtualenv: cannot activate multiple versions at once: ${versions[@]}" 1>&2
+  profile="$HOME/.zshrc"
-      fi
+  ;;
-      echo "false"
+ksh )
-      exit 1
+  profile="$HOME/.profile"
-    fi
+  ;;
  fi
 done
 shell="${PYENV_SHELL:-${SHELL##*/}}"
 prefix="$(pyenv-prefix "${venv}")"
 if [ -L "${prefix}" ]; then
  prefix="$(resolve_link "${prefix}" 2>/dev/null)"
 fi
 # exit as success if the virtualenv is already activated
 if [[ "${VIRTUAL_ENV}" == "${prefix}" ]]; then
  if [ -z "${FORCE}" ]; then
    if [ -z "${QUIET}" ]; then
      echo "pyenv-virtualenv: version \`${venv}' is already activated" 1>&2
    fi
    echo "true"
    exit 0
  fi
 fi
 pyenv-sh-deactivate --force --quiet || true
 # Execute `before_activate` hooks.
 for hook in "${before_hooks[@]}"; do eval "$hook"; done
 if [ -n "$PYENV_VIRTUALENV_VERBOSE_ACTIVATE" ]; then
  echo "pyenv-virtualenv: activate ${venv}" 1>&2
 fi
 if [ -z "$no_shell" ]; then
  # shell version set in pyenv-sh-activate should be unset
  # https://github.com/yyuu/pyenv-virtualenv/issues/61
  OLDIFS="$IFS"
  IFS=:
  case "$shell" in
  fish )
    cat <<EOS
 set -gx PYENV_VERSION "${versions[*]}";
 set -gx PYENV_ACTIVATE_SHELL 1;
 EOS
    ;;
  * )
    cat <<EOS
 export PYENV_VERSION="${versions[*]}";
 export PYENV_ACTIVATE_SHELL=1;
 EOS
    ;;
  esac
  IFS="$OLDIFS"
 fi
 # virtualenv/venv
 case "${shell}" in
 fish )
-  cat <<EOS
+  profile="$HOME/.config/fish/config.fish"
 set -gx PYENV_VIRTUAL_ENV "${prefix}";
 set -gx VIRTUAL_ENV "${prefix}";
 EOS
  ;;
 * )
-  cat <<EOS
+  profile="$HOME/.profile"
 export PYENV_VIRTUAL_ENV="${prefix}";
 export VIRTUAL_ENV="${prefix}";
 EOS
  ;;
 esac
-# anaconda/miniconda
+# Display setup instruction if 'pyenv virtualenv-init -' is not found in "$profile"
-if [ -d "${prefix}/conda-meta" ] ||
+if [ -f "$profile" ] && grep -q 'pyenv init -' "$profile" && ! grep -q 'pyenv virtualenv-init -' "$profile"; then
-     [ -x "${prefix}/bin/conda" ]; then
+  pyenv-virtualenv-init >&2 || true
  if [[ "${prefix}" != "${prefix%/envs/*}" ]]; then
    CONDA_DEFAULT_ENV="${venv##*/envs/}"
  else
    CONDA_DEFAULT_ENV="root"
  fi
  case "${shell}" in
  fish )
    echo "set -gx CONDA_DEFAULT_ENV \"${CONDA_DEFAULT_ENV}\";"
    ;;
  * )
    echo "export CONDA_DEFAULT_ENV=\"${CONDA_DEFAULT_ENV}\";"
    ;;
  esac
 fi
-if [ -n "${PYTHONHOME}" ]; then
+if [ -n "$VERBOSE" ]; then
-  case "${shell}" in
+  echo "pyenv-virtualenv: activate ${versions}" 1>&2
  fish )
    cat <<EOS
 set -gx _OLD_VIRTUAL_PYTHONHOME "${PYTHONHOME}";
 set -e PYTHONHOME;
 EOS
    ;;
  * )
    cat <<EOS
 export _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME}";
 unset PYTHONHOME;
 EOS
    ;;
  esac
 fi
-PYENV_VIRTUALENV_DISABLE_PROMPT="${PYENV_VIRTUALENV_DISABLE_PROMPT:-${PYENV_VIRTUAL_ENV_DISABLE_PROMPT}}"
+if [ -z "$no_shell" ]; then
-PYENV_VIRTUALENV_DISABLE_PROMPT="${PYENV_VIRTUALENV_DISABLE_PROMPT:-${VIRTUAL_ENV_DISABLE_PROMPT}}"
+  echo "pyenv shell \"${versions}\";"
 if [ -z "${PYENV_VIRTUALENV_DISABLE_PROMPT}" ]; then
  case "${shell}" in
  fish )
    if [ -z "${QUIET}" ]; then
      cat <<EOS
 functions -e _pyenv_old_prompt              # remove old prompt function if exists. 
                                            # since everything is in memory, it's safe to
                                            # remove it.
 functions -c fish_prompt _pyenv_old_prompt  # backup old prompt function
 # from python-venv
 function fish_prompt
    set -l prompt (_pyenv_old_prompt)       # call old prompt function first since it might 
                                            # read exit status
    echo -n "(${venv}) "                    # add virtualenv to prompt
    string join -- \n \$prompt              # handle multiline prompts
 end
 EOS
    fi
    ;;
  * )
    if [ -z "${PYENV_VIRTUALENV_PROMPT}" ]; then
      PYENV_VIRTUALENV_PROMPT="(${venv})"
    else
      PYENV_VIRTUALENV_PROMPT="${PYENV_VIRTUALENV_PROMPT/\{venv\}/${venv}}"
    fi
    cat <<EOS
 export _OLD_VIRTUAL_PS1="\${PS1:-}";
 export PS1="${PYENV_VIRTUALENV_PROMPT} \${PS1:-}";
 EOS
    ;;
  esac
 fi
-# conda package anaconda/miniconda scripts (#173)
+prefix="$(pyenv-prefix "${versions}")"
-if [ -d "${prefix}/conda-meta" ] ||
+case "$shell" in
-     [ -x "${prefix}/bin/conda" ]; then
+fish )
-  shopt -s nullglob
+  cat <<EOS
-  case "${shell}" in
+set -e PYENV_DEACTIVATE;
-  fish )
+setenv PYENV_ACTIVATE "${prefix}";
-    # conda 4.4 and above
+. "${prefix}/bin/activate.fish";
-    for script in "${prefix}/etc/fish/conf.d"/*.fish; do
+EOS
-      echo "source \"${script}\";"
+ ;;
-    done
+*    )
-    ;;
+  cat <<EOS
-  * )
+unset PYENV_DEACTIVATE;
-    CONDA_PREFIX="$prefix"
+export PYENV_ACTIVATE="${prefix}";
-    echo "export CONDA_PREFIX=\"${CONDA_PREFIX}\";"
+. "${prefix}/bin/activate";
-    for script in "${prefix}/etc/conda/activate.d"/*.sh; do
+EOS
-      echo ". \"${script}\";"
+  ;;
-    done
+esac
    # conda 4.4 and above
    for script in "${prefix}/etc/profile.d"/*.sh; do
      echo ". \"${script}\";"
    done
    ;;
  esac
  shopt -u nullglob
 fi
 # Execute `after_activate` hooks.
 for hook in "${after_hooks[@]}"; do eval "$hook"; done
--- a/bin/pyenv-sh-deactivate
+++ b/bin/pyenv-sh-deactivate
@ -9,45 +9,16 @@
 set -e
 [ -n "$PYENV_DEBUG" ] && set -x
-if [ -z "${PYENV_ROOT}" ]; then
+unset NOERROR
-  PYENV_ROOT="$(pyenv-root)"
+unset VERBOSE
 fi
 unset FORCE
 unset QUIET
 # Define `before_deactivate` and `after_deactivate` functions that allow
 # plugin hooks to register a string of code for execution before or
 # after deactivating a virtualenv.
 declare -a before_hooks after_hooks
 before_deactivate() {
  local hook="$1"
  before_hooks["${#before_hooks[@]}"]="$hook"
 }
 after_deactivate() {
  local hook="$1"
  after_hooks["${#after_hooks[@]}"]="$hook"
 }
 # Load plugin hooks.
 OLDIFS="$IFS"
 IFS=$'\n' scripts=(`pyenv-hooks deactivate`)
 IFS="$OLDIFS"
 for script in "${scripts[@]}"; do source "$script"; done
 while [ $# -gt 0 ]; do
  case "$1" in
-  "-f" | "--force" )
+  "--no-error" )
-    FORCE=1
+    NOERROR=1
    ;;
-  "-q" | "--quiet")
+  "--verbose" )
-    QUIET=1
+    VERBOSE=1
    ;;
  "-v" | "--verbose" )
    unset QUIET
    PYENV_VIRTUALENV_VERBOSE_ACTIVATE=1
    ;;
  * )
    break
@ -56,173 +27,58 @@ while [ $# -gt 0 ]; do
  shift 1
 done
 if [ -z "${VIRTUAL_ENV}" ]; then
  if [ -z "${FORCE}" ]; then
    if [ -z "${QUIET}" ]; then
      echo "pyenv-virtualenv: no virtualenv has been activated." 1>&2
    fi
    echo "false"
    exit 1
  fi
 fi
 shell="$(basename "${PYENV_SHELL:-$SHELL}")"
-prefix="${VIRTUAL_ENV}"
+case "$shell" in
 fish )
  echo "if functions -q deactivate;"
  ;;
 *    )
  echo "if declare -f deactivate 1>/dev/null 2>&1; then"
  ;;
 esac
-if [[ "${prefix%/*/envs/*}" == "${PYENV_ROOT}/versions" ]]; then
+prefix="${PYENV_ACTIVATE:-${VIRTUAL_ENV}}"
-  venv="${prefix#${PYENV_ROOT}/versions/}"
+
 if [ -n "$VERBOSE" ]; then
  echo "  echo \"pyenv-virtualenv: deactivate ${prefix##*/}\" 1>&2;"
 fi
 if [ -z "${PYENV_VIRTUALENV_INIT}" ]; then
  # Backward compatibility issue
  # https://github.com/yyuu/pyenv-virtualenv/issues/26
  echo "  pyenv shell --unset;"
 fi
 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
  venv="${prefix##*/}"
 fi
 # Execute `before_deactivate` hooks.
 for hook in "${before_hooks[@]}"; do eval "$hook"; done
 if [ -n "$PYENV_VIRTUALENV_VERBOSE_ACTIVATE" ]; then
  echo "pyenv-virtualenv: deactivate ${venv}" 1>&2
 fi
 # conda package anaconda/miniconda scripts (#173)
 if [ -d "${prefix}/conda-meta" ] ||
     [ -x "${prefix}/bin/conda" ]; then
  shopt -s nullglob
  case "${shell}" in
  fish )
    : # conda doesn't support fish
    ;;
  * )
    for script in "${prefix}/etc/conda/deactivate.d"/*.sh; do
      echo ". \"${script}\";"
    done
    echo "unset CONDA_PREFIX"
    ;;
  esac
  shopt -u nullglob
 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
  case "$shell" in
  fish )
    cat <<EOS
 set -e PYENV_VERSION;
 set -e PYENV_ACTIVATE_SHELL;
 EOS
    ;;
  * )
    cat <<EOS
 unset PYENV_VERSION;
 unset PYENV_ACTIVATE_SHELL;
 EOS
    ;;
  esac
 fi
 # virtualenv/venv
 case "${shell}" in
 fish )
  cat <<EOS
 set -e PYENV_VIRTUAL_ENV;
 set -e VIRTUAL_ENV;
 EOS
  ;;
 * )
  cat <<EOS
 unset PYENV_VIRTUAL_ENV;
 unset VIRTUAL_ENV;
 EOS
  ;;
 esac
-# anaconda/miniconda
+if [ -z "$NOERROR" ]; then
-if [ -n "${CONDA_DEFAULT_ENV}" ]; then
+  echo "  echo \"pyenv-virtualenv: no virtualenv has been activated.\" 1>&2;"
  case "${shell}" in
  fish )
    echo "set -e CONDA_DEFAULT_ENV;"
    ;;
  * )
    echo "unset CONDA_DEFAULT_ENV;"
    ;;
  esac
 fi
-case "${shell}" in
+echo "  false;"
 case "$shell" in
 fish )
-  cat <<EOS
+  echo "end;"
 if [ -n "\$_OLD_VIRTUAL_PATH" ];
  set -gx PATH "\$_OLD_VIRTUAL_PATH";
  set -e _OLD_VIRTUAL_PATH;
 end;
 EOS
  ;;
-* )
+*    )
-  cat <<EOS
+  echo "fi;"
 if [ -n "\${_OLD_VIRTUAL_PATH:-}" ]; then
  export PATH="\${_OLD_VIRTUAL_PATH}";
  unset _OLD_VIRTUAL_PATH;
 fi;
 EOS
  ;;
 esac
 case "${shell}" in
 fish )
  cat <<EOS
 if [ -n "\$_OLD_VIRTUAL_PYTHONHOME" ];
  set -gx PYTHONHOME "\$_OLD_VIRTUAL_PYTHONHOME";
  set -e _OLD_VIRTUAL_PYTHONHOME;
 end;
 EOS
  ;;
 * )
  cat <<EOS
 if [ -n "\${_OLD_VIRTUAL_PYTHONHOME:-}" ]; then
  export PYTHONHOME="\${_OLD_VIRTUAL_PYTHONHOME}";
  unset _OLD_VIRTUAL_PYTHONHOME;
 fi;
 EOS
  ;;
 esac
 case "${shell}" in
 fish )
  cat <<EOS
 # check if old prompt function exists
 if functions -q _pyenv_old_prompt
  # remove old prompt function if exists.
  functions -e fish_prompt
  functions -c _pyenv_old_prompt fish_prompt
  functions -e _pyenv_old_prompt
 end
 EOS
  ;;
 * )
  cat <<EOS
 if [ -n "\${_OLD_VIRTUAL_PS1:-}" ]; then
  export PS1="\${_OLD_VIRTUAL_PS1}";
  unset _OLD_VIRTUAL_PS1;
 fi;
 EOS
  ;;
 esac
 case "${shell}" in
 fish )
  cat <<EOS
 if functions -q deactivate;
  functions -e deactivate;
 end;
 EOS
  ;;
 * )
  cat <<EOS
 if declare -f deactivate 1>/dev/null 2>&1; then
  unset -f deactivate;
 fi;
 EOS
  ;;
 esac
 # Execute `after_deactivate` hooks.
 for hook in "${after_hooks[@]}"; do eval "$hook"; done
--- a/bin/pyenv-virtualenv
+++ b/bin/pyenv-virtualenv
@ -2,29 +2,25 @@
 #
 # Summary: Create a Python virtualenv using the pyenv-virtualenv plugin
 #
-# Usage: pyenv virtualenv [-f|--force] [VIRTUALENV_OPTIONS] [version] <virtualenv-name>
+# Usage: pyenv virtualenv [-f|--force] [VIRTUALENV_OPTIONS] <version> <virtualenv-name>
 #        pyenv virtualenv --version
 #        pyenv virtualenv --help
 #
-#   -f/--force       Install even if the version appears to be installed already. Skip
+#   -f/--force       Install even if the version appears to be installed already
 #                    prompting for confirmation
 #
 # Notable VIRTUALENV_OPTIONS passed to venv-creating executable, if applicable:
 #   -u/--upgrade     Imply --force
 #
-PYENV_VIRTUALENV_VERSION="1.4.0"
+PYENV_VIRTUALENV_VERSION="20141106"
 set -e
 [ -n "$PYENV_DEBUG" ] && set -x
 if [ -z "${PYENV_ROOT}" ]; then
  PYENV_ROOT="$(pyenv-root)"
 fi
 # Provide pyenv completions
 if [ "$1" = "--complete" ]; then
-  exec pyenv-versions --bare --skip-envs
+  exec pyenv-versions --bare
 fi
 if [ -z "$PYENV_ROOT" ]; then
  PYENV_ROOT="${HOME}/.pyenv"
 fi
 unset PIP_REQUIRE_VENV
@ -54,12 +50,6 @@ parse_options() {
  done
 }
 colorize() {
  if [ -t 1 ]; then printf "\e[%sm%s\e[m" "$1" "$2"
  else echo -n "$2"
  fi
 }
 resolve_link() {
  $(type -p greadlink readlink | head -1) "$1"
 }
@ -111,75 +101,47 @@ http_get_wget() {
 }
 version() {
  if [[ -z "${PYENV_VERSION:-}" ]]; then
    # `PYENV_VERSION` might not be declared if this was invoked via `--version`
    export PYENV_VERSION="$(pyenv-version-name)"
  fi
  detect_venv
  local version
-  if [ -n "${USE_CONDA}" ]; then
+  if [ -n "$USE_PYVENV" ]; then
-    version="$(pyenv-exec conda --version 2>/dev/null || true)"
+    version="$(pyenv-which pyvenv 2>/dev/null || true)"
-    echo "pyenv-virtualenv ${PYENV_VIRTUALENV_VERSION} (conda ${version:-unknown})"
+    version="${version#$(pyenv-root)/versions/}"
    version="${version%/bin/pyvenv}"
    echo "pyenv-virtualenv ${PYENV_VIRTUALENV_VERSION} (pyvenv ${version:-unknown})"
  else
-    if [ -n "$USE_M_VENV" ]; then
+    version="$(venv --version 2>/dev/null || true)"
-      echo "pyenv-virtualenv ${PYENV_VIRTUALENV_VERSION} (${M_VENV_PYTHON_BIN:-python} -m venv)"
+    echo "pyenv-virtualenv ${PYENV_VIRTUALENV_VERSION} (virtualenv ${version:-unknown})"
    else
      version="$(pyenv-exec virtualenv --version 2>/dev/null || true)"
      echo "pyenv-virtualenv ${PYENV_VIRTUALENV_VERSION} (virtualenv ${version:-unknown})"
    fi
  fi
 }
 usage() {
  # We can remove the sed fallback once pyenv 0.2.0 is widely available.
  pyenv-help virtualenv 2>/dev/null || sed -ne '/^#/!q;s/.//;s/.//;1,4d;p' < "$0"
-  if [ -n "${USE_CONDA}" ]; then
+  venv --help 2>/dev/null || true
    pyenv-exec conda create --help 2>/dev/null || true
  else
    if [ -n "${USE_M_VENV}" ]; then
      pyenv-exec "${M_VENV_PYTHON_BIN:-python}" -m venv --help 2>/dev/null || true
    else
      pyenv-exec virtualenv --help 2>/dev/null || true
    fi
  fi
  [ -z "$1" ] || exit "$1"
 }
 detect_venv() {
  # Check the existence of executables as a workaround for the issue with pyenv-which-ext
  # https://github.com/yyuu/pyenv-virtualenv/issues/26
-  local prefix="$(pyenv-prefix)"
+  if [ -x "$(pyenv-prefix)/bin/virtualenv" ]; then
-  if [ -x "${prefix}/bin/conda" ]; then
+    HAS_VIRTUALENV=1
    HAS_CONDA=1
  else
    if [ -x "${prefix}/bin/virtualenv" ]; then
      HAS_VIRTUALENV=1
    fi
    local python
    local -a pythons
    if [[ $PYENV_VERSION == "system" ]]; then
      # Prefer `python3.x` executable if available (#206, #282)
      pythons=("python3" "python" "python2")
    else
      # as per PEP 394, custom activated Python environments should provide the "python" command
      # this includes Pyenv-provided installations
      pythons=("python")
    fi
    for python in "${pythons[@]}"; do
      if pyenv-exec "${python}" -m venv --help 1>/dev/null 2>&1; then
        HAS_M_VENV=1
        M_VENV_PYTHON_BIN="${python}"
        break
      fi
    done
  fi
-  # Use `python -m venv` only if there is venv available, virtualenv is not installed, and `-p` not given
+  if [ -x "$(pyenv-prefix)/bin/pyvenv" ]; then
-  if [ -n "${HAS_CONDA}" ]; then
+    HAS_PYVENV=1
-    USE_CONDA=1
+  fi
  # Use pyvenv only if there is pyvenv, virtualenv is not installed, and `-p` not given
  if [ -n "${HAS_PYVENV}" ] && [ -z "${HAS_VIRTUALENV}" ] && [ -z "${VIRTUALENV_PYTHON}" ]; then
    USE_PYVENV=1
  fi
 }
 venv() {
  local args=("$@")
  if [ -n "${USE_PYVENV}" ]; then
    pyenv-exec pyvenv "${args[@]}"
  else
-    if [ -n "${HAS_M_VENV}" ] && [ -z "${HAS_VIRTUALENV}" ] && [ -z "${VIRTUALENV_PYTHON}" ]; then
+    pyenv-exec virtualenv "${args[@]}"
      USE_M_VENV=1
    fi
  fi
 }
@ -190,12 +152,12 @@ build_package_ez_setup() {
      echo "Installing setuptools from ${EZ_SETUP}..." 1>&2
      cat "${EZ_SETUP}"
    else
-      [ -n "${EZ_SETUP_URL}" ]
+      [ -n "${EZ_SETUP_URL}" ] || EZ_SETUP_URL="https://bootstrap.pypa.io/ez_setup.py"
      echo "Installing setuptools from ${EZ_SETUP_URL}..." 1>&2
      http get "${EZ_SETUP_URL}"
    fi
  } 1> "${ez_setup}"
-  pyenv-exec python -s "${ez_setup}" ${EZ_SETUP_OPTS} 1>&2 || {
+  pyenv-exec python "${ez_setup}" ${EZ_SETUP_OPTS} 1>&2 || {
    echo "error: failed to install setuptools via ez_setup.py" >&2
    return 1
  }
@ -208,19 +170,21 @@ build_package_get_pip() {
      echo "Installing pip from ${GET_PIP}..." 1>&2
      cat "${GET_PIP}"
    else
-      [ -n "${GET_PIP_URL}" ]
+      [ -n "${GET_PIP_URL}" ] || GET_PIP_URL="https://bootstrap.pypa.io/get-pip.py"
      echo "Installing pip from ${GET_PIP_URL}..." 1>&2
      http get "${GET_PIP_URL}"
    fi
  } 1> "${get_pip}"
-  pyenv-exec python -s "${get_pip}" ${GET_PIP_OPTS} 1>&2 || {
+  pyenv-exec python "${get_pip}" ${GET_PIP_OPTS} 1>&2 || {
    echo "error: failed to install pip via get-pip.py" >&2
    return 1
  }
 }
 build_package_ensurepip() {
-  pyenv-exec python -s -m ensurepip 2>/dev/null || build_package_get_pip "$@" || return 1
+  pyenv-exec python -m ensurepip 2>/dev/null|| {
    build_package_ez_setup "$@" && build_package_get_pip "$@"
  } || return 1
 }
 prepare_requirements() {
@ -253,11 +217,10 @@ fi
 VIRTUALENV_OPTIONS=()
 unset FORCE
-unset NO_ENSUREPIP
+unset VIRTUALENV_PYTHON
 unset QUIET
 unset UPGRADE
 unset VERBOSE
 unset VIRTUALENV_PYTHON
 parse_options "$@"
 for option in "${OPTIONS[@]}"; do
@ -268,14 +231,6 @@ for option in "${OPTIONS[@]}"; do
  "h" | "help" )
    usage 0
    ;;
  "no-pip" )
    NO_ENSUREPIP=1
    VIRTUALENV_OPTIONS[${#VIRTUALENV_OPTIONS[*]}]="--$option"
    ;;
  "no-setuptools" )
    NO_ENSUREPIP=1
    VIRTUALENV_OPTIONS[${#VIRTUALENV_OPTIONS[*]}]="--$option"
    ;;
  "p" | "python" )
    VIRTUALENV_PYTHON="${ARGUMENTS[0]}"
    ARGUMENTS=("${ARGUMENTS[@]:1}") # shift 1
@ -293,10 +248,6 @@ for option in "${OPTIONS[@]}"; do
    version
    exit 0
    ;;
  "without-pip" )
    NO_ENSUREPIP=1
    VIRTUALENV_OPTIONS[${#VIRTUALENV_OPTIONS[*]}]="--$option"
    ;;
  * ) # virtualenv long options
    if [[ "$option" == "python="* ]]; then
      VIRTUALENV_PYTHON="${option#python=}"
@ -312,60 +263,28 @@ if [[ "${#ARGUMENTS[@]}" == 0 ]]; then
  exit 1
 elif [[ "${#ARGUMENTS[@]}" == 1 ]]; then
  # If only one argument given, use current version as source version
-  OLDIFS="${IFS}"
+  VERSION_NAME="$(pyenv-version-name)"
  IFS=:
  VERSION_NAMES=($(pyenv-version-name))
  IFS="${OLDIFS}"
  VERSION_NAME="${VERSION_NAMES}"
  VIRTUALENV_NAME="${ARGUMENTS[0]}"
 else
  # Otherwise, use former as source version, and latter as virtualenv version
  VERSION_NAME="${ARGUMENTS[0]}"
-  VIRTUALENV_NAME="${ARGUMENTS[1]}"
+  VIRTUALENV_NAME="${ARGUMENTS[1]##*/}"
 fi
 if [[ -n "${VERSION_NAME}" ]] && command -v pyenv-latest >/dev/null; then
  VERSION_NAME="$(pyenv-latest -f "${VERSION_NAME}")"
 fi
 if [ -z "${VERSION_NAME}" ] || [ -z "${VIRTUALENV_NAME}" ]; then
  usage 1
 fi
 if [[ "${VIRTUALENV_NAME##*/}" == "system" ]]; then
  echo "pyenv-virtualenv: \`system' is not allowed as virtualenv name." 1>&2
  exit 1
 fi
 if [ "$VIRTUALENV_NAME" != "${VIRTUALENV_NAME%[[:space:]]*}" ]; then
  echo "pyenv-virtualenv: no whitespace allowed in virtualenv name." 1>&2
  exit 1
 fi
 if [ "${VIRTUALENV_NAME}" != "${VIRTUALENV_NAME%/*}" ] && [[ "${VIRTUALENV_NAME}" != "${VERSION_NAME%%/*}/envs/${VIRTUALENV_NAME##*/}" ]] ; then
  echo "pyenv-virtualenv: no slash allowed in virtualenv name." 1>&2
  exit 1
 fi
 # Set VERSION_NAME as default version in this script
 export PYENV_VERSION="${VERSION_NAME}"
-not_installed_message() {
+# Source version must exists before creating virtualenv
-    local is_available=$(python-build --definitions | grep -F -x "$1")
+pyenv-prefix 1>/dev/null 2>&1 || usage 1
    echo "pyenv-virtualenv: \`${1}' is not installed in pyenv." 1>&2
    if [[ $is_available ]]; then
        echo "Run \`pyenv install ${1}' to install it." 1>&2
    else
        echo "It does not look like a valid Python version. See \`pyenv install --list' for available versions." 1>&2
    fi
 }
 # Source version must exist before creating virtualenv.
 PREFIX="$(pyenv-prefix 2>/dev/null || true)"
 if [ ! -d "${PREFIX}" ]; then
  not_installed_message "${PYENV_VERSION}"
  exit 1
 fi
 if [ -z "$TMPDIR" ]; then
  TMP="/tmp"
@ -373,36 +292,11 @@ else
  TMP="${TMPDIR%/}"
 fi
 # Not create `system/envs` directory even if source version is `system`
 if [[ "${VERSION_NAME%/envs/*}" == "system" ]]; then
  VIRTUALENV_NAME="${VIRTUALENV_NAME##*/}"
 else
  VIRTUALENV_PREFIX="$(pyenv-virtualenv-prefix 2>/dev/null || true)"
  if [[ "${VIRTUALENV_PREFIX%/*}" == "${PYENV_ROOT}/versions" ]]; then
    VIRTUALENV_NAME="${VIRTUALENV_PREFIX#${PYENV_ROOT}/versions/}/envs/${VIRTUALENV_NAME##*/}"
  else
    VIRTUALENV_NAME="${VERSION_NAME}/envs/${VIRTUALENV_NAME##*/}"
  fi
 fi
 VIRTUALENV_PATH="${PYENV_ROOT}/versions/${VIRTUALENV_NAME}"
 if [[ "${VIRTUALENV_PATH/*/envs/*}" != "${PYENV_ROOT}/versions" ]]; then
  COMPAT_VIRTUALENV_PATH="${PYENV_ROOT}/versions/${VIRTUALENV_NAME##*/}"
 fi
 if [ -n "${COMPAT_VIRTUALENV_PATH}" ]; then
  if [ -z ${FORCE} ]; then
    if [ -e "${COMPAT_VIRTUALENV_PATH}" ] || [ -L "${COMPAT_VIRTUALENV_PATH}" ]; then
      echo "pyenv-virtualenv: \`${COMPAT_VIRTUALENV_PATH}' already exists." 1>&2
      exit 1
    fi
  fi
 fi
 unset HAS_VIRTUALENV
-unset HAS_M_VENV
+unset HAS_PYVENV
-unset USE_CONDA
+unset USE_PYVENV
 unset USE_M_VENV
 detect_venv
 SEED="$(date "+%Y%m%d%H%M%S").$$"
@ -412,131 +306,39 @@ REQUIREMENTS="${TMP}/requirements.${SEED}.txt"
 # Upgrade existing virtualenv
 if [ -n "$UPGRADE" ]; then
  FORCE=1
-  # `python -m venv` has `--upgrade` by default
+  # pyvenv has `--upgrade` by default
-  if [ -n "${USE_M_VENV}" ]; then
+  if [ -n "${USE_PYVENV}" ]; then
    unset UPGRADE
    VIRTUALENV_OPTIONS[${#VIRTUALENV_OPTIONS[*]}]="--upgrade"
  fi
 fi
-if [ -z "${VIRTUALENV_VERSION}" ]; then
+if [ -n "${USE_PYVENV}" ]; then
-  case "${PYENV_VERSION}" in
+  # Unset some arguments not supported by pyvenv
-  "3.0"* )
+  unset QUIET
-    NO_ENSUREPIP=1
+  unset VERBOSE
    ;;
  "3.1"* )
    NO_ENSUREPIP=1
    ;;
  "3.2"* | "stackless-3.2"* )
    # pip 8.x (bundled with virtualenv 14+) doesn't support 3.2 anymore
    # https://github.com/yyuu/pyenv/issues/531
    VIRTUALENV_VERSION="13.1.2"
    NO_ENSUREPIP=1
    ;;
  esac
 fi
 if [ -n "${USE_CONDA}" ]; then
  # e.g. `conda create -n py35 python=3.5 anaconda`
  if [ -n "${VIRTUALENV_PYTHON}" ]; then
    VIRTUALENV_PYTHON="${VIRTUALENV_PYTHON##*/}"
    VIRTUALENV_PYTHON="${VIRTUALENV_PYTHON#python}"
    if [ -n "${VIRTUALENV_PYTHON}" ]; then
      VIRTUALENV_OPTIONS[${#VIRTUALENV_OPTIONS[*]}]="python=${VIRTUALENV_PYTHON}"
    fi
  fi
 else
-  if [ -n "${USE_M_VENV}" ]; then
+  if [ -n "${VIRTUALENV_PYTHON}" ]; then
-    # Unset some arguments not supported by `python -m venv`
+    VIRTUALENV_OPTIONS[${#VIRTUALENV_OPTIONS[*]}]="--python=${VIRTUALENV_PYTHON}"
-    unset QUIET
+  fi
-    unset VERBOSE
+  if [ -z "${HAS_VIRTUALENV}" ]; then
-    if [ -n "${VIRTUALENV_PYTHON}" ]; then
+    VIRTUALENV_VERSION="==${VIRTUALENV_VERSION}"
-      echo "pyenv-virtualenv: \`--python=${VIRTUALENV_PYTHON}' is not supported by \`python -m venv'." 1>&2
+    pyenv-exec pip install $QUIET $VERBOSE "virtualenv${VIRTUALENV_VERSION%==}"
-      exit 1
+    HAS_VIRTUALENV=1
    fi
  else
    if [ -n "${VIRTUALENV_PYTHON}" ]; then
      if [[ "${VIRTUALENV_PYTHON}" == "${VIRTUALENV_PYTHON##*/}" ]] || [[ "${VIRTUALENV_PYTHON}" == "${PYENV_ROOT}/shims/"* ]]; then
        python="$(pyenv-which "${VIRTUALENV_PYTHON##*/}" 2>/dev/null || true)"
        if [ -x "${python}" ]; then
          VIRTUALENV_OPTIONS[${#VIRTUALENV_OPTIONS[*]}]="--python=${python}"
        else
          python="$(PYENV_VERSION="$(pyenv-whence "${VIRTUALENV_PYTHON##*/}" 2>/dev/null | tail -n 1 || true)" pyenv-which "${VIRTUALENV_PYTHON##*/}" 2>/dev/null || true)"
          if [ -x "${python}" ]; then
            VIRTUALENV_OPTIONS[${#VIRTUALENV_OPTIONS[*]}]="--python=${python}"
          else
            # echo "pyenv-virtualenv: \`${VIRTUALENV_PYTHON##*/}' is not installed in pyenv." 1>&2
            not_installed_message "${VIRTUALENV_PYTHON##*/}"
            exit 1
          fi
        fi
      else
        VIRTUALENV_OPTIONS[${#VIRTUALENV_OPTIONS[*]}]="--python=${VIRTUALENV_PYTHON}"
      fi
    fi
    if [ -z "${HAS_VIRTUALENV}" ]; then
      if [ -n "${VIRTUALENV_VERSION}" ]; then
        virtualenv_spec="virtualenv==${VIRTUALENV_VERSION}"
      else
        virtualenv_spec="virtualenv"
      fi
      pyenv-exec pip install $QUIET $VERBOSE "${virtualenv_spec}"
      HAS_VIRTUALENV=1
    fi
  fi
 fi
-# Unset environment variables which start with `VIRTUALENV_`.
+# Unset environment variables which starts with `VIRTUALENV_`.
 # These variables are reserved for virtualenv.
 unset VIRTUALENV_VERSION
-# Download specified version of ez_setup.py/get-pip.py.
+# Download specified version of ez_setup.py/get-pip.py
-if [ -z "${EZ_SETUP_URL}" ]; then
+if [ -n "${SETUPTOOLS_VERSION}" ]; then
-  if [ -n "${SETUPTOOLS_VERSION}" ]; then
+  EZ_SETUP_URL="https://bitbucket.org/pypa/setuptools/raw/${SETUPTOOLS_VERSION}/ez_setup.py"
    EZ_SETUP_URL="https://bitbucket.org/pypa/setuptools/raw/${SETUPTOOLS_VERSION}/ez_setup.py"
    unset SETUPTOOLS_VERSION
  else
    EZ_SETUP_URL="https://bootstrap.pypa.io/ez_setup.py"
  fi
 fi
-if [ -z "${GET_PIP_URL}" ]; then
+if [ -n "${PIP_VERSION}" ]; then
-  if [ -n "${PIP_VERSION}" ]; then
+  GET_PIP_URL="https://raw.githubusercontent.com/pypa/pip/${PIP_VERSION}/contrib/get-pip.py"
    { colorize 1 "WARNING"
      echo ": Setting PIP_VERSION=${PIP_VERSION} is no longer supported and may cause failures during the install process."
    } 1>&2
    GET_PIP_URL="https://raw.githubusercontent.com/pypa/pip/${PIP_VERSION}/contrib/get-pip.py"
    # Unset `PIP_VERSION` from environment before invoking `get-pip.py` to deal with "ValueError: invalid truth value" (pypa/pip#4528)
    unset PIP_VERSION
  else
    # Use custom get-pip URL based on the target version (#1127)
    case "${PYENV_VERSION}" in
    2.6 | 2.6.* )
      GET_PIP_URL="https://bootstrap.pypa.io/pip/2.6/get-pip.py"
      ;;
    2.7 | 2.7.* )
      GET_PIP_URL="https://bootstrap.pypa.io/pip/2.7/get-pip.py"
      ;;
    3.2 | 3.2.* )
      GET_PIP_URL="https://bootstrap.pypa.io/pip/3.2/get-pip.py"
      ;;
    3.3 | 3.3.* )
      GET_PIP_URL="https://bootstrap.pypa.io/pip/3.3/get-pip.py"
      ;;
    3.4 | 3.4.* )
      GET_PIP_URL="https://bootstrap.pypa.io/pip/3.4/get-pip.py"
      ;;
    3.5 | 3.5.* )
      GET_PIP_URL="https://bootstrap.pypa.io/pip/3.5/get-pip.py"
      ;;
    3.6 | 3.6.* )
      GET_PIP_URL="https://bootstrap.pypa.io/pip/3.6/get-pip.py"
      ;;
    * )
      GET_PIP_URL="https://bootstrap.pypa.io/pip/get-pip.py"
      ;;
    esac
  fi
 fi
@ -578,12 +380,7 @@ if [ -d "${VIRTUALENV_PATH}/bin" ]; then
  fi
  if [ -n "$UPGRADE" ]; then
-    if [ -n "${NO_ENSUREPIP}" ]; then
+    PYENV_VERSION="${VIRTUALENV_NAME}" prepare_requirements
      echo "pyenv-virtualenv: upgrading will not work with --no-setuptools or --no-pip" 1>&2
      exit 1
    else
      PYENV_VERSION="${VIRTUALENV_NAME}" prepare_requirements
    fi
  fi
 fi
@ -592,69 +389,26 @@ for hook in "${before_hooks[@]}"; do eval "$hook"; done
 # Plan cleanup on unsuccessful installation.
 cleanup() {
  [[ -L "${COMPAT_VIRTUALENV_PATH}" ]] && rm "${COMPAT_VIRTUALENV_PATH}"
  [ -z "${PREFIX_EXISTS}" ] && rm -rf "$VIRTUALENV_PATH"
 }
-trap cleanup SIGINT ERR
+trap cleanup SIGINT
 # Invoke virtualenv and record exit status in $STATUS.
 STATUS=0
-# virtualenv may download distribute/setuptools into the current directory.
+# virtualenv may download distribute/setuptools in current directory.
-# Change to cache directory to reuse them between invocations.
+# change to cache directory to reuse them between invocation.
 mkdir -p "${PYENV_VIRTUALENV_CACHE_PATH}"
 cd "${PYENV_VIRTUALENV_CACHE_PATH}"
-if [ -n "${USE_CONDA}" ]; then
+venv $QUIET $VERBOSE "${VIRTUALENV_OPTIONS[@]}" "${VIRTUALENV_PATH}" || STATUS="$?"
  if [ -z "$VIRTUALENV_PYTHON" ]; then
    #process substitution doesn't seem to work unless it's directly inserted to the command line
    #if we add it to VIRTUALENV_OPTIONS instead, "broken pipe" happens
    pyenv-exec conda create $QUIET $VERBOSE --name "${VIRTUALENV_PATH##*/}" --yes "${VIRTUALENV_OPTIONS[@]}" --file <(pyenv-exec conda list python --full-name --export) || STATUS="$?"
  else
    pyenv-exec conda create $QUIET $VERBOSE --name "${VIRTUALENV_PATH##*/}" --yes "${VIRTUALENV_OPTIONS[@]}" || STATUS="$?"
  fi
 else
  if [ -n "${USE_M_VENV}" ]; then
    pyenv-exec "${M_VENV_PYTHON_BIN:-python}" -m venv $QUIET $VERBOSE "${VIRTUALENV_OPTIONS[@]}" "${VIRTUALENV_PATH}" || STATUS="$?"
  else
    pyenv-exec virtualenv $QUIET $VERBOSE "${VIRTUALENV_OPTIONS[@]}" "${VIRTUALENV_PATH}" || STATUS="$?"
  fi
 fi
-(
+## Install setuptools and pip
-  shopt -s nullglob
+PYENV_VERSION="${VIRTUALENV_NAME}" build_package_ensurepip
  for extra_binary in "$PREFIX"/bin/python*-config; do
    extra_binary_linkname="$VIRTUALENV_PATH/bin/$(basename $extra_binary)"
    [[ -e "$extra_binary_linkname" ]] || \
        ln -s "$extra_binary" "$extra_binary_linkname"
  done
 )
-## Create symlink in the `versions` directory for backward compatibility
+## Migrate previously installed packages from requirements.txt
-if [ -d "${VIRTUALENV_PATH}" ] && [ -n "${COMPAT_VIRTUALENV_PATH}" ]; then
+PYENV_VERSION="${VIRTUALENV_NAME}" install_requirements || true
  # Overwrite an existing link, can happen if running with -f
  ln -fsn "${VIRTUALENV_PATH}" "${COMPAT_VIRTUALENV_PATH}"
 fi
-if [ ! -e "${VIRTUALENV_PATH}/bin/pydoc" ]; then
+# Execute `after_virtualenv` hooks
  mkdir -p "${VIRTUALENV_PATH}/bin"
  cat <<EOS > "${VIRTUALENV_PATH}/bin/pydoc"
 #!${VIRTUALENV_PATH}/bin/python
 import pydoc
 if __name__ == '__main__':
      pydoc.cli()
 EOS
  chmod +x "${VIRTUALENV_PATH}/bin/pydoc"
 fi
 if [ -z "${NO_ENSUREPIP}" ]; then
  ## Install setuptools and pip.
  PYENV_VERSION="${VIRTUALENV_NAME}" build_package_ensurepip
  ## Migrate previously installed packages from requirements.txt.
  PYENV_VERSION="${VIRTUALENV_NAME}" install_requirements || true
 fi
 # Execute `after_virtualenv` hooks.
 for hook in "${after_hooks[@]}"; do eval "$hook"; done
 # Run `pyenv-rehash` after a successful installation.
--- a/bin/pyenv-virtualenv-delete
+++ b/bin/pyenv-virtualenv-delete
@ -1,108 +0,0 @@
 #!/usr/bin/env bash
 #
 # Summary: Uninstall a specific Python virtualenv
 #
 # Usage: pyenv virtualenv-delete [-f|--force] <virtualenv>
 #
 #    -f  Attempt to remove the specified virtualenv without prompting
 #        for confirmation. If the virtualenv does not exist, do not
 #        display an error message.
 #
 # See `pyenv virtualenvs` for a complete list of installed versions.
 #
 set -e
 [ -n "$PYENV_DEBUG" ] && set -x
 if [ -z "${PYENV_ROOT}" ]; then
  PYENV_ROOT="$(pyenv-root)"
 fi
 # Provide pyenv completions
 if [ "$1" = "--complete" ]; then
  exec pyenv virtualenvs --bare
 fi
 resolve_link() {
  $(type -p greadlink readlink | head -1) "$1"
 }
 usage() {
  pyenv-help virtualenv-delete 2>/dev/null
  [ -z "$1" ] || exit "$1"
 }
 if [ -z "$PYENV_ROOT" ]; then
  PYENV_ROOT="${HOME}/.pyenv"
 fi
 if [ "$1" = "-h" ] || [ "$1" = "--help" ]; then
  usage 0
 fi
 unset FORCE
 if [ "$1" = "-f" ] || [ "$1" = "--force" ]; then
  FORCE=true
  shift
 fi
 [ "$#" -eq 1 ] || usage 1 >&2
 DEFINITION="$1"
 case "$DEFINITION" in
 "" | -* )
  usage 1 >&2
  ;;
 esac
 VERSION_NAME="${DEFINITION##*/}"
 # Must initialize because it might be set in the environment
 ENV_PREFIX=
 ENV_COMPAT_PREFIX="${PYENV_ROOT}/versions/${VERSION_NAME}"
 if [[ "${DEFINITION}" != "${DEFINITION%/envs/*}" ]]; then
  ENV_PREFIX="${PYENV_ROOT}/versions/${DEFINITION}"
  if [ -L "${ENV_COMPAT_PREFIX}" ]; then
    if [[ "${ENV_PREFIX}" != "$(resolve_link "${ENV_COMPAT_PREFIX}" 2>/dev/null || true)" ]]; then
      unset ENV_COMPAT_PREFIX
    fi
  fi
 else
  if [ -L "${ENV_COMPAT_PREFIX}" ]; then
    ENV_PREFIX="$(resolve_link "${ENV_COMPAT_PREFIX}" 2>/dev/null || true)"
    if [[ "${ENV_PREFIX%/*/envs/*}" != "${PYENV_ROOT}/versions" ]]; then
      echo "pyenv-virtualenv: \`${ENV_COMPAT_PREFIX}' is a symlink for unknown location." 1>&2
      exit 1
    fi
  else
    if pyenv-virtualenv-prefix "${VERSION_NAME}" 1>/dev/null 2>&1; then
      ENV_PREFIX="${PYENV_ROOT}/versions/${VERSION_NAME}"
      unset ENV_COMPAT_PREFIX
    elif [ -z "$FORCE" ]; then
      echo "pyenv-virtualenv: \`${DEFINITION}' is not a virtualenv." 1>&2
      exit 1
    fi
  fi
 fi
 if [ ! -d "$ENV_PREFIX" ]; then
  if [ -z "$FORCE" ]; then
    echo "pyenv-virtualenv: virtualenv \`$VERSION_NAME' not installed" >&2
    exit 1
  else
    exit 0
  fi
 fi
 if [ -z "$FORCE" ]; then
  read -p "pyenv-virtualenv: remove $ENV_PREFIX? (y/N) "
  case "$REPLY" in
  y* | Y* ) ;;
  * ) exit 1 ;;
  esac
 fi
 rm -rf "$ENV_PREFIX"
 if [ -L "$ENV_COMPAT_PREFIX" ]; then
  rm -rf "$ENV_COMPAT_PREFIX"
 fi
 pyenv-rehash
--- a/bin/pyenv-virtualenv-init
+++ b/bin/pyenv-virtualenv-init
@ -9,43 +9,6 @@
 set -e
 [ -n "$PYENV_DEBUG" ] && set -x
 # Detect stat format for mtime: GNU uses -c %Y, BSD uses -f %m
 # -L follows symlinks: a symlinked .python-version reflects target changes
 if stat -L -c %Y / >/dev/null 2>&1; then
  _stat_fmt="-L -c %Y"
 else
  _stat_fmt="-L -f %m"
 fi
 # Check for version-name hooks at init time. Hooks can alter version
 # resolution in ways the mtime cache cannot track. If present, the hook
 # falls back to upstream behavior (no caching). Restart shell after
 # installing or removing pyenv plugins.
 _has_version_hooks=""
 if [ -n "$(pyenv hooks version-name 2>/dev/null)" ]; then
  _has_version_hooks=1
 fi
 resolve_link() {
  $(type -p greadlink readlink | head -1) "$1"
 }
 abs_dirname() {
  local cwd="$(pwd)"
  local path="$1"
  while [ -n "$path" ]; do
    cd "${path%/*}"
    local name="${path##*/}"
    path="$(resolve_link "$name" || true)"
  done
  pwd
  cd "$cwd"
 }
 PYENV_VIRTUALENV_INSTALL_PREFIX="$(dirname "$(abs_dirname "$0")")"
 print=""
 for args in "$@"
 do
@ -55,20 +18,18 @@ do
  fi
 done
-shell="${1:-$PYENV_SHELL}"
+shell="$1"
 if [ -z "$shell" ]; then
-  shell="$(ps -p "$PPID" -o 'args=' 2>/dev/null || true)"
+  shell="$(ps c -p "$PPID" -o 'ucomm=' 2>/dev/null || true)"
  shell="${shell##-}"
  shell="${shell%% *}"
-  shell="${shell:-$SHELL}"
+  shell="$(basename "${shell:-$SHELL}")"
  shell="${shell##*/}"
  shell="${shell%%-*}"
 fi
 if [ -z "$print" ]; then
  case "$shell" in
  bash )
-    profile='~/.bashrc'
+    profile='~/.bash_profile'
    ;;
  zsh )
    profile='~/.zshrc'
@ -89,7 +50,7 @@ if [ -z "$print" ]; then
    echo
    case "$shell" in
    fish )
-      echo 'status --is-interactive; and source (pyenv virtualenv-init -|psub)'
+      echo 'status --is-interactive; and . (pyenv virtualenv-init -|psub)'
      ;;
    * )
      echo 'eval "$(pyenv virtualenv-init -)"'
@ -103,18 +64,10 @@ fi
 case "$shell" in
 fish )
-  cat <<EOS
+  echo "setenv PYENV_VIRTUALENV_INIT 1;"
 while set index (contains -i -- "${PYENV_VIRTUALENV_ROOT:-${PYENV_VIRTUALENV_INSTALL_PREFIX}}/shims" \$PATH)
 set -eg PATH[\$index]; end; set -e index
 set -gx PATH '${PYENV_VIRTUALENV_ROOT:-${PYENV_VIRTUALENV_INSTALL_PREFIX}}/shims' \$PATH;
 set -gx PYENV_VIRTUALENV_INIT 1;
 EOS
  ;;
 * )
-  cat <<EOS
+  echo "export PYENV_VIRTUALENV_INIT=1;"
 export PATH="${PYENV_VIRTUALENV_ROOT:-${PYENV_VIRTUALENV_INSTALL_PREFIX}}/shims:\${PATH}";
 export PYENV_VIRTUALENV_INIT=1;
 EOS
  ;;
 esac
@ -122,148 +75,82 @@ case "$shell" in
 fish )
  cat <<EOS
 function _pyenv_virtualenv_hook --on-event fish_prompt;
-  set -l ret \$status
+  if [ -n "\$PYENV_ACTIVATE" ]
-EOS
+    if [ (pyenv version-name) = "system" ]
-
+      pyenv deactivate --no-error --verbose
-  if [ -z "$_has_version_hooks" ]; then
+      set -e PYENV_DEACTIVATE
-    cat <<EOS
+      return 0
  if test "\$PYENV_VERSION" = "\$_PYENV_VH_VERSION" \\
    -a "\$VIRTUAL_ENV" = "\$_PYENV_VH_VENV"
    if test -n "\$PYENV_VERSION"
      return \$ret
    end
-    if test "\$PWD" = "\$_PYENV_VH_PWD" \\
+    if [ "\$PYENV_ACTIVATE" != (pyenv prefix 2>/dev/null) ]
-      -a "(stat ${_stat_fmt} \$_PYENV_VH_PATHS 2>/dev/null)" = "\$_PYENV_VH_MTIMES"
+      if pyenv deactivate --no-error --verbose
-      return \$ret
+        set -e PYENV_DEACTIVATE
-    end
+        pyenv activate --no-error --verbose; or set -e PYENV_DEACTIVATE
-  end
+      else
-EOS
+        pyenv activate --no-error --verbose
  fi
  cat <<EOS
  if [ -n "\$VIRTUAL_ENV" ]
    pyenv activate --quiet; or pyenv deactivate --quiet; or true
  else
    pyenv activate --quiet; or true
  end
 EOS
  if [ -z "$_has_version_hooks" ]; then
    cat <<EOS
  set -g _PYENV_VH_PWD "\$PWD"
  set -g _PYENV_VH_VERSION "\$PYENV_VERSION"
  set -g _PYENV_VH_VENV "\$VIRTUAL_ENV"
  set -l d "\$PWD"
  set -l _pvh_found_local 0
  set -g _PYENV_VH_PATHS
  while true
    if test -f "\$d/.python-version"; or test -L "\$d/.python-version"
      set -g _PYENV_VH_PATHS \$_PYENV_VH_PATHS "\$d/.python-version"
      if test -f "\$d/.python-version" 
        set _pvh_found_local 1
        break
      end
    else
      set -g _PYENV_VH_PATHS \$_PYENV_VH_PATHS "\$d"
    end
-    test "\$d" = "/"; and break
+  else
-    set d (string replace -r '/[^/]*\$' '' -- "\$d")
+    if [ -z "\$VIRTUAL_ENV" ]; and [ "\$PYENV_DEACTIVATE" != (pyenv prefix 2>/dev/null) ]
-    test -z "\$d"; and set d "/"
+      pyenv activate --no-error --verbose
    end
  end
  if test "\$_pvh_found_local" = "0"
    set -g _PYENV_VH_PATHS \$_PYENV_VH_PATHS "\$PYENV_ROOT/version"
  end
  set -g _PYENV_VH_MTIMES (stat ${_stat_fmt} \$_PYENV_VH_PATHS 2>/dev/null)
 EOS
  fi
  cat <<EOS
  return \$ret
 end
 EOS
-  ;;
+ ;;
-
+ksh )
 bash|zsh )
  cat <<EOS
-_pyenv_virtualenv_hook() {
+function _pyenv_virtualenv_hook() {
  local ret=\$?
 EOS
  if [ -z "$_has_version_hooks" ]; then
    cat <<EOS
  if [ "\${PYENV_VERSION-}" = "\${_PYENV_VH_VERSION-}" ] \\
    && [ "\${VIRTUAL_ENV-}" = "\${_PYENV_VH_VENV-}" ]; then
    if [ -n "\${PYENV_VERSION-}" ]; then
      return \$ret
    fi
    if [ "\${PWD}" = "\${_PYENV_VH_PWD-}" ] \\
      && [ "\$(stat ${_stat_fmt} "\${_PYENV_VH_PATHS[@]}" 2>/dev/null)" = "\${_PYENV_VH_MTIMES-}" ]; then
      return \$ret
    fi
  fi
 EOS
  fi
  cat <<EOS
  if [ -n "\${VIRTUAL_ENV-}" ]; then
    eval "\$(pyenv sh-activate --quiet || pyenv sh-deactivate --quiet || true)" || true
  else
    eval "\$(pyenv sh-activate --quiet || true)" || true
  fi
 EOS
  if [ -z "$_has_version_hooks" ]; then
    cat <<EOS
  _PYENV_VH_PWD="\${PWD}"
  _PYENV_VH_VERSION="\${PYENV_VERSION-}"
  _PYENV_VH_VENV="\${VIRTUAL_ENV-}"
  local _pvh_d="\${PWD}" _pvh_found_local=0
  _PYENV_VH_PATHS=()
  while :; do
    if [ -f "\${_pvh_d}/.python-version" ] || [ -L "\${_pvh_d}/.python-version" ]; then
      _PYENV_VH_PATHS+=("\${_pvh_d}/.python-version")
      if [ -f "\${_pvh_d}/.python-version" ]; then 
        _pvh_found_local=1
        break
      fi
    else
      _PYENV_VH_PATHS+=("\${_pvh_d}")
    fi
    [ "\${_pvh_d}" = "/" ] && break
    _pvh_d="\${_pvh_d%/*}"
    [ -z "\${_pvh_d}" ] && _pvh_d="/"
  done
  if [ "\${_pvh_found_local}" = "0" ]; then
    _PYENV_VH_PATHS+=("\${PYENV_ROOT}/version")
  fi
  _PYENV_VH_MTIMES="\$(stat ${_stat_fmt} "\${_PYENV_VH_PATHS[@]}" 2>/dev/null)"
 EOS
  fi
  cat <<EOS
  return \$ret
 };
 EOS
  ;;
 esac
 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 \$precmd_functions);
 fi
 EOS
  ;;
 * )
-  # No prompt command support or it's installed elsewhere
+  cat <<EOS
 _pyenv_virtualenv_hook() {
 EOS
  ;;
 esac
 if [[ "$shell" != "fish" ]]; then
  cat <<EOS
  if [ -n "\$PYENV_ACTIVATE" ]; then
    if [ "\$(pyenv version-name)" = "system" ]; then
      pyenv deactivate --no-error --verbose
      unset PYENV_DEACTIVATE
      return 0
    fi
    if [ "\$PYENV_ACTIVATE" != "\$(pyenv prefix 2>/dev/null)" ]; then
      if pyenv deactivate --no-error --verbose; then
        unset PYENV_DEACTIVATE
        pyenv activate --no-error --verbose || unset PYENV_DEACTIVATE
      else
        pyenv activate --no-error --verbose
      fi
    fi
  else
    if [ -z "\$VIRTUAL_ENV" ] && [ "\$PYENV_DEACTIVATE" != "\$(pyenv prefix 2>/dev/null)" ]; then
      pyenv activate --no-error --verbose
    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 -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
@ -6,45 +6,28 @@
 set -e
 [ -n "$PYENV_DEBUG" ] && set -x
 if [ -L "${BASH_SOURCE}" ]; then
    READLINK=$(type -p greadlink readlink | head -1)
    if [ -z "$READLINK" ]; then
        echo "pyenv: cannot find readlink - are you missing GNU coreutils?" >&2
        exit 1
    fi
    resolve_link() {
        $READLINK -f "$1"
    }
    script_path=$(resolve_link ${BASH_SOURCE})
 else
    script_path=${BASH_SOURCE}
 fi
 . ${script_path%/*}/../libexec/pyenv-virtualenv-realpath
 if [ -z "$PYENV_ROOT" ]; then
  PYENV_ROOT="${HOME}/.pyenv"
 fi
 OLDIFS="$IFS"
 IFS=:
 if [ -n "$1" ]; then
-  # $@ is not affected by IFS
+  versions=($@)
-  versions=("$@")
+  IFS=: PYENV_VERSION="${versions[*]}"
  PYENV_VERSION="${versions[*]}"
  export PYENV_VERSION
 else
-  versions=($(pyenv-version-name))
+  IFS=: versions=($(pyenv-version-name))
 fi
 IFS="$OLDIFS"
-append_virtualenv_prefix() {
+real_prefix() { # virtualenv
-  if [ -d "${VIRTUALENV_PREFIX_PATH}" ]; then
+  local version="$1"
-    VIRTUALENV_PREFIX_PATHS=("${VIRTUALENV_PREFIX_PATHS[@]}" "${VIRTUALENV_PREFIX_PATH:-${PYENV_PREFIX_PATH}}")
+  PYENV_VERSION="${version}" pyenv-exec python -c 'import sys;print(sys.real_prefix)' 2>/dev/null
-  else
+}
-    echo "pyenv-virtualenv: version \`${version}' is not a virtualenv" 1>&2
+
-    exit 1
+base_prefix() { # pyvenv
-  fi
+  # FIXME: non-pyvenv versions also have sys.base_prefix
  local version="$1"
  PYENV_VERSION="${version}" pyenv-exec python -c 'import sys;print(sys.base_prefix)' 2>/dev/null
 }
 VIRTUALENV_PREFIX_PATHS=()
@ -53,63 +36,14 @@ for version in "${versions[@]}"; do
    echo "pyenv-virtualenv: version \`${version}' is not a virtualenv" 1>&2
    exit 1
  fi
-
+  PREFIX="$(pyenv-prefix "${version}")"
-  # In the vast majority of cases, there's a direct match and 
+  if [ -f "${PREFIX}/bin/activate" ]; then
-  # not spawning `pyenv-prefix' saves about half the invocation time
+    VIRTUALENV_PREFIX_PATH="$(real_prefix "${version}" || base_prefix "${version}" || true)"
-  # with a signle argument which accumulates when called repeatedly
+    VIRTUALENV_PREFIX_PATHS=("${VIRTUALENV_PREFIX_PATHS[@]}" "$VIRTUALENV_PREFIX_PATH")
  # (e.g. from `pyenv-virtualenvs').
  # `pyenv-prefix' also does not have hooks to worry about.
  # XXX: refactor the test into a shared module?
  PYENV_PREFIX_PATH="${PYENV_ROOT}/versions/${version}"
  if [[ ! -d "$PYENV_PREFIX_PATH" ]]; then
    PYENV_PREFIX_PATH="$(pyenv-prefix "${version}")"
  fi
  if [ -x "${PYENV_PREFIX_PATH}/bin/python" ]; then
    if [ -f "${PYENV_PREFIX_PATH}/bin/activate" ]; then
      if [ -f "${PYENV_PREFIX_PATH}/bin/conda" ]; then
        # conda
        VIRTUALENV_PREFIX_PATH="${PYENV_PREFIX_PATH}"
      else
        if [ -f "${PYENV_ROOT}/versions/${version}/pyvenv.cfg" ]; then
          # venv
          virtualenv_binpath="$(cut -b 1-1024 "${PYENV_ROOT}/versions/${version}/pyvenv.cfg" | sed -n '/^ *home *= */s///p' || true)"
          VIRTUALENV_PREFIX_PATH="${virtualenv_binpath%/bin}"
        else
          # virtualenv
          if [ -d "${PYENV_ROOT}/versions/${version}/Lib" ]; then
            # jython
            virtualenv_libpath="${PYENV_ROOT}/versions/${version}/Lib"
          else
            if [ -d "${PYENV_ROOT}/versions/${version}/lib-python" ]; then
              # pypy
              virtualenv_libpath="${PYENV_ROOT}/versions/${version}/lib-python"
            else
              virtualenv_libpath="${PYENV_ROOT}/versions/${version}/lib"
            fi
          fi
          virtualenv_orig_prefix="$(find "${virtualenv_libpath}/" -maxdepth 2 -type f -and -name "orig-prefix.txt" 2>/dev/null | head -1)"
          if [ -f "${virtualenv_orig_prefix}" ]; then
            VIRTUALENV_PREFIX_PATH="$(cat "${virtualenv_orig_prefix}" 2>/dev/null || true)"
          fi
        fi
      fi
      append_virtualenv_prefix
    elif [ -d "${PYENV_PREFIX_PATH}/conda-meta" ]; then
      # conda
      VIRTUALENV_PREFIX_PATH="$(realpath "${PYENV_PREFIX_PATH}"/../..)"
      append_virtualenv_prefix
    else
      echo "pyenv-virtualenv: version \`${version}' is not a virtualenv" 1>&2
      exit 1
    fi
  else
-    echo "pyenv-virtualenv: \`python' not found in version \`${version}'" 1>&2
+    echo "pyenv-virtualenv: version \`${version}' is not a virtualenv" 1>&2
    exit 1
  fi
 done
-OLDIFS="$IFS"
+IFS=: echo "${VIRTUALENV_PREFIX_PATHS[*]}"
 IFS=:
 echo "${VIRTUALENV_PREFIX_PATHS[*]}"
 IFS="$OLDIFS"
--- a/bin/pyenv-virtualenvs
+++ b/bin/pyenv-virtualenvs
@ -1,131 +1,56 @@
 #!/usr/bin/env bash
 #
 # Summary: List all Python virtualenvs found in `$PYENV_ROOT/versions/*'.
 # Usage: pyenv virtualenvs [--bare] [--skip-aliases]
 #
-# List all virtualenvs found in `$PYENV_ROOT/versions/*' and its `$PYENV_ROOT/versions/envs/*'.
+# Usage: pyenv virtualenvs [--bare]
 #
 set -e
-[[ -n $PYENV_DEBUG ]] && set -x
+[ -n "$PYENV_DEBUG" ] && set -x
-if [[ -z $PYENV_ROOT ]]; then
+if [ -z "$PYENV_ROOT" ]; then
  PYENV_ROOT="${HOME}/.pyenv"
 fi
-unset bare
+if [ "$1" = "--bare" ]; then
-unset skip_aliases
+  hit_prefix=""
-# Provide pyenv completions
+  miss_prefix=""
 for arg; do
  case "$arg" in
  --complete )
    echo --bare
    echo --skip-aliases
    exit ;;
  --bare ) bare=1 ;;
  --skip-aliases ) skip_aliases=1 ;;
  * )
    pyenv-help --usage virtualenvs >&2
    exit 1
    ;;
  esac
 done
 versions_dir="${PYENV_ROOT}/versions"
 if [[ ${BASH_VERSINFO[0]} -gt 3 ]]; then
  declare -A current_versions
 else
  current_versions=()
-fi
+  print_origin=""
-if [[ -z $bare ]]; then
+else
  hit_prefix="* "
  miss_prefix="  "
-  OLDIFS="$IFS"
+  current_versions=($(IFS=:; for version in $(pyenv-version-name); do echo "$version"; done))
-  IFS=:
+  print_origin="1"
  if [[ ${BASH_VERSINFO[0]} -gt 3 ]]; then
    for i in $(pyenv-version-name || true); do
      current_versions["$i"]="1"
    done
  else
    read -r -a current_versions <<< "$(pyenv-version-name || true)"
  fi
  IFS="$OLDIFS"
 fi
-exists() {
+array_exists() {
-  local car="$1"
+  local x car="$1"
  local cdar
  shift
-  for cdar in "$@"; do
+  for x in "$@"; do
-    if [ "${car}" == "${cdar}" ]; then
+    [ "${x}" = "${car}" ] && return 0
      return 0
    fi
  done
  return 1
 }
 print_version() {
-  local version="${1:?}"
+  if [ -n "${print_origin}" ]; then
-  if [[ -n $bare ]]; then
+    local version_origin="$2"
    echo "$version"
    return
  fi
  local path="${2:?}"
  if [[ -L "$path" ]]; then
    version_repr="$version --> $(readlink "$path")"
  else
-    version_repr="$version (created from $(pyenv-virtualenv-prefix "$version" 2>/dev/null))"
+    local version_origin=""
  fi
-  if [[ ${BASH_VERSINFO[0]} -gt 3 && ${current_versions["$1"]} ]] || \
+  if array_exists "$1" "${current_versions[@]}"; then
-     { [[ ${BASH_VERSINFO[0]} -le 3 ]] && exists "$1" "${current_versions[@]}"; }; then
+    echo "${hit_prefix}${1}${version_origin}"
    echo "${hit_prefix}${version_repr} (set by $(pyenv-version-origin))"
  else
-    echo "${miss_prefix}${version_repr}"
+    echo "${miss_prefix}${1}${version_origin}"
  fi
 }
-shopt -s dotglob
+for version in $(pyenv-versions --bare); do
-shopt -s nullglob
+  if [[ "${version}" != "system" ]]; then
-version_dir_entries=("$versions_dir"/*)
+    virtualenv_prefix="$(pyenv-virtualenv-prefix "${version}" 2>/dev/null || true)"
-venv_dir_entries=("$versions_dir"/*/envs/*)
+    if [ -d "${virtualenv_prefix}" ]; then
-
+      print_version "${version}" " (created from ${virtualenv_prefix})"
 if sort --version-sort </dev/null >/dev/null 2>&1; then
    # system sort supports version sorting
    OLDIFS="$IFS"
    IFS='||'
    read -r -a version_dir_entries <<< "$(
        printf "%s||" "${version_dir_entries[@]}" |
        sort --version-sort
    )"
    read -r -a venv_dir_entries <<< "$(
        printf "%s||" "${venv_dir_entries[@]}" |
        sort --version-sort
    )"
    IFS="$OLDIFS"
 fi
 for env_path in "${venv_dir_entries[@]}"; do
  if [[ -d ${env_path} ]]; then
    print_version "${env_path#"${PYENV_ROOT}"/versions/}" "${env_path}"
  fi
 done
 for env_path in "${version_dir_entries[@]}"; do
  if [[ -d ${env_path} ]]; then
    if [[ -L ${env_path} ]]; then
      if [[ -z $skip_aliases ]]; then
        print_version "${env_path#"${PYENV_ROOT}"/versions/}" "${env_path}"
      fi
    # Mimics the test from pyenv-virtualenv-prefix
    # XXX: refactor itto a shared module ?
    elif [[ -f "${env_path}/bin/activate" ]]; then
      print_version "${env_path#"${PYENV_ROOT}"/versions/}" "${env_path}"
    fi
  fi
 done
 shopt -u dotglob
 shopt -u nullglob
--- a/etc/pyenv.d/rehash/envs.bash
+++ b/etc/pyenv.d/rehash/envs.bash
@ -1,11 +0,0 @@
 virtualenv_list_executable_names() {
  local file
  shopt -s nullglob
  for file in "$PYENV_ROOT"/versions/*/envs/*/bin/*; do
    echo "${file##*/}"
  done
  shopt -u nullglob
 }
 if declare -f make_shims 1>/dev/null 2>&1; then
  make_shims $(virtualenv_list_executable_names | sort -u)
 fi
--- a/etc/pyenv.d/uninstall/envs.bash
+++ b/etc/pyenv.d/uninstall/envs.bash
@ -1,32 +0,0 @@
 resolve_link() {
  $(type -p greadlink readlink | head -1) "$1"
 }
 uninstall_related_virtual_env() {
  if [ -n "${DEFINITION}" ]; then
    if [[ "${DEFINITION}" != "${DEFINITION%/envs/*}" ]]; then
      # Uninstall virtualenv by long name
      pyenv-virtualenv-delete ${FORCE+-f} "${DEFINITION}"
    else
      VERSION_NAME="${VERSION_NAME:-${DEFINITION##*/}}"
      PREFIX="${PREFIX:-${PYENV_ROOT}/versions/${VERSION_NAME}}"
      if [ -L "${PREFIX}" ]; then
        REAL_PREFIX="$(resolve_link "${PREFIX}" 2>/dev/null || true)"
        REAL_DEFINITION="${REAL_PREFIX#${PYENV_ROOT}/versions/}"
        if [[ "${REAL_DEFINITION}" != "${REAL_DEFINITION%/envs/*}" ]]; then
          # Uninstall virtualenv by short name
          pyenv-virtualenv-delete ${FORCE+-f} "${REAL_DEFINITION}"
        fi
      else
        # Uninstall all virtualenvs inside `envs` directory too
        shopt -s nullglob
        for virtualenv in "${PREFIX}/envs/"*; do
          pyenv-virtualenv-delete ${FORCE+-f} "${DEFINITION}/envs/${virtualenv##*/}"
        done
        shopt -u nullglob
      fi
    fi
  fi
 }
 before_uninstall "uninstall_related_virtual_env"
--- a/etc/pyenv.d/which/conda.bash
+++ b/etc/pyenv.d/which/conda.bash
@ -1,11 +0,0 @@
 # newer versions of conda share programs from the real prefix
 # this hook tries to find the executable there
 if [ ! -x "${PYENV_COMMAND_PATH}" ] && [[ "${PYENV_COMMAND_PATH##*/}" == "conda" ]]; then
  if [ -d "${PYENV_ROOT}/versions/${version}/conda-meta" ]; then
    conda_command_path="$(pyenv-virtualenv-prefix "$version")"/bin/"${PYENV_COMMAND_PATH##*/}"
    if [ -x "${conda_command_path}" ]; then
      PYENV_COMMAND_PATH="${conda_command_path}"
    fi
  fi
 fi
--- a/etc/pyenv.d/which/python-config.bash
+++ b/etc/pyenv.d/which/python-config.bash
@ -1,43 +0,0 @@
 # 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
  OLDIFS="${IFS}"
  IFS=:
  version="$(pyenv-version-name)"
  IFS="${OLDIFS}"
  if [ -f "${PYENV_ROOT}/versions/${version}/bin/activate" ]; then
    if [ -f "${PYENV_ROOT}/versions/${version}/bin/conda" ]; then
      : # do nothing for conda's environments
    else
      if [ -f "${PYENV_ROOT}/versions/${version}/pyvenv.cfg" ]; then
        # venv
        virtualenv_binpath="$(cut -b 1-1024 "${PYENV_ROOT}/versions/${version}/pyvenv.cfg" | sed -n '/^ *home *= */s///p' || true)"
        virtualenv_prefix="${virtualenv_binpath%/bin}"
      else
        # virtualenv
        if [ -d "${PYENV_ROOT}/versions/${version}/Lib" ]; then
          # jython
          virtualenv_libpath="${PYENV_ROOT}/versions/${version}/Lib"
        else
          if [ -d "${PYENV_ROOT}/versions/${version}/lib-python" ]; then
            # pypy
            virtualenv_libpath="${PYENV_ROOT}/versions/${version}/lib-python"
          else
            virtualenv_libpath="${PYENV_ROOT}/versions/${version}/lib"
          fi
        fi
        virtualenv_orig_prefix="$(find "${virtualenv_libpath}/" -maxdepth 2 -type f -and -name "orig-prefix.txt" 2>/dev/null | head -1)"
        if [ -f "${virtualenv_orig_prefix}" ]; then
          virtualenv_prefix="$(cat "${virtualenv_orig_prefix}" 2>/dev/null || true)"
        fi
      fi
      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/etc/pyenv.d/which/system-site-packages.bash
+++ b/etc/pyenv.d/which/system-site-packages.bash
@ -1,54 +0,0 @@
 # 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
  OLDIFS="${IFS}"
  IFS=:
  version="$(pyenv-version-name)"
  IFS="${OLDIFS}"
  if [ -f "${PYENV_ROOT}/versions/${version}/bin/activate" ]; then
    unset include_system_site_packages
    if [ -f "${PYENV_ROOT}/versions/${version}/bin/conda" ]; then
      : # do nothing for conda's environments
    else
      if [ -f "${PYENV_ROOT}/versions/${version}/pyvenv.cfg" ]; then
        # venv
        virtualenv_binpath="$(cut -b 1-1024 "${PYENV_ROOT}/versions/${version}/pyvenv.cfg" | sed -n '/^ *home *= */s///p' || true)"
        virtualenv_prefix="${virtualenv_binpath%/bin}"
        if grep -q -i "include-system-site-packages *= *true" "${PYENV_ROOT}/versions/${version}/pyvenv.cfg" 1>/dev/null 2>&1; then
          include_system_site_packages=1
        fi
      else
        # virtualenv
        if [ -d "${PYENV_ROOT}/versions/${version}/Lib" ]; then
          # jython
          virtualenv_libpath="${PYENV_ROOT}/versions/${version}/Lib"
        else
          if [ -d "${PYENV_ROOT}/versions/${version}/lib-python" ]; then
            # pypy
            virtualenv_libpath="${PYENV_ROOT}/versions/${version}/lib-python"
          else
            virtualenv_libpath="${PYENV_ROOT}/versions/${version}/lib"
          fi
        fi
        no_global_site_packages="$(find "${virtualenv_libpath}/" -maxdepth 2 -type f -and -name "no-global-site-packages.txt" 2>/dev/null | head -1)"
        if [ ! -f "${no_global_site_packages}" ]; then
          include_system_site_packages=1
        fi
        virtualenv_orig_prefix="$(find "${virtualenv_libpath}/" -maxdepth 2 -type f -and -name "orig-prefix.txt" 2>/dev/null | head -1)"
        if [ -f "${virtualenv_orig_prefix}" ]; then
          virtualenv_prefix="$(cat "${virtualenv_orig_prefix}" 2>/dev/null || true)"
        fi
      fi
      if [ -n "${include_system_site_packages}" ] && [ -n "${virtualenv_prefix}" ]; 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
 fi
--- a/install.sh
+++ b/install.sh
@ -12,22 +12,7 @@ if [ -z "${PREFIX}" ]; then
 fi
 BIN_PATH="${PREFIX}/bin"
 LIBEXEC_PATH="${PREFIX}/libexec"
 SHIMS_PATH="${PREFIX}/shims"
 HOOKS_PATH="${PREFIX}/etc/pyenv.d"
 mkdir -p "$BIN_PATH"
 mkdir -p "$LIBEXEC_PATH"
 mkdir -p "$SHIMS_PATH"
 mkdir -p "$HOOKS_PATH"
 install -p bin/* "$BIN_PATH"
 install -p libexec/* "$LIBEXEC_PATH"
 install -p shims/* "$SHIMS_PATH"
 for hook in etc/pyenv.d/*; do
  if [ -d "$hook" ]; then
    cp -RPp "$hook" "$HOOKS_PATH"
  else
    install -p -m 0644 "$hook" "$HOOKS_PATH"
  fi
 done
--- a/libexec/pyenv-virtualenv-realpath
+++ b/libexec/pyenv-virtualenv-realpath
@ -1,50 +0,0 @@
 #!/usr/bin/env bash
 # Summary: Substitute realpath if unavailable as a builtin or file
 # Usage: . pyenv-virtualenv-realpath
 if ! {
    enable -f "${BASH_SOURCE%/*}"/../../../libexec/pyenv-realpath.dylib realpath ||
      type realpath
  } >/dev/null 2>&1; then
  if [ -n "$PYENV_NATIVE_EXT" ]; then
    echo "pyenv: failed to load \`realpath' builtin" >&2
    exit 1
  fi
  READLINK=$(type -p greadlink readlink | head -1)
  if [ -z "$READLINK" ]; then
    echo "pyenv: cannot find readlink - are you missing GNU coreutils?" >&2
    exit 1
  fi
  resolve_link() {
    $READLINK "$1"
  }
  realpath() {
    local f="$*" \
          name dir
    [[ $f ]] || {
      >&2 echo ${FUNCNAME[0]}: missing operand
      return
    }
    while [[ -L $f ]]; do
      f="$(resolve_link "$f")"
    done
    if [[ ! -d $f ]]; then
      name="/${f##*/}"
      # parent?
      dir="${f%/*}"
      if [[ $dir == $f ]]; then
        #lacks /: parent is current directory
        f="$PWD"
      else
        f="$dir"
      fi
    fi
    #absolute directory
    dir="$(cd "$f"
           pwd)"
    echo "$dir$name"
  }
 fi
--- a/shims/activate
+++ b/shims/activate
@ -1,7 +0,0 @@
 #!/usr/bin/env bash
 if [[ "$0" != "${BASH_SOURCE}" ]]; then
  eval "$(pyenv sh-activate --verbose "$@" || true)"
 else
  echo "pyenv-virtualenv: activate must be sourced. Run 'source activate envname' instead of 'activate envname'" 1>&2
  false
 fi
--- a/shims/deactivate
+++ b/shims/deactivate
@ -1,7 +0,0 @@
 #!/usr/bin/env bash
 if [[ "$0" != "${BASH_SOURCE}" ]]; then
  eval "$(pyenv sh-deactivate --verbose "$@" || true)"
 else
  echo "pyenv-virtualenv: deactivate must be sourced. Run 'source deactivate' instead of 'deactivate'" 1>&2
  false
 fi
--- a/test/activate.bats
+++ b/test/activate.bats
@ -5,19 +5,6 @@ load test_helper
 setup() {
  export HOME="${TMP}"
  export PYENV_ROOT="${TMP}/pyenv"
  unset PYENV_VERSION
  unset PYENV_ACTIVATE_SHELL
  unset VIRTUAL_ENV
  unset CONDA_DEFAULT_ENV
  unset PYTHONHOME
  unset _OLD_VIRTUAL_PYTHONHOME
  unset PYENV_VIRTUALENV_VERBOSE_ACTIVATE
  unset PYENV_VIRTUALENV_DISABLE_PROMPT
  unset PYENV_VIRTUAL_ENV_DISABLE_PROMPT
  unset VIRTUAL_ENV_DISABLE_PROMPT
  unset PYENV_VIRTUALENV_PROMPT
  unset _OLD_VIRTUAL_PS1
  stub pyenv-hooks "activate : echo"
 }
@test "activate virtualenv from current version" {
@ -26,100 +13,41 @@ setup() {
  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-sh-deactivate "--force --quiet : echo deactivated"
  PYENV_SHELL="bash" PYENV_VERSION="venv" run pyenv-sh-activate
  assert_success
  assert_output <<EOS
 deactivated
 export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv";
 export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv";
 export _OLD_VIRTUAL_PS1="\${PS1:-}";
 export PS1="(venv) \${PS1:-}";
 EOS
  unstub pyenv-version-name
  unstub pyenv-virtualenv-prefix
  unstub pyenv-prefix
  unstub pyenv-sh-deactivate
 }
@test "activate virtualenv from current version with custom prompt" {
  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-sh-deactivate "--force --quiet : echo deactivated"
  PYENV_SHELL="bash" PYENV_VERSION="venv" PYENV_VIRTUALENV_PROMPT='venv:{venv}' run pyenv-sh-activate
  assert_success
  assert_output <<EOS
-deactivated
+unset PYENV_DEACTIVATE;
-export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv";
+export PYENV_ACTIVATE="${PYENV_ROOT}/versions/venv";
-export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv";
+. "${PYENV_ROOT}/versions/venv/bin/activate";
 export _OLD_VIRTUAL_PS1="\${PS1:-}";
 export PS1="venv:venv \${PS1:-}";
 EOS
  unstub pyenv-version-name
  unstub pyenv-virtualenv-prefix
  unstub pyenv-prefix
  unstub pyenv-sh-deactivate
 }
@test "activate virtualenv from current version (quiet)" {
  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-sh-deactivate "--force --quiet : echo deactivated"
  PYENV_SHELL="bash" PYENV_VERSION="venv" run pyenv-sh-activate --quiet
  assert_success
  assert_output <<EOS
 deactivated
 export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv";
 export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv";
 export _OLD_VIRTUAL_PS1="\${PS1:-}";
 export PS1="(venv) \${PS1:-}";
 EOS
  unstub pyenv-version-name
  unstub pyenv-virtualenv-prefix
  unstub pyenv-prefix
  unstub pyenv-sh-deactivate
 }
@test "activate virtualenv from current version (verbose)" {
  export PYENV_VIRTUALENV_INIT=1
  export PYENV_VIRTUALENV_VERBOSE_ACTIVATE=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-sh-deactivate "--force --quiet : echo deactivated"
  PYENV_SHELL="bash" PYENV_VERSION="venv" run pyenv-sh-activate --verbose
  assert_success
  assert_output <<EOS
 deactivated
 pyenv-virtualenv: activate venv
 export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv";
 export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv";
 export _OLD_VIRTUAL_PS1="\${PS1:-}";
 export PS1="(venv) \${PS1:-}";
 EOS
  unstub pyenv-version-name
  unstub pyenv-virtualenv-prefix
  unstub pyenv-prefix
-  unstub pyenv-sh-deactivate
+
  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)" {
@ -128,25 +56,20 @@ EOS
  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-sh-deactivate "--force --quiet : echo deactivated"
  PYENV_SHELL="bash" PYENV_VERSION="venv" run pyenv-sh-activate
  assert_success
  assert_output <<EOS
 deactivated
 export PYENV_VERSION="venv";
 export PYENV_ACTIVATE_SHELL=1;
 export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv";
 export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv";
 export _OLD_VIRTUAL_PS1="\${PS1:-}";
 export PS1="(venv) \${PS1:-}";
 EOS
  unstub pyenv-version-name
  unstub pyenv-virtualenv-prefix
  unstub pyenv-prefix
-  unstub pyenv-sh-deactivate
+
  assert_success
  assert_output <<EOS
 pyenv shell "venv";
 unset PYENV_DEACTIVATE;
 export PYENV_ACTIVATE="${PYENV_ROOT}/versions/venv";
 . "${PYENV_ROOT}/versions/venv/bin/activate";
 EOS
 }
@test "activate virtualenv from current version (fish)" {
@ -155,33 +78,19 @@ EOS
  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-sh-deactivate "--force --quiet : echo deactivated"
  PYENV_SHELL="fish" PYENV_VERSION="venv" run pyenv-sh-activate
  assert_success
  assert_output <<EOS
 deactivated
 set -gx PYENV_VIRTUAL_ENV "${PYENV_ROOT}/versions/venv";
 set -gx VIRTUAL_ENV "${PYENV_ROOT}/versions/venv";
 functions -e _pyenv_old_prompt              # remove old prompt function if exists. 
                                            # since everything is in memory, it's safe to
                                            # remove it.
 functions -c fish_prompt _pyenv_old_prompt  # backup old prompt function
 # from python-venv
 function fish_prompt
    set -l prompt (_pyenv_old_prompt)       # call old prompt function first since it might 
                                            # read exit status
    echo -n "(venv) "                    # add virtualenv to prompt
    string join -- \n \$prompt              # handle multiline prompts
 end
 EOS
  unstub pyenv-version-name
  unstub pyenv-virtualenv-prefix
  unstub pyenv-prefix
-  unstub pyenv-sh-deactivate
+
  assert_success
  assert_output <<EOS
 set -e PYENV_DEACTIVATE;
 setenv PYENV_ACTIVATE "${PYENV_ROOT}/versions/venv";
 . "${PYENV_ROOT}/versions/venv/bin/activate.fish";
 EOS
 }
@test "activate virtualenv from current version (fish) (without pyenv-virtualenv-init)" {
@ -190,35 +99,20 @@ EOS
  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-sh-deactivate "--force --quiet : echo deactivated"
  PYENV_SHELL="fish" PYENV_VERSION="venv" run pyenv-sh-activate
  assert_success
  assert_output <<EOS
 deactivated
 set -gx PYENV_VERSION "venv";
 set -gx PYENV_ACTIVATE_SHELL 1;
 set -gx PYENV_VIRTUAL_ENV "${PYENV_ROOT}/versions/venv";
 set -gx VIRTUAL_ENV "${PYENV_ROOT}/versions/venv";
 functions -e _pyenv_old_prompt              # remove old prompt function if exists. 
                                            # since everything is in memory, it's safe to
                                            # remove it.
 functions -c fish_prompt _pyenv_old_prompt  # backup old prompt function
 # from python-venv
 function fish_prompt
    set -l prompt (_pyenv_old_prompt)       # call old prompt function first since it might 
                                            # read exit status
    echo -n "(venv) "                    # add virtualenv to prompt
    string join -- \n \$prompt              # handle multiline prompts
 end
 EOS
  unstub pyenv-version-name
  unstub pyenv-virtualenv-prefix
  unstub pyenv-prefix
-  unstub pyenv-sh-deactivate
+
  assert_success
  assert_output <<EOS
 pyenv shell "venv";
 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" {
@ -226,24 +120,19 @@ EOS
  stub pyenv-virtualenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/venv27\""
  stub pyenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/venv27\""
  stub pyenv-sh-deactivate "--force --quiet : echo deactivated"
-  PYENV_SHELL="bash" PYENV_VERSION="venv" run pyenv-sh-activate "venv27"
+  run pyenv-sh-activate "venv27"
  assert_success
  assert_output <<EOS
 deactivated
 export PYENV_VERSION="venv27";
 export PYENV_ACTIVATE_SHELL=1;
 export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv27";
 export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv27";
 export _OLD_VIRTUAL_PS1="\${PS1:-}";
 export PS1="(venv27) \${PS1:-}";
 EOS
  unstub pyenv-virtualenv-prefix
  unstub pyenv-prefix
-  unstub pyenv-sh-deactivate
+
  assert_success
  assert_output <<EOS
 pyenv shell "venv27";
 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)" {
@ -251,150 +140,58 @@ EOS
  stub pyenv-virtualenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/venv27\""
  stub pyenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/venv27\""
  stub pyenv-sh-deactivate "--force --quiet : echo deactivated"
-  PYENV_SHELL="bash" PYENV_VERSION="venv" run pyenv-sh-activate "venv27"
+  run pyenv-sh-activate "venv27"
  assert_success
  assert_output <<EOS
 deactivated
 export PYENV_VERSION="venv27";
 export PYENV_ACTIVATE_SHELL=1;
 export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv27";
 export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv27";
 export _OLD_VIRTUAL_PS1="\${PS1:-}";
 export PS1="(venv27) \${PS1:-}";
 EOS
  unstub pyenv-virtualenv-prefix
  unstub pyenv-prefix
  unstub pyenv-sh-deactivate
 }
@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-sh-deactivate "--force --quiet : echo deactivated"
  PYENV_SHELL="fish" PYENV_VERSION="venv" run pyenv-sh-activate "venv27"
  assert_success
  assert_output <<EOS
-deactivated
+pyenv shell "venv27";
-set -gx PYENV_VERSION "venv27";
+unset PYENV_DEACTIVATE;
-set -gx PYENV_ACTIVATE_SHELL 1;
+export PYENV_ACTIVATE="${PYENV_ROOT}/versions/venv27";
-set -gx PYENV_VIRTUAL_ENV "${PYENV_ROOT}/versions/venv27";
+. "${PYENV_ROOT}/versions/venv27/bin/activate";
 set -gx VIRTUAL_ENV "${PYENV_ROOT}/versions/venv27";
 functions -e _pyenv_old_prompt              # remove old prompt function if exists. 
                                            # since everything is in memory, it's safe to
                                            # remove it.
 functions -c fish_prompt _pyenv_old_prompt  # backup old prompt function
 # from python-venv
 function fish_prompt
    set -l prompt (_pyenv_old_prompt)       # call old prompt function first since it might 
                                            # read exit status
    echo -n "(venv27) "                    # add virtualenv to prompt
    string join -- \n \$prompt              # handle multiline prompts
 end
 EOS
  unstub pyenv-virtualenv-prefix
  unstub pyenv-prefix
  unstub pyenv-sh-deactivate
 }
@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-sh-deactivate "--force --quiet : echo deactivated"
  PYENV_SHELL="fish" PYENV_VERSION="venv" run pyenv-sh-activate "venv27"
  assert_success
  assert_output <<EOS
 deactivated
 set -gx PYENV_VERSION "venv27";
 set -gx PYENV_ACTIVATE_SHELL 1;
 set -gx PYENV_VIRTUAL_ENV "${PYENV_ROOT}/versions/venv27";
 set -gx VIRTUAL_ENV "${PYENV_ROOT}/versions/venv27";
 functions -e _pyenv_old_prompt              # remove old prompt function if exists. 
                                            # since everything is in memory, it's safe to
                                            # remove it.
 functions -c fish_prompt _pyenv_old_prompt  # backup old prompt function
 # from python-venv
 function fish_prompt
    set -l prompt (_pyenv_old_prompt)       # call old prompt function first since it might 
                                            # read exit status
    echo -n "(venv27) "                    # add virtualenv to prompt
    string join -- \n \$prompt              # handle multiline prompts
 end
 EOS
  unstub pyenv-virtualenv-prefix
  unstub pyenv-prefix
  unstub pyenv-sh-deactivate
 }
@test "unset invokes deactivate" {
  export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
  export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
  export PYENV_ACTIVATE_SHELL=
  stub pyenv-sh-deactivate " : echo deactivated"
  run pyenv-sh-activate --unset
  assert_success
  assert_output <<EOS
-deactivated
+pyenv deactivate
 EOS
  unstub pyenv-sh-deactivate
 }
@test "should fail if the version is not a virtualenv" {
  stub pyenv-virtualenv-prefix "3.3.3 : false"
  stub pyenv-version-name " : echo 3.3.3"
  stub pyenv-virtualenv-prefix "3.3.3/envs/3.3.3 : false"
  run pyenv-sh-activate "3.3.3"
  unstub pyenv-virtualenv-prefix
  assert_failure
  assert_output <<EOS
 pyenv-virtualenv: version \`3.3.3' is not a virtualenv
 false
 EOS
  unstub pyenv-virtualenv-prefix
  unstub pyenv-version-name
 }
-@test "should fail if the version is not a virtualenv (quiet)" {
+@test "should fail if the version is not a virtualenv (no-error)" {
  stub pyenv-virtualenv-prefix "3.3.3 : false"
  stub pyenv-version-name " : echo 3.3.3"
  stub pyenv-virtualenv-prefix "3.3.3/envs/3.3.3 : false"
-  run pyenv-sh-activate --quiet "3.3.3"
+  run pyenv-sh-activate --no-error "3.3.3"
  unstub pyenv-virtualenv-prefix
  assert_failure
  assert_output <<EOS
 false
 EOS
  unstub pyenv-virtualenv-prefix
  unstub pyenv-version-name
 }
@test "should fail if there are multiple versions" {
  stub pyenv-virtualenv-prefix "venv : true"
  stub pyenv-virtualenv-prefix "venv27 : true"
  run pyenv-sh-activate "venv" "venv27"
  assert_failure
@ -402,94 +199,14 @@ EOS
 pyenv-virtualenv: cannot activate multiple versions at once: venv venv27
 false
 EOS
  unstub pyenv-virtualenv-prefix
 }
-@test "should fail if there are multiple virtualenvs (quiet)" {
+@test "should fail if there are multiple versions (no-error)" {
-  stub pyenv-virtualenv-prefix "venv : true"
+  run pyenv-sh-activate --no-error "venv" "venv27"
  stub pyenv-virtualenv-prefix "venv27 : true"
  run pyenv-sh-activate --quiet "venv" "venv27"
  assert_failure
  assert_output <<EOS
 false
 EOS
  unstub pyenv-virtualenv-prefix
 }
@test "should fail if the first version is not a virtualenv" {
  export PYENV_VIRTUALENV_INIT=1
  stub pyenv-virtualenv-prefix "2.7.10 : false"
  stub pyenv-version-name " : echo 2.7.10"
  stub pyenv-virtualenv-prefix "2.7.10/envs/2.7.10 : false"
  run pyenv-sh-activate "2.7.10" "venv27"
  assert_failure
  assert_output <<EOS
 pyenv-virtualenv: version \`2.7.10' is not a virtualenv
 false
 EOS
  unstub pyenv-virtualenv-prefix
  unstub pyenv-version-name
 }
@test "activate if the first virtualenv is a virtualenv" {
  export PYENV_VIRTUALENV_INIT=1
  stub pyenv-sh-deactivate "--force --quiet : echo deactivated"
  stub pyenv-virtualenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/venv27\""
  stub pyenv-virtualenv-prefix "2.7.10 : false"
  stub pyenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/venv27\""
  PYENV_SHELL="bash" run pyenv-sh-activate "venv27" "2.7.10"
  assert_success
  assert_output <<EOS
 deactivated
 export PYENV_VERSION="venv27:2.7.10";
 export PYENV_ACTIVATE_SHELL=1;
 export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv27";
 export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv27";
 export _OLD_VIRTUAL_PS1="\${PS1:-}";
 export PS1="(venv27) \${PS1:-}";
 EOS
  unstub pyenv-sh-deactivate
  unstub pyenv-virtualenv-prefix
  unstub pyenv-prefix
 }
@test "do nothing if a 3rd-party virtualenv is active" {
  export PYENV_VIRTUALENV_INIT=1
  export VIRTUAL_ENV="${TMP}/venv-3rd-party"
  unset PYENV_VIRTUAL_ENV
  PYENV_SHELL="bash" run pyenv-sh-activate "venv"
  assert_success
  assert_output <<EOS
 pyenv-virtualenv: virtualenv \`${TMP}/venv-3rd-party' is already activated
 true
 EOS
 }
@test "do nothing if a 3rd-party virtualenv is active over ours" {
  export PYENV_VIRTUALENV_INIT=1
  export VIRTUAL_ENV="${TMP}/venv-3rd-party"
  export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
  PYENV_SHELL="bash" run pyenv-sh-activate "venv"
  assert_success
  assert_output <<EOS
 pyenv-virtualenv: virtualenv \`${TMP}/venv-3rd-party' is already activated
 true
 EOS
 }
--- a/test/conda-activate.bats
+++ b/test/conda-activate.bats
@ -1,215 +0,0 @@
 #!/usr/bin/env bats
 load test_helper
 setup() {
  export HOME="${TMP}"
  export PYENV_ROOT="${TMP}/pyenv"
  unset PYENV_VERSION
  unset PYENV_ACTIVATE_SHELL
  unset PYENV_VIRTUAL_ENV
  unset VIRTUAL_ENV
  unset CONDA_DEFAULT_ENV
  unset PYTHONHOME
  unset _OLD_VIRTUAL_PYTHONHOME
  unset PYENV_VIRTUALENV_VERBOSE_ACTIVATE
  unset PYENV_VIRTUALENV_DISABLE_PROMPT
  unset PYENV_VIRTUAL_ENV_DISABLE_PROMPT
  unset VIRTUAL_ENV_DISABLE_PROMPT
  unset PYENV_VIRTUALENV_PROMPT
  unset _OLD_VIRTUAL_PS1
  stub pyenv-hooks "activate : echo"
 }
 teardown() {
  unstub pyenv-hooks
 }
@test "activate conda root from current version" {
  export PYENV_VIRTUALENV_INIT=1
  setup_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-sh-deactivate "--force --quiet : echo deactivated"
  PYENV_SHELL="bash" PYENV_VERSION="anaconda-2.3.0" run pyenv-sh-activate
  assert_success
  assert_output <<EOS
 deactivated
 export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/anaconda-2.3.0";
 export VIRTUAL_ENV="${PYENV_ROOT}/versions/anaconda-2.3.0";
 export CONDA_DEFAULT_ENV="root";
 export _OLD_VIRTUAL_PS1="\${PS1:-}";
 export PS1="(anaconda-2.3.0) \${PS1:-}";
 export CONDA_PREFIX="${TMP}/pyenv/versions/anaconda-2.3.0";
 EOS
  unstub pyenv-version-name
  unstub pyenv-virtualenv-prefix
  unstub pyenv-prefix
  unstub pyenv-sh-deactivate
  teardown_conda "anaconda-2.3.0"
 }
@test "activate conda root from current version with custom prompt" {
  export PYENV_VIRTUALENV_INIT=1
  setup_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-sh-deactivate "--force --quiet : echo deactivated"
  PYENV_SHELL="bash" PYENV_VERSION="anaconda-2.3.0" PYENV_VIRTUALENV_PROMPT='venv:{venv}' run pyenv-sh-activate
  assert_success
  assert_output <<EOS
 deactivated
 export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/anaconda-2.3.0";
 export VIRTUAL_ENV="${PYENV_ROOT}/versions/anaconda-2.3.0";
 export CONDA_DEFAULT_ENV="root";
 export _OLD_VIRTUAL_PS1="\${PS1:-}";
 export PS1="venv:anaconda-2.3.0 \${PS1:-}";
 export CONDA_PREFIX="${TMP}/pyenv/versions/anaconda-2.3.0";
 EOS
  unstub pyenv-version-name
  unstub pyenv-virtualenv-prefix
  unstub pyenv-prefix
  unstub pyenv-sh-deactivate
  teardown_conda "anaconda-2.3.0"
 }
@test "activate conda root from current version (fish)" {
  export PYENV_VIRTUALENV_INIT=1
  setup_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-sh-deactivate "--force --quiet : echo deactivated"
  PYENV_SHELL="fish" PYENV_VERSION="anaconda-2.3.0" run pyenv-sh-activate
  assert_success
  assert_output <<EOS
 deactivated
 set -gx PYENV_VIRTUAL_ENV "${TMP}/pyenv/versions/anaconda-2.3.0";
 set -gx VIRTUAL_ENV "${TMP}/pyenv/versions/anaconda-2.3.0";
 set -gx CONDA_DEFAULT_ENV "root";
 functions -e _pyenv_old_prompt              # remove old prompt function if exists. 
                                            # since everything is in memory, it's safe to
                                            # remove it.
 functions -c fish_prompt _pyenv_old_prompt  # backup old prompt function
 # from python-venv
 function fish_prompt
    set -l prompt (_pyenv_old_prompt)       # call old prompt function first since it might 
                                            # read exit status
    echo -n "(anaconda-2.3.0) "                    # add virtualenv to prompt
    string join -- \n \$prompt              # handle multiline prompts
 end
 EOS
  unstub pyenv-version-name
  unstub pyenv-virtualenv-prefix
  unstub pyenv-prefix
  unstub pyenv-sh-deactivate
  teardown_conda "anaconda-2.3.0"
 }
@test "activate conda root from command-line argument" {
  export PYENV_VIRTUALENV_INIT=1
  setup_conda "anaconda-2.3.0"
  setup_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-sh-deactivate "--force --quiet : echo deactivated"
  PYENV_SHELL="bash" PYENV_VERSION="anaconda-2.3.0" run pyenv-sh-activate "miniconda-3.9.1"
  assert_success
  assert_output <<EOS
 deactivated
 export PYENV_VERSION="miniconda-3.9.1";
 export PYENV_ACTIVATE_SHELL=1;
 export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/miniconda-3.9.1";
 export VIRTUAL_ENV="${PYENV_ROOT}/versions/miniconda-3.9.1";
 export CONDA_DEFAULT_ENV="root";
 export _OLD_VIRTUAL_PS1="\${PS1:-}";
 export PS1="(miniconda-3.9.1) \${PS1:-}";
 export CONDA_PREFIX="${TMP}/pyenv/versions/miniconda-3.9.1";
 EOS
  unstub pyenv-virtualenv-prefix
  unstub pyenv-prefix
  unstub pyenv-sh-deactivate
  teardown_conda "anaconda-2.3.0"
  teardown_conda "miniconda-3.9.1"
 }
@test "activate conda env from current version" {
  export PYENV_VIRTUALENV_INIT=1
  setup_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-sh-deactivate "--force --quiet : echo deactivated"
  PYENV_SHELL="bash" PYENV_VERSION="anaconda-2.3.0/envs/foo" run pyenv-sh-activate
  assert_success
  assert_output <<EOS
 deactivated
 export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/anaconda-2.3.0/envs/foo";
 export VIRTUAL_ENV="${PYENV_ROOT}/versions/anaconda-2.3.0/envs/foo";
 export CONDA_DEFAULT_ENV="foo";
 export _OLD_VIRTUAL_PS1="\${PS1:-}";
 export PS1="(anaconda-2.3.0/envs/foo) \${PS1:-}";
 export CONDA_PREFIX="${TMP}/pyenv/versions/anaconda-2.3.0/envs/foo";
 . "${PYENV_ROOT}/versions/anaconda-2.3.0/envs/foo/etc/conda/activate.d/activate.sh";
 EOS
  unstub pyenv-version-name
  unstub pyenv-virtualenv-prefix
  unstub pyenv-prefix
  unstub pyenv-sh-deactivate
  teardown_conda "anaconda-2.3.0" "foo"
 }
@test "activate conda env from command-line argument" {
  export PYENV_VIRTUALENV_INIT=1
  setup_conda "anaconda-2.3.0" "foo"
  setup_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-sh-deactivate "--force --quiet : echo deactivated"
  PYENV_SHELL="bash" PYENV_VERSION="anaconda-2.3.0/envs/foo" run pyenv-sh-activate "miniconda-3.9.1/envs/bar"
  assert_success
  assert_output <<EOS
 deactivated
 export PYENV_VERSION="miniconda-3.9.1/envs/bar";
 export PYENV_ACTIVATE_SHELL=1;
 export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/miniconda-3.9.1/envs/bar";
 export VIRTUAL_ENV="${PYENV_ROOT}/versions/miniconda-3.9.1/envs/bar";
 export CONDA_DEFAULT_ENV="bar";
 export _OLD_VIRTUAL_PS1="\${PS1:-}";
 export PS1="(miniconda-3.9.1/envs/bar) \${PS1:-}";
 export CONDA_PREFIX="${TMP}/pyenv/versions/miniconda-3.9.1/envs/bar";
 . "${PYENV_ROOT}/versions/miniconda-3.9.1/envs/bar/etc/conda/activate.d/activate.sh";
 EOS
  unstub pyenv-virtualenv-prefix
  unstub pyenv-prefix
  unstub pyenv-sh-deactivate
  teardown_conda "anaconda-2.3.0" "foo"
  teardown_conda "miniconda-3.9.1" "bar"
 }
--- a/test/conda-deactivate.bats
+++ b/test/conda-deactivate.bats
@ -1,135 +0,0 @@
 #!/usr/bin/env bats
 load test_helper
 setup() {
  export PYENV_ROOT="${TMP}/pyenv"
  unset PYENV_VERSION
  unset PYENV_ACTIVATE_SHELL
  unset PYENV_VIRTUAL_ENV
  unset VIRTUAL_ENV
  unset CONDA_DEFAULT_ENV
  unset PYTHONHOME
  unset _OLD_VIRTUAL_PYTHONHOME
  unset PYENV_VIRTUALENV_VERBOSE_ACTIVATE
  unset PYENV_VIRTUALENV_DISABLE_PROMPT
  unset PYENV_VIRTUAL_ENV_DISABLE_PROMPT
  unset VIRTUAL_ENV_DISABLE_PROMPT
  unset _OLD_VIRTUAL_PS1
  stub pyenv-hooks "deactivate : echo"
 }
 teardown() {
  unstub pyenv-hooks
 }
@test "deactivate conda root" {
  export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/anaconda-2.3.0"
  export VIRTUAL_ENV="${PYENV_ROOT}/versions/anaconda-2.3.0"
  export PYENV_ACTIVATE_SHELL=
  export CONDA_DEFAULT_ENV="root"
  setup_conda "anaconda-2.3.0"
  PYENV_SHELL="bash" run pyenv-sh-deactivate
  assert_success
  assert_output <<EOS
 unset CONDA_PREFIX
 unset PYENV_VIRTUAL_ENV;
 unset VIRTUAL_ENV;
 unset CONDA_DEFAULT_ENV;
 if [ -n "\${_OLD_VIRTUAL_PATH:-}" ]; then
  export PATH="\${_OLD_VIRTUAL_PATH}";
  unset _OLD_VIRTUAL_PATH;
 fi;
 if [ -n "\${_OLD_VIRTUAL_PYTHONHOME:-}" ]; then
  export PYTHONHOME="\${_OLD_VIRTUAL_PYTHONHOME}";
  unset _OLD_VIRTUAL_PYTHONHOME;
 fi;
 if [ -n "\${_OLD_VIRTUAL_PS1:-}" ]; then
  export PS1="\${_OLD_VIRTUAL_PS1}";
  unset _OLD_VIRTUAL_PS1;
 fi;
 if declare -f deactivate 1>/dev/null 2>&1; then
  unset -f deactivate;
 fi;
 EOS
  teardown_conda "anaconda-2.3.0"
 }
@test "deactivate conda root (fish)" {
  export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/anaconda-2.3.0"
  export VIRTUAL_ENV="${PYENV_ROOT}/versions/anaconda-2.3.0"
  export PYENV_ACTIVATE_SHELL=
  export CONDA_DEFAULT_ENV="root"
  setup_conda "anaconda-2.3.0"
  PYENV_SHELL="fish" run pyenv-sh-deactivate
  assert_success
  assert_output <<EOS
 set -e PYENV_VIRTUAL_ENV;
 set -e VIRTUAL_ENV;
 set -e CONDA_DEFAULT_ENV;
 if [ -n "\$_OLD_VIRTUAL_PATH" ];
  set -gx PATH "\$_OLD_VIRTUAL_PATH";
  set -e _OLD_VIRTUAL_PATH;
 end;
 if [ -n "\$_OLD_VIRTUAL_PYTHONHOME" ];
  set -gx PYTHONHOME "\$_OLD_VIRTUAL_PYTHONHOME";
  set -e _OLD_VIRTUAL_PYTHONHOME;
 end;
 # check if old prompt function exists
 if functions -q _pyenv_old_prompt
  # remove old prompt function if exists.
  functions -e fish_prompt
  functions -c _pyenv_old_prompt fish_prompt
  functions -e _pyenv_old_prompt
 end
 if functions -q deactivate;
  functions -e deactivate;
 end;
 EOS
  teardown_conda "anaconda-2.3.0"
 }
@test "deactivate conda env" {
  export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/anaconda-2.3.0/envs/foo"
  export VIRTUAL_ENV="${PYENV_ROOT}/versions/anaconda-2.3.0/envs/foo"
  export PYENV_ACTIVATE_SHELL=
  export CONDA_DEFAULT_ENV="foo"
  setup_conda "anaconda-2.3.0" "foo"
  PYENV_SHELL="bash" run pyenv-sh-deactivate
  assert_success
  assert_output <<EOS
 . "${PYENV_ROOT}/versions/anaconda-2.3.0/envs/foo/etc/conda/deactivate.d/deactivate.sh";
 unset CONDA_PREFIX
 unset PYENV_VIRTUAL_ENV;
 unset VIRTUAL_ENV;
 unset CONDA_DEFAULT_ENV;
 if [ -n "\${_OLD_VIRTUAL_PATH:-}" ]; then
  export PATH="\${_OLD_VIRTUAL_PATH}";
  unset _OLD_VIRTUAL_PATH;
 fi;
 if [ -n "\${_OLD_VIRTUAL_PYTHONHOME:-}" ]; then
  export PYTHONHOME="\${_OLD_VIRTUAL_PYTHONHOME}";
  unset _OLD_VIRTUAL_PYTHONHOME;
 fi;
 if [ -n "\${_OLD_VIRTUAL_PS1:-}" ]; then
  export PS1="\${_OLD_VIRTUAL_PS1}";
  unset _OLD_VIRTUAL_PS1;
 fi;
 if declare -f deactivate 1>/dev/null 2>&1; then
  unset -f deactivate;
 fi;
 EOS
  teardown_conda "anaconda-2.3.0" "foo"
 }
--- a/test/conda-prefix.bats
+++ b/test/conda-prefix.bats
@ -1,37 +0,0 @@
 #!/usr/bin/env bats
 load test_helper
 setup() {
  export PYENV_ROOT="${TMP}/pyenv"
 }
@test "display conda root" {
  setup_conda "anaconda-2.3.0"
  stub pyenv-version-name "echo anaconda-2.3.0"
  PYENV_VERSION="anaconda-2.3.0" run pyenv-virtualenv-prefix
  assert_success
  assert_output <<OUT
 ${PYENV_ROOT}/versions/anaconda-2.3.0
 OUT
  unstub pyenv-version-name
  teardown_conda "anaconda-2.3.0"
 }
@test "display conda env" {
  setup_conda "anaconda-2.3.0" "foo"
  stub pyenv-version-name "echo anaconda-2.3.0/envs/foo"
  PYENV_VERSION="anaconda-2.3.0/envs/foo" run pyenv-virtualenv-prefix
  assert_success
  assert_output <<OUT
 ${PYENV_ROOT}/versions/anaconda-2.3.0/envs/foo
 OUT
  unstub pyenv-version-name
  teardown_conda "anaconda-2.3.0" "foo"
 }
--- a/test/conda.bats
+++ b/test/conda.bats
@ -1,91 +0,0 @@
 #!/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 "create virtualenv by conda create" {
  export PYENV_VERSION="miniconda3-3.16.0"
  setup_conda "${PYENV_VERSION}"
  stub_pyenv "${PYENV_VERSION}"
  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
  stub pyenv-virtualenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
  stub -N pyenv-exec "conda list * : true"
  stub -N pyenv-exec "conda create * : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
  stub pyenv-exec "python -s -m ensurepip : true"
  run pyenv-virtualenv venv
  assert_success
  assert_output_wildcards <<OUT
 PYENV_VERSION=miniconda3-3.16.0 conda create --name venv --yes --file /dev/fd/*
 rehashed
 OUT
  unstub_pyenv
  unstub pyenv-virtualenv-prefix
  unstub pyenv-exec
  teardown_m_venv "miniconda3-3.16.0"
 }
@test "create virtualenv by conda create with -p" {
  export PYENV_VERSION="miniconda3-3.16.0"
  setup_conda "${PYENV_VERSION}"
  stub_pyenv "${PYENV_VERSION}"
  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
  stub pyenv-virtualenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
  stub pyenv-exec "conda create * : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
  stub pyenv-exec "python -s -m ensurepip : true"
  run pyenv-virtualenv -p python3.5 venv
  assert_success
  assert_output <<OUT
 PYENV_VERSION=miniconda3-3.16.0 conda create --name venv --yes python=3.5
 rehashed
 OUT
  unstub_pyenv
  unstub pyenv-virtualenv-prefix
  unstub pyenv-exec
  teardown_m_venv "miniconda3-3.16.0"
 }
@test "create virtualenv by conda create with --python" {
  export PYENV_VERSION="miniconda3-3.16.0"
  setup_conda "${PYENV_VERSION}"
  stub_pyenv "${PYENV_VERSION}"
  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
  stub pyenv-virtualenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
  stub pyenv-exec "conda create * : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
  stub pyenv-exec "python -s -m ensurepip : true"
  run pyenv-virtualenv --python=python3.5 venv
  assert_success
  assert_output <<OUT
 PYENV_VERSION=miniconda3-3.16.0 conda create --name venv --yes python=3.5
 rehashed
 OUT
  unstub_pyenv
  unstub pyenv-virtualenv-prefix
  unstub pyenv-exec
  teardown_m_venv "miniconda3-3.16.0"
 }
--- a/test/deactivate.bats
+++ b/test/deactivate.bats
@ -4,372 +4,214 @@ load test_helper
 setup() {
  export PYENV_ROOT="${TMP}/pyenv"
  unset PYENV_VERSION
  unset PYENV_ACTIVATE_SHELL
  unset PYENV_VIRTUAL_ENV
  unset VIRTUAL_ENV
  unset CONDA_DEFAULT_ENV
  unset PYTHONHOME
  unset _OLD_VIRTUAL_PYTHONHOME
  unset PYENV_VIRTUALENV_VERBOSE_ACTIVATE
  unset PYENV_VIRTUALENV_DISABLE_PROMPT
  unset PYENV_VIRTUAL_ENV_DISABLE_PROMPT
  unset VIRTUAL_ENV_DISABLE_PROMPT
  unset _OLD_VIRTUAL_PS1
  stub pyenv-hooks "deactivate : echo"
 }
@test "deactivate virtualenv" {
  export PYENV_VIRTUALENV_INIT=1
-  export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
+  export PYENV_ACTIVATE="${PYENV_ROOT}/versions/venv"
  export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
  export PYENV_ACTIVATE_SHELL=
  PYENV_SHELL="bash" run pyenv-sh-deactivate
  assert_success
  assert_output <<EOS
 unset PYENV_VIRTUAL_ENV;
 unset VIRTUAL_ENV;
 if [ -n "\${_OLD_VIRTUAL_PATH:-}" ]; then
  export PATH="\${_OLD_VIRTUAL_PATH}";
  unset _OLD_VIRTUAL_PATH;
 fi;
 if [ -n "\${_OLD_VIRTUAL_PYTHONHOME:-}" ]; then
  export PYTHONHOME="\${_OLD_VIRTUAL_PYTHONHOME}";
  unset _OLD_VIRTUAL_PYTHONHOME;
 fi;
 if [ -n "\${_OLD_VIRTUAL_PS1:-}" ]; then
  export PS1="\${_OLD_VIRTUAL_PS1}";
  unset _OLD_VIRTUAL_PS1;
 fi;
 if declare -f deactivate 1>/dev/null 2>&1; then
-  unset -f deactivate;
+  export PYENV_DEACTIVATE="$PYENV_ACTIVATE";
-fi;
+  unset PYENV_ACTIVATE;
-EOS
+  deactivate;
-}
+else
-
+  echo "pyenv-virtualenv: no virtualenv has been activated." 1>&2;
-@test "deactivate virtualenv (quiet)" {
+  false;
  export PYENV_VIRTUALENV_INIT=1
  export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
  export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
  export PYENV_ACTIVATE_SHELL=
  PYENV_SHELL="bash" run pyenv-sh-deactivate --quiet
  assert_success
  assert_output <<EOS
 unset PYENV_VIRTUAL_ENV;
 unset VIRTUAL_ENV;
 if [ -n "\${_OLD_VIRTUAL_PATH:-}" ]; then
  export PATH="\${_OLD_VIRTUAL_PATH}";
  unset _OLD_VIRTUAL_PATH;
 fi;
 if [ -n "\${_OLD_VIRTUAL_PYTHONHOME:-}" ]; then
  export PYTHONHOME="\${_OLD_VIRTUAL_PYTHONHOME}";
  unset _OLD_VIRTUAL_PYTHONHOME;
 fi;
 if [ -n "\${_OLD_VIRTUAL_PS1:-}" ]; then
  export PS1="\${_OLD_VIRTUAL_PS1}";
  unset _OLD_VIRTUAL_PS1;
 fi;
 if declare -f deactivate 1>/dev/null 2>&1; then
  unset -f deactivate;
 fi;
 EOS
 }
@test "deactivate virtualenv (verbose)" {
  export PYENV_VIRTUALENV_INIT=1
-  export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
+  export PYENV_ACTIVATE="${PYENV_ROOT}/versions/venv"
  export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
  export PYENV_ACTIVATE_SHELL=
  export PYENV_VIRTUALENV_VERBOSE_ACTIVATE=1
  PYENV_SHELL="bash" run pyenv-sh-deactivate --verbose
  assert_success
  assert_output <<EOS
 pyenv-virtualenv: deactivate venv
 unset PYENV_VIRTUAL_ENV;
 unset VIRTUAL_ENV;
 if [ -n "\${_OLD_VIRTUAL_PATH:-}" ]; then
  export PATH="\${_OLD_VIRTUAL_PATH}";
  unset _OLD_VIRTUAL_PATH;
 fi;
 if [ -n "\${_OLD_VIRTUAL_PYTHONHOME:-}" ]; then
  export PYTHONHOME="\${_OLD_VIRTUAL_PYTHONHOME}";
  unset _OLD_VIRTUAL_PYTHONHOME;
 fi;
 if [ -n "\${_OLD_VIRTUAL_PS1:-}" ]; then
  export PS1="\${_OLD_VIRTUAL_PS1}";
  unset _OLD_VIRTUAL_PS1;
 fi;
 if declare -f deactivate 1>/dev/null 2>&1; then
-  unset -f deactivate;
+  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 (with shell activation)" {
+@test "deactivate virtualenv (no-error)" {
  export PYENV_VIRTUALENV_INIT=1
-  export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
+  export PYENV_ACTIVATE="${PYENV_ROOT}/versions/venv"
-  export VIRTUAL_ENV="${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
  export PYENV_DEACTIVATE="$PYENV_ACTIVATE";
  unset PYENV_ACTIVATE;
  deactivate;
 else
  false;
 fi;
 EOS
 }
@test "deactivate virtualenv (without pyenv-virtualenv-init)" {
  export PYENV_VIRTUALENV_INIT=
  export PYENV_ACTIVATE="${PYENV_ROOT}/versions/venv"
  PYENV_SHELL="bash" run pyenv-sh-deactivate
  assert_success
  assert_output <<EOS
 unset PYENV_VERSION;
 unset PYENV_ACTIVATE_SHELL;
 unset PYENV_VIRTUAL_ENV;
 unset VIRTUAL_ENV;
 if [ -n "\${_OLD_VIRTUAL_PATH:-}" ]; then
  export PATH="\${_OLD_VIRTUAL_PATH}";
  unset _OLD_VIRTUAL_PATH;
 fi;
 if [ -n "\${_OLD_VIRTUAL_PYTHONHOME:-}" ]; then
  export PYTHONHOME="\${_OLD_VIRTUAL_PYTHONHOME}";
  unset _OLD_VIRTUAL_PYTHONHOME;
 fi;
 if [ -n "\${_OLD_VIRTUAL_PS1:-}" ]; then
  export PS1="\${_OLD_VIRTUAL_PS1}";
  unset _OLD_VIRTUAL_PS1;
 fi;
 if declare -f deactivate 1>/dev/null 2>&1; then
-  unset -f deactivate;
+  pyenv shell --unset;
  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) (quiet)" {
+@test "deactivate virtualenv (without pyenv-virtualenv-init) (no-error)" {
-  export PYENV_VIRTUALENV_INIT=1
+  export PYENV_VIRTUALENV_INIT=
-  export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
+  export PYENV_ACTIVATE="${PYENV_ROOT}/versions/venv"
  export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
  export PYENV_ACTIVATE_SHELL=1
-  PYENV_SHELL="bash" run pyenv-sh-deactivate --quiet
+  PYENV_SHELL="bash" run pyenv-sh-deactivate --no-error
  assert_success
  assert_output <<EOS
 unset PYENV_VERSION;
 unset PYENV_ACTIVATE_SHELL;
 unset PYENV_VIRTUAL_ENV;
 unset VIRTUAL_ENV;
 if [ -n "\${_OLD_VIRTUAL_PATH:-}" ]; then
  export PATH="\${_OLD_VIRTUAL_PATH}";
  unset _OLD_VIRTUAL_PATH;
 fi;
 if [ -n "\${_OLD_VIRTUAL_PYTHONHOME:-}" ]; then
  export PYTHONHOME="\${_OLD_VIRTUAL_PYTHONHOME}";
  unset _OLD_VIRTUAL_PYTHONHOME;
 fi;
 if [ -n "\${_OLD_VIRTUAL_PS1:-}" ]; then
  export PS1="\${_OLD_VIRTUAL_PS1}";
  unset _OLD_VIRTUAL_PS1;
 fi;
 if declare -f deactivate 1>/dev/null 2>&1; then
-  unset -f deactivate;
+  pyenv shell --unset;
  export PYENV_DEACTIVATE="$PYENV_ACTIVATE";
  unset PYENV_ACTIVATE;
  deactivate;
 else
  false;
 fi;
 EOS
 }
@test "deactivate virtualenv which has been activated manually" {
  export PYENV_VIRTUALENV_INIT=1
  export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
  export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
  export PYENV_ACTIVATE_SHELL=
  PYENV_SHELL="bash" run pyenv-sh-deactivate
  assert_success
  assert_output <<EOS
 unset PYENV_VIRTUAL_ENV;
 unset VIRTUAL_ENV;
 if [ -n "\${_OLD_VIRTUAL_PATH:-}" ]; then
  export PATH="\${_OLD_VIRTUAL_PATH}";
  unset _OLD_VIRTUAL_PATH;
 fi;
 if [ -n "\${_OLD_VIRTUAL_PYTHONHOME:-}" ]; then
  export PYTHONHOME="\${_OLD_VIRTUAL_PYTHONHOME}";
  unset _OLD_VIRTUAL_PYTHONHOME;
 fi;
 if [ -n "\${_OLD_VIRTUAL_PS1:-}" ]; then
  export PS1="\${_OLD_VIRTUAL_PS1}";
  unset _OLD_VIRTUAL_PS1;
 fi;
 if declare -f deactivate 1>/dev/null 2>&1; then
-  unset -f deactivate;
+  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_VIRTUALENV_INIT=1
-  export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
+  export PYENV_ACTIVATE="${PYENV_ROOT}/versions/venv"
  export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
  export PYENV_ACTIVATE_SHELL=
  PYENV_SHELL="fish" run pyenv-sh-deactivate
  assert_success
  assert_output <<EOS
 set -e PYENV_VIRTUAL_ENV;
 set -e VIRTUAL_ENV;
 if [ -n "\$_OLD_VIRTUAL_PATH" ];
  set -gx PATH "\$_OLD_VIRTUAL_PATH";
  set -e _OLD_VIRTUAL_PATH;
 end;
 if [ -n "\$_OLD_VIRTUAL_PYTHONHOME" ];
  set -gx PYTHONHOME "\$_OLD_VIRTUAL_PYTHONHOME";
  set -e _OLD_VIRTUAL_PYTHONHOME;
 end;
 # check if old prompt function exists
 if functions -q _pyenv_old_prompt
  # remove old prompt function if exists.
  functions -e fish_prompt
  functions -c _pyenv_old_prompt fish_prompt
  functions -e _pyenv_old_prompt
 end
 if functions -q deactivate;
-  functions -e 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) (quiet)" {
+@test "deactivate virtualenv (fish) (no-error)" {
  export PYENV_VIRTUALENV_INIT=1
-  export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
+  export PYENV_ACTIVATE="${PYENV_ROOT}/versions/venv"
  export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
  export PYENV_ACTIVATE_SHELL=
-  PYENV_SHELL="fish" run pyenv-sh-deactivate --quiet
+  PYENV_SHELL="fish" run pyenv-sh-deactivate --no-error
  assert_success
  assert_output <<EOS
 set -e PYENV_VIRTUAL_ENV;
 set -e VIRTUAL_ENV;
 if [ -n "\$_OLD_VIRTUAL_PATH" ];
  set -gx PATH "\$_OLD_VIRTUAL_PATH";
  set -e _OLD_VIRTUAL_PATH;
 end;
 if [ -n "\$_OLD_VIRTUAL_PYTHONHOME" ];
  set -gx PYTHONHOME "\$_OLD_VIRTUAL_PYTHONHOME";
  set -e _OLD_VIRTUAL_PYTHONHOME;
 end;
 # check if old prompt function exists
 if functions -q _pyenv_old_prompt
  # remove old prompt function if exists.
  functions -e fish_prompt
  functions -c _pyenv_old_prompt fish_prompt
  functions -e _pyenv_old_prompt
 end
 if functions -q deactivate;
-  functions -e deactivate;
+  setenv PYENV_DEACTIVATE "$PYENV_ACTIVATE";
  set -e PYENV_ACTIVATE;
  deactivate;
 else;
  false;
 end;
 EOS
 }
-@test "deactivate virtualenv (fish) (with shell activation)" {
+@test "deactivate virtualenv (fish) (without pyenv-virtualenv-init)" {
-  export PYENV_VIRTUALENV_INIT=1
+  export PYENV_VIRTUALENV_INIT=
-  export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
+  export PYENV_ACTIVATE="${PYENV_ROOT}/versions/venv"
  export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
  export PYENV_ACTIVATE_SHELL=1
  PYENV_SHELL="fish" run pyenv-sh-deactivate
  assert_success
  assert_output <<EOS
 set -e PYENV_VERSION;
 set -e PYENV_ACTIVATE_SHELL;
 set -e PYENV_VIRTUAL_ENV;
 set -e VIRTUAL_ENV;
 if [ -n "\$_OLD_VIRTUAL_PATH" ];
  set -gx PATH "\$_OLD_VIRTUAL_PATH";
  set -e _OLD_VIRTUAL_PATH;
 end;
 if [ -n "\$_OLD_VIRTUAL_PYTHONHOME" ];
  set -gx PYTHONHOME "\$_OLD_VIRTUAL_PYTHONHOME";
  set -e _OLD_VIRTUAL_PYTHONHOME;
 end;
 # check if old prompt function exists
 if functions -q _pyenv_old_prompt
  # remove old prompt function if exists.
  functions -e fish_prompt
  functions -c _pyenv_old_prompt fish_prompt
  functions -e _pyenv_old_prompt
 end
 if functions -q deactivate;
-  functions -e deactivate;
+  pyenv shell --unset;
  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) (quiet)" {
+@test "deactivate virtualenv (fish) (without pyenv-virtualenv-init) (no-error)" {
-  export PYENV_VIRTUALENV_INIT=1
+  export PYENV_VIRTUALENV_INIT=
-  export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
+  export PYENV_ACTIVATE="${PYENV_ROOT}/versions/venv"
  export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
  export PYENV_ACTIVATE_SHELL=1
-  PYENV_SHELL="fish" run pyenv-sh-deactivate --quiet
+  PYENV_SHELL="fish" run pyenv-sh-deactivate --no-error
  assert_success
  assert_output <<EOS
 set -e PYENV_VERSION;
 set -e PYENV_ACTIVATE_SHELL;
 set -e PYENV_VIRTUAL_ENV;
 set -e VIRTUAL_ENV;
 if [ -n "\$_OLD_VIRTUAL_PATH" ];
  set -gx PATH "\$_OLD_VIRTUAL_PATH";
  set -e _OLD_VIRTUAL_PATH;
 end;
 if [ -n "\$_OLD_VIRTUAL_PYTHONHOME" ];
  set -gx PYTHONHOME "\$_OLD_VIRTUAL_PYTHONHOME";
  set -e _OLD_VIRTUAL_PYTHONHOME;
 end;
 # check if old prompt function exists
 if functions -q _pyenv_old_prompt
  # remove old prompt function if exists.
  functions -e fish_prompt
  functions -c _pyenv_old_prompt fish_prompt
  functions -e _pyenv_old_prompt
 end
 if functions -q deactivate;
-  functions -e deactivate;
+  pyenv shell --unset;
  setenv PYENV_DEACTIVATE "$PYENV_ACTIVATE";
  set -e PYENV_ACTIVATE;
  deactivate;
 else;
  false;
 end;
 EOS
 }
@test "deactivate virtualenv which has been activated manually (fish)" {
  export PYENV_VIRTUALENV_INIT=1
  export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
  export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
  export PYENV_ACTIVATE_SHELL=
  PYENV_SHELL="fish" run pyenv-sh-deactivate
  assert_success
  assert_output <<EOS
 set -e PYENV_VIRTUAL_ENV;
 set -e VIRTUAL_ENV;
 if [ -n "\$_OLD_VIRTUAL_PATH" ];
  set -gx PATH "\$_OLD_VIRTUAL_PATH";
  set -e _OLD_VIRTUAL_PATH;
 end;
 if [ -n "\$_OLD_VIRTUAL_PYTHONHOME" ];
  set -gx PYTHONHOME "\$_OLD_VIRTUAL_PYTHONHOME";
  set -e _OLD_VIRTUAL_PYTHONHOME;
 end;
 # check if old prompt function exists
 if functions -q _pyenv_old_prompt
  # remove old prompt function if exists.
  functions -e fish_prompt
  functions -c _pyenv_old_prompt fish_prompt
  functions -e _pyenv_old_prompt
 end
 if functions -q deactivate;
-  functions -e 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/delete.bats
+++ b/test/delete.bats
@ -1,88 +0,0 @@
 #!/usr/bin/env bats
 load test_helper
 setup() {
  export PYENV_ROOT="${TMP}/pyenv"
 }
@test "delete virtualenv" {
  mkdir -p "${PYENV_ROOT}/versions/venv27"
  stub pyenv-virtualenv-prefix "venv27 : true"
  stub pyenv-rehash "true"
  run pyenv-virtualenv-delete -f "venv27"
  assert_success
  unstub pyenv-virtualenv-prefix
  unstub pyenv-rehash
  [ ! -d "${PYENV_ROOT}/versions/venv27" ]
 }
@test "delete virtualenv by symlink" {
  mkdir -p "${PYENV_ROOT}/versions/2.7.11/envs/venv27"
  ln -fs "${PYENV_ROOT}/versions/2.7.11/envs/venv27" "${PYENV_ROOT}/versions/venv27"
  stub pyenv-rehash "true"
  run pyenv-virtualenv-delete -f "venv27"
  assert_success
  unstub pyenv-rehash
  [ ! -d "${PYENV_ROOT}/versions/2.7.11/envs/venv27" ]
  [ ! -L "${PYENV_ROOT}/versions/venv27" ]
 }
@test "delete virtualenv with symlink" {
  mkdir -p "${PYENV_ROOT}/versions/2.7.11/envs/venv27"
  ln -fs "${PYENV_ROOT}/versions/2.7.11/envs/venv27" "${PYENV_ROOT}/versions/venv27"
  stub pyenv-rehash "true"
  run pyenv-virtualenv-delete -f "2.7.11/envs/venv27"
  assert_success
  unstub pyenv-rehash
  [ ! -d "${PYENV_ROOT}/versions/2.7.11/envs/venv27" ]
  [ ! -L "${PYENV_ROOT}/versions/venv27" ]
 }
@test "not delete virtualenv with different symlink" {
  mkdir -p "${PYENV_ROOT}/versions/2.7.8/envs/venv27"
  mkdir -p "${PYENV_ROOT}/versions/2.7.11/envs/venv27"
  ln -fs "${PYENV_ROOT}/versions/2.7.8/envs/venv27" "${PYENV_ROOT}/versions/venv27"
  stub pyenv-rehash "true"
  run pyenv-virtualenv-delete -f "2.7.11/envs/venv27"
  assert_success
  unstub pyenv-rehash
  [ ! -d "${PYENV_ROOT}/versions/2.7.11/envs/venv27" ]
  [ -L "${PYENV_ROOT}/versions/venv27" ]
 }
@test "not delete virtualenv with same name" {
  mkdir -p "${PYENV_ROOT}/versions/2.7.11/envs/venv27"
  mkdir -p "${PYENV_ROOT}/versions/venv27"
  stub pyenv-rehash "true"
  run pyenv-virtualenv-delete -f "2.7.11/envs/venv27"
  assert_success
  unstub pyenv-rehash
  [ ! -d "${PYENV_ROOT}/versions/2.7.11/envs/venv27" ]
  [ -d "${PYENV_ROOT}/versions/venv27" ]
 }
--- a/test/envs.bats
+++ b/test/envs.bats
@ -1,47 +0,0 @@
 #!/usr/bin/env bats
 load test_helper
 setup() {
  export PYENV_ROOT="${TMP}/envs/pyenv"
 }
 stub_pyenv() {
  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
  stub pyenv-hooks "virtualenv : echo"
  stub pyenv-rehash " : echo rehashed"
 }
 unstub_pyenv() {
  unstub pyenv-prefix
  unstub pyenv-hooks
  unstub pyenv-rehash
 }
@test "path should be handled properly even if there is 'envs' in PYENV_ROOT" {
  export PYENV_VERSION="3.5.1"
  setup_m_venv "3.5.1"
  stub_pyenv "${PYENV_VERSION}"
  stub pyenv-version-name "echo '${PYENV_VERSION}'"
  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
  stub pyenv-virtualenv-prefix " : false"
  stub pyenv-exec "python -m venv --help : true"
  stub pyenv-exec "python -m venv * : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\";mkdir -p \${PYENV_ROOT}/versions/3.5.1/envs/venv/bin"
  stub pyenv-exec "python -s -m ensurepip : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\";touch \${PYENV_ROOT}/versions/3.5.1/envs/venv/bin/pip"
  run pyenv-virtualenv venv
  assert_success
  assert_output <<OUT
 PYENV_VERSION=3.5.1 python -m venv ${PYENV_ROOT}/versions/3.5.1/envs/venv
 PYENV_VERSION=3.5.1/envs/venv python -s -m ensurepip
 rehashed
 OUT
  assert [ -e "${PYENV_ROOT}/versions/3.5.1/envs/venv/bin/pip" ]
  unstub_pyenv
  unstub pyenv-version-name
  unstub pyenv-virtualenv-prefix
  unstub pyenv-exec
  teardown_m_venv "3.5.1"
 }
--- a/test/hooks.bats
+++ b/test/hooks.bats
@ -6,7 +6,6 @@ setup() {
  export PYENV_ROOT="${TMP}/pyenv"
  export HOOK_PATH="${TMP}/i has hooks"
  mkdir -p "$HOOK_PATH"
  unset PYENV_VIRTUALENV_PROMPT
 }
@test "pyenv-virtualenv hooks" {
@ -14,101 +13,23 @@ setup() {
 before_virtualenv 'echo before: \$VIRTUALENV_PATH'
 after_virtualenv 'echo after: \$STATUS'
 OUT
-  setup_version "3.5.1"
+  stub pyenv-prefix "echo '${PYENV_ROOT}/versions/3.2.1'"
-  create_executable "3.5.1" "virtualenv"
+  stub pyenv-prefix "echo '${PYENV_ROOT}/versions/3.2.1'"
-  stub pyenv-prefix "echo '${PYENV_ROOT}/versions/3.5.1'"
+  stub pyenv-prefix "echo '${PYENV_ROOT}/versions/3.2.1'"
  stub pyenv-prefix "echo '${PYENV_ROOT}/versions/3.5.1'"
  stub pyenv-exec "python -m venv --help : true"
  stub pyenv-hooks "virtualenv : echo '$HOOK_PATH'/virtualenv.bash"
-  stub pyenv-exec "echo PYENV_VERSION=3.5.1 \"\$@\""
+  stub pyenv-exec "echo PYENV_VERSION=3.2.1 \"\$@\""
  stub pyenv-exec "echo PYENV_VERSION=3.5.1 \"\$@\""
  stub pyenv-rehash "echo rehashed"
-  run pyenv-virtualenv "3.5.1" venv
+  create_executable "3.2.1" "virtualenv"
  remove_executable "3.2.1" "pyvenv"
  run pyenv-virtualenv "3.2.1" venv
  assert_success
  assert_output <<-OUT
-before: ${PYENV_ROOT}/versions/3.5.1/envs/venv
+before: ${PYENV_ROOT}/versions/venv
-PYENV_VERSION=3.5.1 virtualenv ${PYENV_ROOT}/versions/3.5.1/envs/venv
+PYENV_VERSION=3.2.1 virtualenv ${PYENV_ROOT}/versions/venv
 PYENV_VERSION=3.5.1 python -s -m ensurepip
 after: 0
 rehashed
 OUT
  unstub pyenv-prefix
  unstub pyenv-hooks
  unstub pyenv-exec
  unstub pyenv-rehash
  teardown_version "3.5.1"
 }
@test "pyenv-sh-activate hooks" {
  cat > "${HOOK_PATH}/activate.bash" <<OUT
 before_activate 'echo "before"'
 after_activate 'echo "after"'
 OUT
  export PYENV_VIRTUALENV_INIT=1
  stub pyenv-version-name "echo venv"
  stub pyenv-virtualenv-prefix ""
  stub pyenv-prefix "venv : echo \"${PYENV_ROOT}/versions/venv\""
  stub pyenv-hooks "activate : echo '$HOOK_PATH'/activate.bash"
  stub pyenv-sh-deactivate ""
  PYENV_SHELL="bash" PYENV_VERSION="venv" run pyenv-sh-activate
  assert_success
  assert_output <<EOS
 before
 export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv";
 export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv";
 export _OLD_VIRTUAL_PS1="\${PS1:-}";
 export PS1="(venv) \${PS1:-}";
 after
 EOS
  unstub pyenv-version-name
  unstub pyenv-virtualenv-prefix
  unstub pyenv-prefix
  unstub pyenv-hooks
  unstub pyenv-sh-deactivate
 }
@test "deactivate virtualenv" {
  cat > "${HOOK_PATH}/deactivate.bash" <<OUT
 before_deactivate 'echo "before"'
 after_deactivate 'echo "after"'
 OUT
  export PYENV_VIRTUALENV_INIT=1
  export PYENV_VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
  export VIRTUAL_ENV="${PYENV_ROOT}/versions/venv"
  export PYENV_ACTIVATE_SHELL=
  stub pyenv-hooks "deactivate : echo '$HOOK_PATH'/deactivate.bash"
  PYENV_SHELL="bash" run pyenv-sh-deactivate
  assert_success
  assert_output <<EOS
 before
 unset PYENV_VIRTUAL_ENV;
 unset VIRTUAL_ENV;
 if [ -n "\${_OLD_VIRTUAL_PATH:-}" ]; then
  export PATH="\${_OLD_VIRTUAL_PATH}";
  unset _OLD_VIRTUAL_PATH;
 fi;
 if [ -n "\${_OLD_VIRTUAL_PYTHONHOME:-}" ]; then
  export PYTHONHOME="\${_OLD_VIRTUAL_PYTHONHOME}";
  unset _OLD_VIRTUAL_PYTHONHOME;
 fi;
 if [ -n "\${_OLD_VIRTUAL_PS1:-}" ]; then
  export PS1="\${_OLD_VIRTUAL_PS1}";
  unset _OLD_VIRTUAL_PS1;
 fi;
 if declare -f deactivate 1>/dev/null 2>&1; then
  unset -f deactivate;
 fi;
 after
 EOS
  unstub pyenv-hooks
 }
--- a/test/init.bats
+++ b/test/init.bats
@ -3,216 +3,118 @@
 load test_helper
@test "detect parent shell" {
-  unset PYENV_SHELL
+  root="$(cd $BATS_TEST_DIRNAME/.. && pwd)"
  SHELL=/bin/false run pyenv-virtualenv-init -
  assert_success
-  assert_output_contains '  PROMPT_COMMAND="_pyenv_virtualenv_hook;${PROMPT_COMMAND-}"'
+  assert_output_contains '  PROMPT_COMMAND="_pyenv_virtualenv_hook;$PROMPT_COMMAND";'
 }
-@test "detect parent shell from script (sh)" {
+@test "sh-compatible instructions" {
-  unset PYENV_SHELL
+  run pyenv-virtualenv-init bash
-  printf '#!/bin/sh\necho "$(pyenv-virtualenv-init -)"' > "${TMP}/script.sh"
+  assert [ "$status" -eq 1 ]
-  chmod +x ${TMP}/script.sh
+  assert_output_contains 'eval "$(pyenv virtualenv-init -)"'
  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)" {
+  run pyenv-virtualenv-init zsh
-  unset PYENV_SHELL
+  assert [ "$status" -eq 1 ]
-  printf '#!/bin/bash\necho "$(pyenv-virtualenv-init -)"' > "${TMP}/script.sh"
+  assert_output_contains 'eval "$(pyenv virtualenv-init -)"'
  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 "fish instructions" {
  run pyenv-virtualenv-init fish
  assert [ "$status" -eq 1 ]
-  assert_output_contains 'status --is-interactive; and source (pyenv virtualenv-init -|psub)'
+  assert_output_contains 'status --is-interactive; and . (pyenv virtualenv-init -|psub)'
 }
@test "other shells instructions" {
    run pyenv-virtualenv-init some_other_sh
    assert [ "$status" -eq 1 ]
    assert_output_contains 'eval "$(pyenv virtualenv-init -)"'
 }
@test "outputs bash-specific syntax" {
  export PYENV_VIRTUALENV_ROOT="${TMP}/pyenv/plugins/pyenv-virtualenv"
  run pyenv-virtualenv-init - bash
  assert_success
  assert_output <<EOS
 export PATH="${TMP}/pyenv/plugins/pyenv-virtualenv/shims:\${PATH}";
 export PYENV_VIRTUALENV_INIT=1;
 _pyenv_virtualenv_hook() {
-  local ret=\$?
+  if [ -n "\$PYENV_ACTIVATE" ]; then
-  if [ "\${PYENV_VERSION-}" = "\${_PYENV_VH_VERSION-}" ] \\
+    if [ "\$(pyenv version-name)" = "system" ]; then
-    && [ "\${VIRTUAL_ENV-}" = "\${_PYENV_VH_VENV-}" ]; then
+      pyenv deactivate --no-error --verbose
-    if [ -n "\${PYENV_VERSION-}" ]; then
+      unset PYENV_DEACTIVATE
-      return \$ret
+      return 0
    fi
-    if [ "\${PWD}" = "\${_PYENV_VH_PWD-}" ] \\
+    if [ "\$PYENV_ACTIVATE" != "\$(pyenv prefix 2>/dev/null)" ]; then
-      && [ "\$(stat ${_stat_fmt} "\${_PYENV_VH_PATHS[@]}" 2>/dev/null)" = "\${_PYENV_VH_MTIMES-}" ]; then
+      if pyenv deactivate --no-error --verbose; then
-      return \$ret
+        unset PYENV_DEACTIVATE
-    fi
+        pyenv activate --no-error --verbose || unset PYENV_DEACTIVATE
-  fi
+      else
-  if [ -n "\${VIRTUAL_ENV-}" ]; then
+        pyenv activate --no-error --verbose
    eval "\$(pyenv sh-activate --quiet || pyenv sh-deactivate --quiet || true)" || true
  else
    eval "\$(pyenv sh-activate --quiet || true)" || true
  fi
  _PYENV_VH_PWD="\${PWD}"
  _PYENV_VH_VERSION="\${PYENV_VERSION-}"
  _PYENV_VH_VENV="\${VIRTUAL_ENV-}"
  local _pvh_d="\${PWD}" _pvh_found_local=0
  _PYENV_VH_PATHS=()
  while :; do
    if [ -f "\${_pvh_d}/.python-version" ] || [ -L "\${_pvh_d}/.python-version" ]; then
      _PYENV_VH_PATHS+=("\${_pvh_d}/.python-version")
      if [ -f "\${_pvh_d}/.python-version" ]; then 
        _pvh_found_local=1
        break
      fi
    else
      _PYENV_VH_PATHS+=("\${_pvh_d}")
    fi
-    [ "\${_pvh_d}" = "/" ] && break
+  else
-    _pvh_d="\${_pvh_d%/*}"
+    if [ -z "\$VIRTUAL_ENV" ] && [ "\$PYENV_DEACTIVATE" != "\$(pyenv prefix 2>/dev/null)" ]; then
-    [ -z "\${_pvh_d}" ] && _pvh_d="/"
+      pyenv activate --no-error --verbose
-  done
+    fi
  if [ "\${_pvh_found_local}" = "0" ]; then
    _PYENV_VH_PATHS+=("\${PYENV_ROOT}/version")
  fi
  _PYENV_VH_MTIMES="\$(stat ${_stat_fmt} "\${_PYENV_VH_PATHS[@]}" 2>/dev/null)"
  return \$ret
 };
-if ! [[ "\${PROMPT_COMMAND-}" =~ _pyenv_virtualenv_hook ]]; then
+if ! [[ "\$PROMPT_COMMAND" =~ _pyenv_virtualenv_hook ]]; then
-  PROMPT_COMMAND="_pyenv_virtualenv_hook;\${PROMPT_COMMAND-}"
+  PROMPT_COMMAND="_pyenv_virtualenv_hook;\$PROMPT_COMMAND";
 fi
 EOS
 }
@test "outputs fish-specific syntax" {
  export PYENV_VIRTUALENV_ROOT="${TMP}/pyenv/plugins/pyenv-virtualenv"
  run pyenv-virtualenv-init - fish
  assert_success
  assert_output <<EOS
-while set index (contains -i -- "${TMP}/pyenv/plugins/pyenv-virtualenv/shims" \$PATH)
+setenv PYENV_VIRTUALENV_INIT 1;
 set -eg PATH[\$index]; end; set -e index
 set -gx PATH '${TMP}/pyenv/plugins/pyenv-virtualenv/shims' \$PATH;
 set -gx PYENV_VIRTUALENV_INIT 1;
 function _pyenv_virtualenv_hook --on-event fish_prompt;
-  set -l ret \$status
+  if [ -n "\$PYENV_ACTIVATE" ]
-  if test "\$PYENV_VERSION" = "\$_PYENV_VH_VERSION" \\
+    if [ (pyenv version-name) = "system" ]
-    -a "\$VIRTUAL_ENV" = "\$_PYENV_VH_VENV"
+      pyenv deactivate --no-error --verbose
-    if test -n "\$PYENV_VERSION"
+      set -e PYENV_DEACTIVATE
-      return \$ret
+      return 0
    end
-    if test "\$PWD" = "\$_PYENV_VH_PWD" \\
+    if [ "\$PYENV_ACTIVATE" != (pyenv prefix 2>/dev/null) ]
-      -a "(stat ${_stat_fmt} \$_PYENV_VH_PATHS 2>/dev/null)" = "\$_PYENV_VH_MTIMES"
+      if pyenv deactivate --no-error --verbose
-      return \$ret
+        set -e PYENV_DEACTIVATE
-    end
+        pyenv activate --no-error --verbose; or set -e PYENV_DEACTIVATE
-  end
+      else
-  if [ -n "\$VIRTUAL_ENV" ]
+        pyenv activate --no-error --verbose
    pyenv activate --quiet; or pyenv deactivate --quiet; or true
  else
    pyenv activate --quiet; or true
  end
  set -g _PYENV_VH_PWD "\$PWD"
  set -g _PYENV_VH_VERSION "\$PYENV_VERSION"
  set -g _PYENV_VH_VENV "\$VIRTUAL_ENV"
  set -l d "\$PWD"
  set -l _pvh_found_local 0
  set -g _PYENV_VH_PATHS
  while true
    if test -f "\$d/.python-version"; or test -L "\$d/.python-version"
      set -g _PYENV_VH_PATHS \$_PYENV_VH_PATHS "\$d/.python-version"
      if test -f "\$d/.python-version" 
        set _pvh_found_local 1
        break
      end
    else
      set -g _PYENV_VH_PATHS \$_PYENV_VH_PATHS "\$d"
    end
-    test "\$d" = "/"; and break
+  else
-    set d (string replace -r '/[^/]*\$' '' -- "\$d")
+    if [ -z "\$VIRTUAL_ENV" ]; and [ "\$PYENV_DEACTIVATE" != (pyenv prefix 2>/dev/null) ]
-    test -z "\$d"; and set d "/"
+      pyenv activate --no-error --verbose
    end
  end
  if test "\$_pvh_found_local" = "0"
    set -g _PYENV_VH_PATHS \$_PYENV_VH_PATHS "\$PYENV_ROOT/version"
  end
  set -g _PYENV_VH_MTIMES (stat ${_stat_fmt} \$_PYENV_VH_PATHS 2>/dev/null)
  return \$ret
 end
 EOS
 }
@test "outputs zsh-specific syntax" {
  export PYENV_VIRTUALENV_ROOT="${TMP}/pyenv/plugins/pyenv-virtualenv"
  run pyenv-virtualenv-init - zsh
  assert_success
  assert_output <<EOS
 export PATH="${TMP}/pyenv/plugins/pyenv-virtualenv/shims:\${PATH}";
 export PYENV_VIRTUALENV_INIT=1;
 _pyenv_virtualenv_hook() {
-  local ret=\$?
+  if [ -n "\$PYENV_ACTIVATE" ]; then
-  if [ "\${PYENV_VERSION-}" = "\${_PYENV_VH_VERSION-}" ] \\
+    if [ "\$(pyenv version-name)" = "system" ]; then
-    && [ "\${VIRTUAL_ENV-}" = "\${_PYENV_VH_VENV-}" ]; then
+      pyenv deactivate --no-error --verbose
-    if [ -n "\${PYENV_VERSION-}" ]; then
+      unset PYENV_DEACTIVATE
-      return \$ret
+      return 0
    fi
-    if [ "\${PWD}" = "\${_PYENV_VH_PWD-}" ] \\
+    if [ "\$PYENV_ACTIVATE" != "\$(pyenv prefix 2>/dev/null)" ]; then
-      && [ "\$(stat ${_stat_fmt} "\${_PYENV_VH_PATHS[@]}" 2>/dev/null)" = "\${_PYENV_VH_MTIMES-}" ]; then
+      if pyenv deactivate --no-error --verbose; then
-      return \$ret
+        unset PYENV_DEACTIVATE
-    fi
+        pyenv activate --no-error --verbose || unset PYENV_DEACTIVATE
-  fi
+      else
-  if [ -n "\${VIRTUAL_ENV-}" ]; then
+        pyenv activate --no-error --verbose
    eval "\$(pyenv sh-activate --quiet || pyenv sh-deactivate --quiet || true)" || true
  else
    eval "\$(pyenv sh-activate --quiet || true)" || true
  fi
  _PYENV_VH_PWD="\${PWD}"
  _PYENV_VH_VERSION="\${PYENV_VERSION-}"
  _PYENV_VH_VENV="\${VIRTUAL_ENV-}"
  local _pvh_d="\${PWD}" _pvh_found_local=0
  _PYENV_VH_PATHS=()
  while :; do
    if [ -f "\${_pvh_d}/.python-version" ] || [ -L "\${_pvh_d}/.python-version" ]; then
      _PYENV_VH_PATHS+=("\${_pvh_d}/.python-version")
      if [ -f "\${_pvh_d}/.python-version" ]; then 
        _pvh_found_local=1
        break
      fi
    else
      _PYENV_VH_PATHS+=("\${_pvh_d}")
    fi
-    [ "\${_pvh_d}" = "/" ] && break
+  else
-    _pvh_d="\${_pvh_d%/*}"
+    if [ -z "\$VIRTUAL_ENV" ] && [ "\$PYENV_DEACTIVATE" != "\$(pyenv prefix 2>/dev/null)" ]; then
-    [ -z "\${_pvh_d}" ] && _pvh_d="/"
+      pyenv activate --no-error --verbose
-  done
+    fi
  if [ "\${_pvh_found_local}" = "0" ]; then
    _PYENV_VH_PATHS+=("\${PYENV_ROOT}/version")
  fi
  _PYENV_VH_MTIMES="\$(stat ${_stat_fmt} "\${_PYENV_VH_PATHS[@]}" 2>/dev/null)"
  return \$ret
 };
-typeset -g -a precmd_functions
+typeset -a precmd_functions
 if [[ -z \$precmd_functions[(r)_pyenv_virtualenv_hook] ]]; then
-  precmd_functions=(_pyenv_virtualenv_hook \$precmd_functions);
+  precmd_functions+=_pyenv_virtualenv_hook;
 fi
 EOS
 }
@test "outputs other shells syntax" {
  export PYENV_VIRTUALENV_ROOT="${TMP}/pyenv/plugins/pyenv-virtualenv"
  run pyenv-virtualenv-init - some_other_sh
  assert_success
  assert_output <<EOS
 export PATH="${TMP}/pyenv/plugins/pyenv-virtualenv/shims:\${PATH}";
 export PYENV_VIRTUALENV_INIT=1;
 EOS
 }
--- a/test/pip.bats
+++ b/test/pip.bats
@ -21,57 +21,58 @@ unstub_pyenv() {
 }
@test "install pip with ensurepip" {
-  export PYENV_VERSION="3.5.1"
+  export PYENV_VERSION="3.4.1"
  setup_m_venv "3.5.1"
  stub_pyenv "${PYENV_VERSION}"
  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
-  stub pyenv-virtualenv-prefix " : false"
+  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
-  stub pyenv-exec "python -m venv --help : true"
+  stub pyenv-exec "pyvenv ${PYENV_ROOT}/versions/venv : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\";mkdir -p \${PYENV_ROOT}/versions/venv/bin"
-  stub pyenv-exec "python -m venv * : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\";mkdir -p \${PYENV_ROOT}/versions/3.5.1/envs/venv/bin"
+  stub pyenv-exec "python -m ensurepip : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\";touch \${PYENV_ROOT}/versions/venv/bin/pip"
-  stub pyenv-exec "python -s -m ensurepip : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\";touch \${PYENV_ROOT}/versions/3.5.1/envs/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.5.1 python -m venv ${TMP}/pyenv/versions/3.5.1/envs/venv
+PYENV_VERSION=3.4.1 pyvenv ${PYENV_ROOT}/versions/venv
-PYENV_VERSION=3.5.1/envs/venv python -s -m ensurepip
+PYENV_VERSION=venv python -m ensurepip
 rehashed
 OUT
-  assert [ -e "${PYENV_ROOT}/versions/3.5.1/envs/venv/bin/pip" ]
+  assert [ -e "${PYENV_ROOT}/versions/venv/bin/pip" ]
  unstub_pyenv
  unstub pyenv-virtualenv-prefix
  unstub pyenv-exec
  teardown_m_venv "3.5.1"
 }
@test "install pip without using ensurepip" {
-  export PYENV_VERSION="3.3.6"
+  export PYENV_VERSION="3.3.5"
  setup_m_venv "3.3.6"
  stub_pyenv "${PYENV_VERSION}"
  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
-  stub pyenv-virtualenv-prefix " : false"
+  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
-  stub pyenv-exec "python -m venv --help : true"
+  stub pyenv-exec "pyvenv ${PYENV_ROOT}/versions/venv : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\";mkdir -p \${PYENV_ROOT}/versions/venv/bin"
-  stub pyenv-exec "python -m venv * : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\";mkdir -p \${PYENV_ROOT}/versions/3.3.6/envs/venv/bin"
+  stub pyenv-exec "python -m ensurepip : false"
-  stub pyenv-exec "python -s -m ensurepip : false"
+  stub pyenv-exec "python */ez_setup.py : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\";touch \${PYENV_ROOT}/versions/venv/bin/easy_install"
-  stub pyenv-exec "python -s */get-pip.py : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\";touch \${PYENV_ROOT}/versions/3.3.6/envs/venv/bin/pip"
+  stub pyenv-exec "python */get-pip.py : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\";touch \${PYENV_ROOT}/versions/venv/bin/pip"
  stub curl true
  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.6 python -m venv ${PYENV_ROOT}/versions/3.3.6/envs/venv
+PYENV_VERSION=3.3.5 pyvenv ${PYENV_ROOT}/versions/venv
-Installing pip from https://bootstrap.pypa.io/pip/3.3/get-pip.py...
+Installing setuptools from https://bootstrap.pypa.io/ez_setup.py...
-PYENV_VERSION=3.3.6/envs/venv python -s ${TMP}/pyenv/cache/get-pip.py
+PYENV_VERSION=venv python ${TMP}/pyenv/cache/ez_setup.py
 Installing pip from https://bootstrap.pypa.io/get-pip.py...
 PYENV_VERSION=venv python ${TMP}/pyenv/cache/get-pip.py
 rehashed
 OUT
-  assert [ -e "${PYENV_ROOT}/versions/3.3.6/envs/venv/bin/pip" ]
+  assert [ -e "${PYENV_ROOT}/versions/venv/bin/pip" ]
  unstub_pyenv
  unstub pyenv-virtualenv-prefix
  unstub pyenv-exec
  teardown_m_venv "3.3.6"
 }
--- a/test/prefix.bats
+++ b/test/prefix.bats
@ -1,214 +0,0 @@
 #!/usr/bin/env bats
 load test_helper
 setup() {
  export PYENV_ROOT="${TMP}/pyenv"
 }
 create_version() {
  mkdir -p "${PYENV_ROOT}/versions/$1/bin"
  touch "${PYENV_ROOT}/versions/$1/bin/python"
  chmod +x "${PYENV_ROOT}/versions/$1/bin/python"
 }
 create_virtualenv() {
  create_version "$1"
  create_version "${2:-$1}"
  mkdir -p "${PYENV_ROOT}/versions/$1/lib/python${2:-$1}"
  echo "${PYENV_ROOT}/versions/${2:-$1}" > "${PYENV_ROOT}/versions/$1/lib/python${2:-$1}/orig-prefix.txt"
  touch "${PYENV_ROOT}/versions/$1/bin/activate"
 }
 create_virtualenv_jython() {
  create_version "$1"
  create_version "${2:-$1}"
  mkdir -p "${PYENV_ROOT}/versions/$1/Lib/"
  echo "${PYENV_ROOT}/versions/${2:-$1}" > "${PYENV_ROOT}/versions/$1/Lib/orig-prefix.txt"
  touch "${PYENV_ROOT}/versions/$1/bin/activate"
 }
 create_virtualenv_pypy() {
  create_version "$1"
  create_version "${2:-$1}"
  mkdir -p "${PYENV_ROOT}/versions/$1/lib-python/${2:-$1}"
  echo "${PYENV_ROOT}/versions/${2:-$1}" > "${PYENV_ROOT}/versions/$1/lib-python/${2:-$1}/orig-prefix.txt"
  touch "${PYENV_ROOT}/versions/$1/bin/activate"
 }
 create_m_venv() {
  create_version "$1"
  create_version "${2:-$1}"
  echo "home = ${PYENV_ROOT}/versions/${2:-$1}/bin" > "${PYENV_ROOT}/versions/$1/pyvenv.cfg"
  touch "${PYENV_ROOT}/versions/$1/bin/activate"
 }
 create_conda() {
  create_version "$1"
  create_version "${2:-$1}"
  touch "${PYENV_ROOT}/versions/$1/bin/conda"
  touch "${PYENV_ROOT}/versions/$1/bin/activate"
  mkdir -p "${PYENV_ROOT}/versions/${2:-$1}/bin"
  touch "${PYENV_ROOT}/versions/${2:-$1}/bin/conda"
  touch "${PYENV_ROOT}/versions/${2:-$1}/bin/activate"
 }
@test "display prefix of virtualenv created by virtualenv" {
  stub pyenv-version-name "echo foo"
  create_virtualenv "foo" "2.7.11"
  PYENV_VERSION="foo" run pyenv-virtualenv-prefix
  assert_success
  assert_output <<OUT
 ${PYENV_ROOT}/versions/2.7.11
 OUT
  unstub pyenv-version-name
 }
@test "display prefix of virtualenv created by virtualenv (pypy)" {
  stub pyenv-version-name "echo foo"
  create_virtualenv_pypy "foo" "pypy-4.0.1"
  PYENV_VERSION="foo" run pyenv-virtualenv-prefix
  assert_success
  assert_output <<OUT
 ${PYENV_ROOT}/versions/pypy-4.0.1
 OUT
  unstub pyenv-version-name
 }
@test "display prefix of virtualenv created by virtualenv (jython)" {
  stub pyenv-version-name "echo foo"
  create_virtualenv_jython "foo" "jython-2.7.0"
  PYENV_VERSION="foo" run pyenv-virtualenv-prefix
  assert_success
  assert_output <<OUT
 ${PYENV_ROOT}/versions/jython-2.7.0
 OUT
  unstub pyenv-version-name
 }
@test "display prefixes of virtualenv created by virtualenv" {
  stub pyenv-version-name "echo foo:bar"
  create_virtualenv "foo" "2.7.11"
  create_virtualenv "bar" "3.5.1"
  PYENV_VERSION="foo:bar" run pyenv-virtualenv-prefix
  assert_success
  assert_output <<OUT
 ${PYENV_ROOT}/versions/2.7.11:${PYENV_ROOT}/versions/3.5.1
 OUT
  unstub pyenv-version-name
 }
@test "display prefix of virtualenv created by venv" {
  stub pyenv-version-name "echo foo"
  create_m_venv "foo" "3.3.6"
  PYENV_VERSION="foo" run pyenv-virtualenv-prefix
  assert_success
  assert_output <<OUT
 ${PYENV_ROOT}/versions/3.3.6
 OUT
  unstub pyenv-version-name
 }
@test "display prefixes of virtualenv created by venv" {
  stub pyenv-version-name "echo foo:bar"
  create_m_venv "foo" "3.3.6"
  create_m_venv "bar" "3.4.4"
  PYENV_VERSION="foo:bar" run pyenv-virtualenv-prefix
  assert_success
  assert_output <<OUT
 ${PYENV_ROOT}/versions/3.3.6:${PYENV_ROOT}/versions/3.4.4
 OUT
  unstub pyenv-version-name
 }
@test "display prefix of virtualenv created by conda" {
  stub pyenv-version-name "echo miniconda3-3.16.0/envs/foo"
  create_conda "miniconda3-3.16.0/envs/foo" "miniconda3-3.16.0"
  PYENV_VERSION="miniconda3-3.16.0/envs/foo" run pyenv-virtualenv-prefix
  assert_success
  assert_output <<OUT
 ${PYENV_ROOT}/versions/miniconda3-3.16.0/envs/foo
 OUT
  unstub pyenv-version-name
 }
@test "should fail if the version is the system" {
  stub pyenv-version-name "echo system"
  PYENV_VERSION="system" run pyenv-virtualenv-prefix
  assert_failure
  assert_output <<OUT
 pyenv-virtualenv: version \`system' is not a virtualenv
 OUT
  unstub pyenv-version-name
 }
@test "should fail if the version is not a virtualenv" {
  stub pyenv-version-name "echo 3.4.4"
  create_version "3.4.4"
  PYENV_VERSION="3.4.4" run pyenv-virtualenv-prefix
  assert_failure
  assert_output <<OUT
 pyenv-virtualenv: version \`3.4.4' is not a virtualenv
 OUT
  unstub pyenv-version-name
 }
@test "should fail if one of the versions is not a virtualenv" {
  stub pyenv-version-name "echo venv33:3.4.4"
  create_virtualenv "venv33" "3.3.6"
  create_version "3.4.4"
  PYENV_VERSION="venv33:3.4.4" run pyenv-virtualenv-prefix
  assert_failure
  assert_output <<OUT
 pyenv-virtualenv: version \`3.4.4' is not a virtualenv
 OUT
  unstub pyenv-version-name
 }
@test "resolves a version that is not an exact match" {
  stub pyenv-version-name "echo 3"
  create_version "3.4.4"
  stub pyenv-prefix "3 : echo \"$PYENV_ROOT/versions/3.4.4\""
  run pyenv-virtualenv-prefix
  assert_failure
  assert_output <<OUT
 pyenv-virtualenv: version \`3' is not a virtualenv
 OUT
  unstub pyenv-version-name
  unstub pyenv-prefix
 }
--- a/test/python.bats
+++ b/test/python.bats
@ -1,117 +0,0 @@
 #!/usr/bin/env bats
 load test_helper
 setup() {
  export PYENV_ROOT="${TMP}/pyenv"
  export PYENV_VERSION="2.7.8"
  setup_version "2.7.8"
  create_executable "2.7.8" "virtualenv"
  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
  stub python-build "echo python2.7"
 }
 teardown() {
  unstub curl
  unstub pyenv-version-name
  unstub pyenv-prefix
  unstub pyenv-hooks
  unstub pyenv-rehash
  unstub python-build
  teardown_version "2.7.8"
  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 "python -m venv --help : false"
  stub pyenv-exec "virtualenv --verbose * : 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
  unstub pyenv-exec
  assert_output <<OUT
 PYENV_VERSION=2.7.8 virtualenv --verbose --python=${PYENV_ROOT}/versions/2.7.8/bin/python2.7 ${PYENV_ROOT}/versions/2.7.8/envs/venv
 OUT
  assert_success
  unstub pyenv-which
  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 "python -m venv --help : false"
  stub pyenv-exec "virtualenv --verbose * : 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/2.7.8/envs/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.
 Run \`pyenv install python2.7' to install it.
 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"
 }
@test "invalid python name" {
  run pyenv-virtualenv --verbose --python=99.99.99 venv
  assert_output <<OUT
 pyenv-virtualenv: \`99.99.99' is not installed in pyenv.
 It does not look like a valid Python version. See \`pyenv install --list' for available versions.
 OUT
  assert_failure
 }
--- a/test/pyvenv.bats
+++ b/test/pyvenv.bats
@ -20,159 +20,162 @@ unstub_pyenv() {
  unstub pyenv-rehash
 }
-@test "use venv if virtualenv is not available" {
+@test "use pyvenv if virtualenv is not available" {
-  export PYENV_VERSION="3.5.1"
+  export PYENV_VERSION="3.4.1"
  setup_m_venv "3.5.1"
  stub_pyenv "${PYENV_VERSION}"
  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
-  stub pyenv-virtualenv-prefix " : false"
+  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
-  stub pyenv-exec "python -m venv --help : true"
+  stub pyenv-exec "pyvenv ${PYENV_ROOT}/versions/venv : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
-  stub pyenv-exec "python -m venv * : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
+  stub pyenv-exec "python -m ensurepip : true"
-  stub pyenv-exec "python -s -m ensurepip : true"
+
  remove_executable "3.4.1" "virtualenv"
  create_executable "3.4.1" "pyvenv"
  run pyenv-virtualenv venv
  assert_success
  assert_output <<OUT
-PYENV_VERSION=3.5.1 python -m venv ${PYENV_ROOT}/versions/3.5.1/envs/venv
+PYENV_VERSION=3.4.1 pyvenv ${PYENV_ROOT}/versions/venv
 rehashed
 OUT
  assert [ -x "${PYENV_ROOT}/versions/3.5.1/envs/venv/bin/pydoc" ]
  assert_success
  unstub_pyenv
  unstub pyenv-virtualenv-prefix
  unstub pyenv-exec
  teardown_m_venv "3.5.1"
 }
-@test "not use venv if virtualenv is available" {
+@test "not use pyvenv if virtualenv is available" {
-  export PYENV_VERSION="3.5.1"
+  export PYENV_VERSION="3.4.1"
  setup_m_venv "3.5.1"
  create_executable "3.5.1" "virtualenv"
  stub_pyenv "${PYENV_VERSION}"
  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
-  stub pyenv-virtualenv-prefix " : false"
+  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
-  stub pyenv-exec "python -m venv --help : true"
+  stub pyenv-exec "virtualenv ${PYENV_ROOT}/versions/venv : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
-  stub pyenv-exec "virtualenv * : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
+  stub pyenv-exec "python -m ensurepip : true"
-  stub pyenv-exec "python -s -m ensurepip : true"
+
  create_executable "3.4.1" "virtualenv"
  create_executable "3.4.1" "pyvenv"
  run pyenv-virtualenv venv
  assert_success
  assert_output <<OUT
-PYENV_VERSION=3.5.1 virtualenv ${PYENV_ROOT}/versions/3.5.1/envs/venv
+PYENV_VERSION=3.4.1 virtualenv ${PYENV_ROOT}/versions/venv
 rehashed
 OUT
  assert [ -x "${PYENV_ROOT}/versions/3.5.1/envs/venv/bin/pydoc" ]
  assert_success
  unstub_pyenv
  unstub pyenv-virtualenv-prefix
  unstub pyenv-exec
  teardown_m_venv "3.5.1"
 }
-@test "install virtualenv if venv is not available" {
+@test "install virtualenv if pyvenv is not avaialble" {
  export PYENV_VERSION="3.2.1"
  setup_version "3.2.1"
  stub_pyenv "${PYENV_VERSION}"
  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
-  stub pyenv-virtualenv-prefix " : false"
+  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
-  stub pyenv-exec "python -m venv --help : false"
+  stub pyenv-exec "pip install virtualenv : echo PYENV_VERSION=\${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 "virtualenv * : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
+  stub pyenv-exec "python -m ensurepip : false"
  stub pyenv-exec "python */ez_setup.py : true"
  stub pyenv-exec "python */get-pip.py : true"
  stub curl true
  stub curl true
  remove_executable "3.2.1" "virtualenv"
  remove_executable "3.2.1" "pyvenv"
  run pyenv-virtualenv venv
  assert_success
  assert_output <<OUT
-PYENV_VERSION=3.2.1 pip install virtualenv==13.1.2
+PYENV_VERSION=3.2.1 pip install virtualenv
-PYENV_VERSION=3.2.1 virtualenv ${PYENV_ROOT}/versions/3.2.1/envs/venv
+PYENV_VERSION=3.2.1 virtualenv ${PYENV_ROOT}/versions/venv
 Installing setuptools from https://bootstrap.pypa.io/ez_setup.py...
 Installing pip from https://bootstrap.pypa.io/get-pip.py...
 rehashed
 OUT
  assert [ -x "${PYENV_ROOT}/versions/3.2.1/envs/venv/bin/pydoc" ]
  assert_success
  unstub_pyenv
  unstub pyenv-virtualenv-prefix
  unstub pyenv-exec
-  teardown_version "3.2.1"
+  unstub curl
 }
@test "install virtualenv if -p has given" {
-  export PYENV_VERSION="3.5.1"
+  export PYENV_VERSION="3.4.1"
  setup_m_venv "3.5.1"
  stub_pyenv "${PYENV_VERSION}"
  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
-  stub pyenv-virtualenv-prefix " : false"
+  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
  stub pyenv-exec "python -m venv --help : true"
  stub pyenv-exec "pip install virtualenv : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
-  stub pyenv-exec "virtualenv * : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
+  stub pyenv-exec "virtualenv --python=python3 ${PYENV_ROOT}/versions/venv : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
-  stub pyenv-exec "python -s -m ensurepip : true"
+  stub pyenv-exec "python -m ensurepip : true"
-  run pyenv-virtualenv -p ${TMP}/python3 venv
+  remove_executable "3.4.1" "virtualenv"
  create_executable "3.4.1" "pyvenv"
  run pyenv-virtualenv -p python3 venv
  assert_success
  assert_output <<OUT
-PYENV_VERSION=3.5.1 pip install virtualenv
+PYENV_VERSION=3.4.1 pip install virtualenv
-PYENV_VERSION=3.5.1 virtualenv --python=${TMP}/python3 ${PYENV_ROOT}/versions/3.5.1/envs/venv
+PYENV_VERSION=3.4.1 virtualenv --python=python3 ${PYENV_ROOT}/versions/venv
 rehashed
 OUT
  assert [ -x "${PYENV_ROOT}/versions/3.5.1/envs/venv/bin/pydoc" ]
  assert_success
  unstub_pyenv
  unstub pyenv-virtualenv-prefix
  unstub pyenv-exec
  teardown_m_venv "3.5.1"
 }
@test "install virtualenv if --python has given" {
-  export PYENV_VERSION="3.5.1"
+  export PYENV_VERSION="3.4.1"
  setup_m_venv "3.5.1"
  stub_pyenv "${PYENV_VERSION}"
  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
-  stub pyenv-virtualenv-prefix " : false"
+  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
  stub pyenv-exec "python -m venv --help : true"
  stub pyenv-exec "pip install virtualenv : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
-  stub pyenv-exec "virtualenv * : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
+  stub pyenv-exec "virtualenv --python=python3 ${PYENV_ROOT}/versions/venv : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
-  stub pyenv-exec "python -s -m ensurepip : true"
+  stub pyenv-exec "python -m ensurepip : true"
-  run pyenv-virtualenv --python=${TMP}/python3 venv
+  remove_executable "3.4.1" "virtualenv"
  create_executable "3.4.1" "pyvenv"
  run pyenv-virtualenv --python=python3 venv
  assert_success
  assert_output <<OUT
-PYENV_VERSION=3.5.1 pip install virtualenv
+PYENV_VERSION=3.4.1 pip install virtualenv
-PYENV_VERSION=3.5.1 virtualenv --python=${TMP}/python3 ${PYENV_ROOT}/versions/3.5.1/envs/venv
+PYENV_VERSION=3.4.1 virtualenv --python=python3 ${PYENV_ROOT}/versions/venv
 rehashed
 OUT
  assert [ -x "${PYENV_ROOT}/versions/3.5.1/envs/venv/bin/pydoc" ]
  assert_success
  unstub_pyenv
  unstub pyenv-virtualenv-prefix
  unstub pyenv-exec
  teardown_m_venv "3.5.1"
 }
@test "install virtualenv with unsetting troublesome pip options" {
  export PYENV_VERSION="3.2.1"
  setup_version "3.2.1"
  stub_pyenv "${PYENV_VERSION}"
  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
-  stub pyenv-virtualenv-prefix " : false"
+  stub pyenv-prefix " : echo '${PYENV_ROOT}/versions/${PYENV_VERSION}'"
-  stub pyenv-exec "python -m venv --help : false"
+  stub pyenv-exec "pip install virtualenv : echo PIP_REQUIRE_VENV=\${PIP_REQUIRE_VENV} PYENV_VERSION=\${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 "virtualenv * : echo PIP_REQUIRE_VENV=\${PIP_REQUIRE_VENV} PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
+  stub pyenv-exec "python -m ensurepip : false"
  stub pyenv-exec "python */ez_setup.py : true"
  stub pyenv-exec "python */get-pip.py : true"
  stub curl true
  stub curl true
  remove_executable "3.2.1" "virtualenv"
  remove_executable "3.2.1" "pyvenv"
  PIP_REQUIRE_VENV="true" run pyenv-virtualenv venv
  assert_success
  assert_output <<OUT
-PIP_REQUIRE_VENV= PYENV_VERSION=3.2.1 pip install virtualenv==13.1.2
+PIP_REQUIRE_VENV= PYENV_VERSION=3.2.1 pip install virtualenv
-PIP_REQUIRE_VENV= PYENV_VERSION=3.2.1 virtualenv ${PYENV_ROOT}/versions/3.2.1/envs/venv
+PIP_REQUIRE_VENV= PYENV_VERSION=3.2.1 virtualenv ${PYENV_ROOT}/versions/venv
 Installing setuptools from https://bootstrap.pypa.io/ez_setup.py...
 Installing pip from https://bootstrap.pypa.io/get-pip.py...
 rehashed
 OUT
  assert [ -x "${PYENV_ROOT}/versions/3.2.1/envs/venv/bin/pydoc" ]
  assert_success
  unstub_pyenv
  unstub pyenv-virtualenv-prefix
  unstub pyenv-exec
-  teardown_version "3.2.1"
+  unstub curl
 }
--- a/test/stubs/stub
+++ b/test/stubs/stub
@ -1,5 +1,4 @@
 #!/usr/bin/env bash
 export PS4='+($$:${BASH_SOURCE}:${LINENO}): ${FUNCNAME[0]:+${FUNCNAME[0]}(): }'
 set -e
 status=0
@ -7,158 +6,41 @@ program="${0##*/}"
 PROGRAM="$(echo "$program" | tr a-z- A-Z_)"
 [ -n "$TMPDIR" ] || TMPDIR="/tmp"
-STUB_PLAN="${PROGRAM}_STUB_PLAN"
+_STUB_PLAN="${PROGRAM}_STUB_PLAN"
-STUB_PLAN="${!STUB_PLAN}"
+_STUB_RUN="${PROGRAM}_STUB_RUN"
 _STUB_INDEX="${PROGRAM}_STUB_INDEX"
 _STUB_RESULT="${PROGRAM}_STUB_RESULT"
 _STUB_END="${PROGRAM}_STUB_END"
 _STUB_DEBUG="${PROGRAM}_STUB_DEBUG"
-STUB_RUN="${PROGRAM}_STUB_RUN"
+if [ -n "${!_STUB_DEBUG}" ]; then
-STUB_RUN="${!STUB_RUN:-${TMPDIR}/${program}-stub-run}"
+  echo "$program" "$@" >&${!_STUB_DEBUG}
-STUB_INDEX=
+fi
 STUB_RESULT=
-STUB_END="${PROGRAM}_STUB_END"
+[ -e "${!_STUB_PLAN}" ] || exit 1
-STUB_END="${!STUB_END}"
+[ -n "${!_STUB_RUN}" ] || eval "${_STUB_RUN}"="${TMPDIR}/${program}-stub-run"
 STUB_LOG="${PROGRAM}_STUB_LOG"
 STUB_LOG="${!STUB_LOG:-${TMPDIR}/${program}-stub-log}"
 STUB_LOCKFILE="${TMPDIR}/${program}-stub.lock"
 release_lock() {
  rm -f "$STUB_LOCKFILE"
  trap - EXIT
 }
 acquire_lock() {
  local start=$SECONDS
  local acquire_timeout=10
  local acquired=
  while (( SECONDS <= start + $acquire_timeout )); do
    ( set -o noclobber; echo -n >"$STUB_LOCKFILE" ) 2>/dev/null && acquired=1
    if [[ -n $acquired ]]; then
      trap release_lock EXIT
      break
    else
      # POSIX sleep(1) doesn't provide subsecond precision, but many others do
      sleep 0.1 2>/dev/null || sleep 1
    fi
  done
  if [[ -z $acquired ]]; then
    echo "$0: error: could not acquire stub lock \`$STUB_LOCKFILE' in ${acquire_timeout} seconds" >&2
    exit 2
  fi
 }
 acquire_lock
 if [[ -z $STUB_END ]]; then echo "$program" "$@" >>"$STUB_LOG"; fi
 [[ -e $STUB_PLAN ]] || exit 1
 # Initialize or load the stub run information.
-read_runfile() {
+eval "${_STUB_INDEX}"=1
-  if [[ -e $STUB_RUN ]]; then source "$STUB_RUN"; fi
+eval "${_STUB_RESULT}"=0
-}
+[ ! -e "${!_STUB_RUN}" ] || source "${!_STUB_RUN}"
 write_runfile() {
  {
    local i
    echo "STUB_INDEX=$STUB_INDEX"
    echo "STUB_RESULT=$STUB_RESULT"
    echo "STUB_RUNCOUNTS=()"
    for i in ${!STUB_RUNCOUNTS[@]}; do
      echo "STUB_RUNCOUNTS[$i]=${STUB_RUNCOUNTS[$i]}"
    done
  } > "$STUB_RUN"
 }
 update_runfile_index() {
  ( STUB_INDEX=$((STUB_INDEX + 1))
    write_runfile
  )
 }
 update_runfile_result() {
  (
    # Another stubs may have run while we were running payload
    # So we need to merge possible state changes
    local our_result="$STUB_RESULT"
    local -a our_runcounts
    array_copy STUB_RUNCOUNTS our_runcounts
    read_runfile
    # merge our match_result and their match_result, with failure taking precedence
    STUB_RESULT=$(( our_result | STUB_RESULT ))
    # 3-way merge STUB_RUNCOUNTS (their changes),
    # our_runcounts (our changes) and initial_runcounts (base)
    local i
    for i in $(printf '%s\n' ${!STUB_RUNCOUNTS[@]} ${!our_runcounts[@]} | sort -u); do
      STUB_RUNCOUNTS[$i]=$((STUB_RUNCOUNTS[i] + our_runcounts[i] - initial_runcounts[i]))
    done
    write_runfile
  )
 }
 array_copy() {
  #`declare -p' is supposed to produce "declare -a src=([index]="value" <etc>)"
  local data="$(declare -p ${1:?})"
  local dest="${2:?}"
  # Bash 5 dumps empty arrays as "declare -a arr"
  if [[ $data != *=* ]]; then
    data="()";
  else
    data="${data#*=}"
  fi
  # Bash 3 and MacPorts version of Bash 5 dump arrays in single quotes "declare -a arr='()'"
  #  but arr='(<value>)' createss "([0]='<value>')" rather than duplicate the array
  if [[ ${data:0:1} == "'" && ${data:${#data}-1:1} == "'" ]]; then
    data="${data:1:${#data}-2}"
  fi
  eval "$dest=$data"
 }
-STUB_INDEX=1
+# Loop over each line in the plan.
-STUB_RESULT=0
+index=0
-declare -a STUB_RUNCOUNTS
+while IFS= read -r line; do
-read_runfile
+  index=$(($index + 1))
-declare -a initial_runcounts
+
-array_copy STUB_RUNCOUNTS initial_runcounts
+  if [ -z "${!_STUB_END}" ] && [ $index -eq "${!_STUB_INDEX}" ]; then
    # We found the plan line we're interested in.
    # Start off by assuming success.
    result=0
 # ${PROGRAM}_STUB_END envvar is set externally to trigger verification mode for `unstub'
 # Execution mode
 if [[ -z $STUB_END ]]; then
  # Loop over each line in the plan.
  regular_command_index=0
  no_order_command_index=0
  match_result=1
  while IFS= read -r line; do
    line_flags="${line%% *}"
    line="${line#${line_flags} }"
    line_flag_no_order="$(if [[ $line_flags == N ]]; then echo 1; fi)"
    line_flag_multiple="$(if [[ $line_flags == M ]]; then echo 1; fi)"
    line_flag_regular="$(if [[ $line_flags == - ]]; then echo 1; fi)"
    unset line_flags
    # Go through the plan until a match is found.
    # For regular commands, only check the next command by index.
    # Also keep track of no-order commands for the purpose of run count tracking
    if [[ -n $line_flag_regular ]]; then
      regular_command_index=$(($regular_command_index + 1))
      if [[ $regular_command_index -ne $STUB_INDEX ]]; then
        continue;
      fi
    else
      no_order_command_index=$(($no_order_command_index + 1))
    fi
    # Split the line into an array of arguments to
    # match and a command to run to produce output.
    command=" $line"
-    if [[ $command == *" : "* ]]; then
+    if [ "$command" != "${command/ : }" ]; then
      patterns="${command%% : *}"
      command="${command#* : }"
    fi
@ -173,110 +55,55 @@ if [[ -z $STUB_END ]]; then
    # Match the expected argument patterns to actual
    # arguments.
    match_result=0
    for (( i=0; i<${#patterns[@]}; i++ )); do
      pattern="${patterns[$i]}"
      argument="${arguments[$i]}"
      case "$argument" in
        $pattern ) ;;
-        * ) match_result=1 ;;
+        * ) result=1 ;;
      esac
    done
    # If the arguments matched, evaluate the command
    # in a subshell. Otherwise, log the failure.
-    if [ $match_result -eq 0 ] ; then
+    if [ $result -eq 0 ] ; then
-
+      set +e
-      # If this is a regular command, push the regular command index for the next stub invocation
+      ( eval "$command" )
-      if [[ -n $line_flag_regular ]]; then
+      status="$?"
-        update_runfile_index
+      set -e
-      else
+    else
-        STUB_RUNCOUNTS[$no_order_command_index]=$((STUB_RUNCOUNTS[no_order_command_index]+1))
+      eval "${_STUB_RESULT}"=1
      fi
      # Release the lock while running the payload to allow another `stub'
      # of the same program to run concurrently (e.g. in a pipeline).
      release_lock
      ( eval "$command" ) && status="$?" || status="$?"
      break
    fi
  done < "$STUB_PLAN"
  #If we never matched anything, we failed.
  if [[ $match_result -eq 1 ]]; then
    STUB_RESULT=1
    #This also means that we never released the lock
    # before running the payload
  else 
    acquire_lock
  fi
-  # Write out the match_result information.
+done < "${!_STUB_PLAN}"
-  update_runfile_result
+
-  release_lock
+
- 
+if [ -n "${!_STUB_END}" ]; then
  # Clean up the run file.
  rm -f "${!_STUB_RUN}"
  # If the number of lines in the plan is larger than
  # the requested index, we failed.
  if [ $index -ge "${!_STUB_INDEX}" ]; then
    eval "${_STUB_RESULT}"=1
  fi
  # Return the result.
  exit "${!_STUB_RESULT}"
 else
  # If the requested index is larger than the number
  # of lines in the plan file, we failed.
  if [ "${!_STUB_INDEX}" -gt $index ]; then
    eval "${_STUB_RESULT}"=1
  fi
  # Write out the run information.
  { echo "${_STUB_INDEX}=$((${!_STUB_INDEX} + 1))"
    echo "${_STUB_RESULT}=${!_STUB_RESULT}"
  } > "${!_STUB_RUN}"
  exit "$status"
 fi
 # Verification mode (`unstub')
 if [[ -n $STUB_END ]]; then
  # `unstub' is supposed to run after any stubs are finished
  release_lock
  # If the number of regular commands in the plan is larger than
  # the final regular_command_index, we failed.
  if [[ $(grep -Ee '^-' "$STUB_PLAN" | wc -l ) -ge $STUB_INDEX ]]; then
    STUB_RESULT=1
  fi
  # If no-order commands weren't executed exactly once
  # and multiple-times commands at least once, we failed.
  no_order_command_index=0
  while IFS= read -r line; do
    line_flags="${line%% *}"
    line="${line#${line_flags} }"
    line_flag_no_order="$(if [[ $line_flags == N ]]; then echo 1; fi)"
    line_flag_multiple="$(if [[ $line_flags == M ]]; then echo 1; fi)"
    line_flag_regular="$(if [[ $line_flags == - ]]; then echo 1; fi)"
    unset line_flags
    if [[ -z $line_flag_regular ]]; then
      continue
    fi
    no_order_command_index=$((no_order_command_index + 1))
    if [[ ( -n $line_flag_no_order && \
          (( STUB_RUNCOUNTS[no_order_command_index] != 1 )) ) \
        || \
        ( -n $line_flag_multiple && \
        (( STUB_RUNCOUNTS[no_order_command_index] < 1 )) ) ]]
    then
      STUB_RESULT=1
    fi
  done < "$STUB_PLAN"
  if [[ $STUB_RESULT -ne 0 ]]; then
    {
      echo "plan:"
      cat "$STUB_PLAN" || true
      echo "log:"
      cat "$STUB_LOG" || true
    } >&2
  fi
  # Clean up the run file.
  rm -f "$STUB_RUN"
  rm -f "$STUB_LOG"
  # Return the run result.
  exit "$STUB_RESULT"
 fi
--- a/test/test_helper.bash
+++ b/test/test_helper.bash
@ -1,15 +1,6 @@
 export TMP="$BATS_TEST_DIRNAME/tmp"
-# Detect stat format for mtime: GNU uses -c %Y, BSD uses -f %m
+PATH=/usr/bin:/usr/sbin:/bin/:/sbin
 # Must match the detection in bin/pyenv-virtualenv-init
 if stat -L -c %Y / >/dev/null 2>&1; then
  _stat_fmt="-L -c %Y"
 else
  _stat_fmt="-L -f %m"
 fi
 export PS4='+(${BASH_SOURCE}:${LINENO}): ${FUNCNAME[0]:+${FUNCNAME[0]}(): }'
 PATH=/usr/bin:/usr/sbin:/bin:/sbin
 PATH="$BATS_TEST_DIRNAME/../bin:$PATH"
 PATH="$TMP/bin:$PATH"
 export PATH
@ -19,51 +10,19 @@ teardown() {
 }
 stub() {
  local FLAG_NO_ORDER=
  local FLAG_MULTIPLE=
  while (($#)); do
    case "$1" in
      -N|--no-order)
        FLAG_NO_ORDER=1
        shift
        ;;
      -M|--multiple)
        FLAG_MULTIPLE=1
        shift
        ;;
      -*)
        echo "stub: unrecognized switch: $arg" >$2
        return 1
        ;;
      *)
        break
        ;;
    esac
  done
  local FLAGS=-
  if [[ -n $FLAG_MULTIPLE ]]; then
    FLAGS=M
  elif [[ -n $FLAG_NO_ORDER ]]; then
    FLAGS=N
  fi
  local program="$1"
  local prefix="$(echo "$program" | tr a-z- A-Z_)"
  shift
  export "${prefix}_STUB_PLAN"="${TMP}/${program}-stub-plan"
  export "${prefix}_STUB_RUN"="${TMP}/${program}-stub-run"
  export "${prefix}_STUB_LOG"="${TMP}/${program}-stub-log"
  export "${prefix}_STUB_END"=
  mkdir -p "${TMP}/bin"
  ln -sf "${BATS_TEST_DIRNAME}/stubs/stub" "${TMP}/bin/${program}"
  touch "${TMP}/${program}-stub-plan"
-  for arg in "$@"; do
+  for arg in "$@"; do printf "%s\n" "$arg" >> "${TMP}/${program}-stub-plan"; done
    echo "$FLAGS" "$arg" >> "${TMP}/${program}-stub-plan"
  done
 }
 unstub() {
@ -115,20 +74,8 @@ assert_failure() {
 assert_equal() {
  if [ "$1" != "$2" ]; then
-    { echo "expected:"
+    { echo "expected: $1"
-      echo "$1"
+      echo "actual:   $2"
      echo "actual:"
      echo "$2"
    } | flunk
  fi
 }
 assert_equal_wildcards() {
  if [[ $1 != $2 ]]; then
    { echo "expected:"
      echo "$2"
      echo "actual:"
      echo "$1"
    } | flunk
  fi
 }
@ -141,14 +88,6 @@ assert_output() {
  assert_equal "$expected" "$output"
 }
 assert_output_wildcards() {
  local expected
  if [ $# -eq 0 ]; then expected="$(cat -)"
  else expected="$1"
  fi
  assert_equal_wildcards "$output" "$expected"
 }
 assert_output_contains() {
  local expected="$1"
  echo "$output" | grep -F "$expected" >/dev/null || {
@ -158,16 +97,6 @@ assert_output_contains() {
  }
 }
 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"
@ -177,56 +106,3 @@ create_executable() {
 remove_executable() {
  rm -f "${PYENV_ROOT}/versions/$1/bin/$2"
 }
 setup_version() {
  create_executable "$1" "python"
  remove_executable "$1" "activate"
  remove_executable "$1" "conda"
 }
 teardown_version() {
  rm -fr "${PYENV_ROOT}/versions/$1"
 }
 setup_virtualenv() {
  create_executable "$1" "python"
  create_executable "$1" "activate"
  remove_executable "$1" "conda"
 }
 teardown_virtualenv() {
  rm -fr "${PYENV_ROOT}/versions/$1"
 }
 setup_m_venv() {
  create_executable "$1" "python"
  create_executable "$1" "activate"
  remove_executable "$1" "conda"
 }
 teardown_m_venv() {
  rm -fr "${PYENV_ROOT}/versions/$1"
 }
 setup_conda() {
  create_executable "$1" "python"
  create_executable "$1" "activate"
  create_executable "$1" "conda"
  local conda="$1"
  shift 1
  local env
  for env; do
    create_executable "${conda}/envs/${env}" "python"
    create_executable "${conda}/envs/${env}" "activate"
    create_executable "${conda}/envs/${env}" "conda"
    mkdir -p "${PYENV_ROOT}/versions/${conda}/envs/${env}/etc/conda/activate.d"
    touch "${PYENV_ROOT}/versions/${conda}/envs/${env}/etc/conda/activate.d/activate.sh"
    mkdir -p "${PYENV_ROOT}/versions/${conda}/envs/${env}/etc/conda/deactivate.d"
    touch "${PYENV_ROOT}/versions/${conda}/envs/${env}/etc/conda/deactivate.d/deactivate.sh"
  done
 }
 teardown_conda() {
  rm -fr "${PYENV_ROOT}/versions/$1"
 }
--- a/test/version.bats
+++ b/test/version.bats
@ -4,36 +4,40 @@ load test_helper
 setup() {
  export PYENV_ROOT="${TMP}/pyenv"
  export PYENV_VIRTUALENV_VERSION="20141106"
 }
@test "display virtualenv version" {
  setup_virtualenv "2.7.7"
  stub pyenv-prefix "echo '${PYENV_ROOT}/versions/2.7.7'"
-  stub pyenv-version-name "echo 2.7.7"
+  stub pyenv-prefix "echo '${PYENV_ROOT}/versions/2.7.7'"
  stub pyenv-exec "python -m venv --help : false"
  stub pyenv-exec "virtualenv --version : echo \"1.11\""
  create_executable "2.7.7" "virtualenv"
  remove_executable "2.7.7" "pyvenv"
  run pyenv-virtualenv --version
  assert_success
-  [[ "$output" == "pyenv-virtualenv "?.?.?" (virtualenv 1.11)" ]]
+  assert_output "pyenv-virtualenv ${PYENV_VIRTUALENV_VERSION} (virtualenv 1.11)"
  unstub pyenv-prefix
  unstub pyenv-exec
  teardown_virtualenv "2.7.7"
 }
-@test "display venv version" {
+@test "display pyvenv version" {
  setup_m_venv "3.4.1"
  stub pyenv-version-name "echo 3.4.1"
  stub pyenv-prefix "echo '${PYENV_ROOT}/versions/3.4.1'"
-  stub pyenv-exec "python -m venv --help : true"
+  stub pyenv-prefix "echo '${PYENV_ROOT}/versions/3.4.1'"
  stub pyenv-which "pyvenv : echo \"${PYENV_ROOT}/versions/3.4.1/bin/pyvenv\""
  stub pyenv-root "echo \"${PYENV_ROOT}\""
  remove_executable "3.4.1" "virtualenv"
  create_executable "3.4.1" "pyvenv"
  run pyenv-virtualenv --version
  assert_success
-  [[ "$output" == "pyenv-virtualenv "?.?.?" (python -m venv)" ]]
+  assert_output "pyenv-virtualenv ${PYENV_VIRTUALENV_VERSION} (pyvenv 3.4.1)"
  unstub pyenv-prefix
-  teardown_m_venv "3.4.1"
+  unstub pyenv-root
 }
--- a/test/virtualenv-prefix.bats
+++ b/test/virtualenv-prefix.bats
@ -0,0 +1,158 @@
 #!/usr/bin/env bats
 load test_helper
 setup() {
  export PYENV_ROOT="${TMP}/pyenv"
 }
 create_virtualenv() {
  mkdir -p "${PYENV_ROOT}/versions/$1/bin"
  touch "${PYENV_ROOT}/versions/$1/bin/activate"
 }
 remove_virtualenv() {
  rm -fr "${PYENV_ROOT}/versions/$1"
 }
@test "display prefix with using sys.real_prefix" {
  stub pyenv-version-name "echo venv27"
  stub pyenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/venv27\""
  stub pyenv-exec "echo \"${PYENV_ROOT}/versions/2.7.6\""
  create_virtualenv "venv27"
  PYENV_VERSION="venv27" run pyenv-virtualenv-prefix
  unstub pyenv-version-name
  unstub pyenv-prefix
  unstub pyenv-exec
  remove_virtualenv "venv27"
  assert_success
  assert_output <<OUT
 ${PYENV_ROOT}/versions/2.7.6
 OUT
 }
@test "display prefixes with using sys.real_prefix" {
  stub pyenv-version-name "echo venv27:venv32"
  stub pyenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/venv27\"" \
                    "venv32 : echo \"${PYENV_ROOT}/versions/venv32\""
  stub pyenv-exec "echo \"${PYENV_ROOT}/versions/2.7.6\"" \
                  "echo \"${PYENV_ROOT}/versions/3.2.1\""
  create_virtualenv "venv27"
  create_virtualenv "venv32"
  PYENV_VERSION="venv27:venv32" run pyenv-virtualenv-prefix
  unstub pyenv-version-name
  unstub pyenv-prefix
  unstub pyenv-exec
  remove_virtualenv "venv27"
  remove_virtualenv "venv32"
  assert_success
  assert_output <<OUT
 ${PYENV_ROOT}/versions/2.7.6:${PYENV_ROOT}/versions/3.2.1
 OUT
 }
@test "display prefix with using sys.base_prefix" {
  stub pyenv-version-name "echo venv33"
  stub pyenv-prefix "venv33 : echo \"${PYENV_ROOT}/versions/venv33\""
  stub pyenv-exec "false" \
                  "echo \"${PYENV_ROOT}/versions/3.3.3\""
  create_virtualenv "venv33"
  PYENV_VERSION="venv33" run pyenv-virtualenv-prefix
  unstub pyenv-version-name
  unstub pyenv-prefix
  unstub pyenv-exec
  remove_virtualenv "venv33"
  assert_success
  assert_output <<OUT
 ${PYENV_ROOT}/versions/3.3.3
 OUT
 }
@test "display prefixes with using sys.base_prefix" {
  stub pyenv-version-name "echo venv33:venv34"
  stub pyenv-prefix "venv33 : echo \"${PYENV_ROOT}/versions/venv33\"" \
                    "venv34 : echo \"${PYENV_ROOT}/versions/venv34\""
  stub pyenv-exec "false" \
                  "echo \"${PYENV_ROOT}/versions/3.3.3\"" \
                  "false" \
                  "echo \"${PYENV_ROOT}/versions/3.4.0\""
  create_virtualenv "venv33"
  create_virtualenv "venv34"
  PYENV_VERSION="venv33:venv34" run pyenv-virtualenv-prefix
  unstub pyenv-version-name
  unstub pyenv-prefix
  unstub pyenv-exec
  remove_virtualenv "venv33"
  remove_virtualenv "venv34"
  assert_success
  assert_output <<OUT
 ${PYENV_ROOT}/versions/3.3.3:${PYENV_ROOT}/versions/3.4.0
 OUT
 }
@test "should fail if the version is the system" {
  stub pyenv-version-name "echo system"
  PYENV_VERSION="system" run pyenv-virtualenv-prefix
  unstub pyenv-version-name
  assert_failure
  assert_output <<OUT
 pyenv-virtualenv: version \`system' is not a virtualenv
 OUT
 }
@test "should fail if the version is not a virtualenv" {
  stub pyenv-version-name "echo 3.4.0"
  stub pyenv-prefix "3.4.0 : echo \"${PYENV_ROOT}/versions/3.4.0\""
  mkdir -p "${PYENV_ROOT}/versions/3.4.0"
  PYENV_VERSION="3.4.0" run pyenv-virtualenv-prefix
  unstub pyenv-version-name
  unstub pyenv-prefix
  rmdir "${PYENV_ROOT}/versions/3.4.0"
  assert_failure
  assert_output <<OUT
 pyenv-virtualenv: version \`3.4.0' is not a virtualenv
 OUT
 }
@test "should fail if one of the versions is not a virtualenv" {
  stub pyenv-version-name "echo venv33:3.4.0"
  stub pyenv-prefix "venv33 : echo \"${PYENV_ROOT}/versions/venv33\"" \
                    "3.4.0 : echo \"${PYENV_ROOT}/versions/3.4.0\""
  stub pyenv-exec "false" \
                  "echo \"${PYENV_ROOT}/versions/3.3.3\""
  create_virtualenv "venv33"
  mkdir -p "${PYENV_ROOT}/versions/3.4.0"
  PYENV_VERSION="venv33:3.4.0" run pyenv-virtualenv-prefix
  unstub pyenv-version-name
  unstub pyenv-prefix
  unstub pyenv-exec
  remove_virtualenv "venv33"
  rmdir "${PYENV_ROOT}/versions/3.4.0"
  assert_failure
  assert_output <<OUT
 pyenv-virtualenv: version \`3.4.0' is not a virtualenv
 OUT
 }
--- a/test/virtualenv.bats
+++ b/test/virtualenv.bats
@ -7,8 +7,10 @@ setup() {
 }
 stub_pyenv() {
  setup_version "${PYENV_VERSION}"
  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"
@ -19,153 +21,116 @@ unstub_pyenv() {
  unstub pyenv-prefix
  unstub pyenv-hooks
  unstub pyenv-rehash
  teardown_version "${PYENV_VERSION}"
 }
@test "create virtualenv from given version" {
-  export PYENV_VERSION="2.7.11"
+  export PYENV_VERSION="3.2.1"
  stub_pyenv "${PYENV_VERSION}"
-  stub pyenv-virtualenv-prefix " : false"
+  stub pyenv-exec "virtualenv ${PYENV_ROOT}/versions/venv : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
-  stub pyenv-exec "python -m venv --help : false"
+  stub pyenv-exec "python -m ensurepip : false"
-  stub pyenv-exec "virtualenv * : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\"; mkdir -p \"\$2/bin\""
+  stub pyenv-exec "python */ez_setup.py : true"
-  stub pyenv-exec "python -s -m ensurepip : false"
+  stub pyenv-exec "python */get-pip.py : true"
-  stub pyenv-exec "python -s */get-pip.py : true"
+  stub curl true
  stub curl true
  create_executable "${PYENV_VERSION}" "python-config"
  create_executable "${PYENV_VERSION}" "python2-config"
  create_executable "${PYENV_VERSION}" "python2.7-config"
-  run pyenv-virtualenv "2.7.11" "venv"
+  run pyenv-virtualenv "3.2.1" "venv"
  assert_success
  assert_output <<OUT
-PYENV_VERSION=2.7.11 virtualenv ${PYENV_ROOT}/versions/2.7.11/envs/venv
+PYENV_VERSION=3.2.1 virtualenv ${PYENV_ROOT}/versions/venv
-Installing pip from https://bootstrap.pypa.io/pip/2.7/get-pip.py...
+Installing setuptools from https://bootstrap.pypa.io/ez_setup.py...
 Installing pip from https://bootstrap.pypa.io/get-pip.py...
 rehashed
 OUT
  assert_success
  for x in pydoc python-config python2-config python2.7-config; do
    assert [ -x "${PYENV_ROOT}/versions/2.7.11/envs/venv/bin/$x" ]
  done
  unstub_pyenv
  unstub pyenv-virtualenv-prefix
  unstub pyenv-exec
  unstub curl
 }
@test "create virtualenv from a given prefix" {
  stub_pyenv "2.7.11"
  stub pyenv-virtualenv-prefix " : false"
  stub pyenv-exec "python -m venv --help : false"
  stub pyenv-exec "virtualenv * : 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
  stub pyenv-latest "-f 2.7 : echo 2.7.11"
  run pyenv-virtualenv "2.7" "venv"
  assert_output <<OUT
 PYENV_VERSION=2.7.11 virtualenv ${PYENV_ROOT}/versions/2.7.11/envs/venv
 Installing pip from https://bootstrap.pypa.io/pip/2.7/get-pip.py...
 rehashed
 OUT
  assert [ -x "${PYENV_ROOT}/versions/2.7.11/envs/venv/bin/pydoc" ]
  assert [ ! -e "${PYENV_ROOT}/versions/2.7" ]
  assert_success
  unstub_pyenv
  unstub pyenv-virtualenv-prefix
  unstub pyenv-exec
  unstub curl
 }
@test "create virtualenv from current version" {
-  export PYENV_VERSION="2.7.11"
+  export PYENV_VERSION="3.2.1"
  stub_pyenv "${PYENV_VERSION}"
  stub pyenv-version-name "echo \${PYENV_VERSION}"
-  stub pyenv-virtualenv-prefix " : false"
+  stub pyenv-exec "virtualenv ${PYENV_ROOT}/versions/venv : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
-  stub pyenv-exec "python -m venv --help : false"
+  stub pyenv-exec "python -m ensurepip : false"
-  stub pyenv-exec "virtualenv * : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
+  stub pyenv-exec "python */ez_setup.py : true"
-  stub pyenv-exec "python -s -m ensurepip : false"
+  stub pyenv-exec "python */get-pip.py : true"
-  stub pyenv-exec "python -s */get-pip.py : true"
+  stub curl true
  stub curl true
  run pyenv-virtualenv venv
  assert_success
  assert_output <<OUT
-PYENV_VERSION=2.7.11 virtualenv ${PYENV_ROOT}/versions/2.7.11/envs/venv
+PYENV_VERSION=3.2.1 virtualenv ${PYENV_ROOT}/versions/venv
-Installing pip from https://bootstrap.pypa.io/pip/2.7/get-pip.py...
+Installing setuptools from https://bootstrap.pypa.io/ez_setup.py...
 Installing pip from https://bootstrap.pypa.io/get-pip.py...
 rehashed
 OUT
  assert [ -x "${PYENV_ROOT}/versions/2.7.11/envs/venv/bin/pydoc" ]
  assert_success
  unstub_pyenv
  unstub pyenv-version-name
  unstub pyenv-virtualenv-prefix
  unstub pyenv-exec
  unstub curl
 }
@test "create virtualenv with short options" {
-  export PYENV_VERSION="2.7.11"
+  export PYENV_VERSION="3.2.1"
  stub_pyenv "${PYENV_VERSION}"
  stub pyenv-version-name "echo \${PYENV_VERSION}"
-  stub pyenv-virtualenv-prefix " : false"
+  stub pyenv-exec "virtualenv --verbose --python=python ${PYENV_ROOT}/versions/venv : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
-  stub pyenv-exec "python -m venv --help : false"
+  stub pyenv-exec "python -m ensurepip : false"
-  stub pyenv-exec "virtualenv * : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
+  stub pyenv-exec "python */ez_setup.py : true"
-  stub pyenv-exec "python -s -m ensurepip : false"
+  stub pyenv-exec "python */get-pip.py : true"
-  stub pyenv-exec "python -s */get-pip.py : true"
+  stub curl true
  stub curl true
-  run pyenv-virtualenv -v -p ${TMP}/python venv
+  run pyenv-virtualenv -v -p python venv
  assert_success
  assert_output <<OUT
-PYENV_VERSION=2.7.11 virtualenv --verbose --python=${TMP}/python ${PYENV_ROOT}/versions/2.7.11/envs/venv
+PYENV_VERSION=3.2.1 virtualenv --verbose --python=python ${PYENV_ROOT}/versions/venv
-Installing pip from https://bootstrap.pypa.io/pip/2.7/get-pip.py...
+Installing setuptools from https://bootstrap.pypa.io/ez_setup.py...
 Installing pip from https://bootstrap.pypa.io/get-pip.py...
 rehashed
 OUT
  assert [ -x "${PYENV_ROOT}/versions/2.7.11/envs/venv/bin/pydoc" ]
  assert_success
  unstub_pyenv
  unstub pyenv-version-name
  unstub pyenv-virtualenv-prefix
  unstub pyenv-exec
  unstub curl
 }
@test "create virtualenv with long options" {
-  export PYENV_VERSION="2.7.11"
+  export PYENV_VERSION="3.2.1"
  stub_pyenv "${PYENV_VERSION}"
  stub pyenv-version-name "echo \${PYENV_VERSION}"
-  stub pyenv-virtualenv-prefix " : false"
+  stub pyenv-exec "virtualenv --verbose --python=python ${PYENV_ROOT}/versions/venv : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
-  stub pyenv-exec "python -m venv --help : false"
+  stub pyenv-exec "python -m ensurepip : false"
-  stub pyenv-exec "virtualenv * : echo PYENV_VERSION=\${PYENV_VERSION} \"\$@\""
+  stub pyenv-exec "python */ez_setup.py : true"
-  stub pyenv-exec "python -s -m ensurepip : false"
+  stub pyenv-exec "python */get-pip.py : true"
-  stub pyenv-exec "python -s */get-pip.py : true"
+  stub curl true
  stub curl true
-  run pyenv-virtualenv --verbose --python=${TMP}/python venv
+  run pyenv-virtualenv --verbose --python=python venv
  assert_success
  assert_output <<OUT
-PYENV_VERSION=2.7.11 virtualenv --verbose --python=${TMP}/python ${PYENV_ROOT}/versions/2.7.11/envs/venv
+PYENV_VERSION=3.2.1 virtualenv --verbose --python=python ${PYENV_ROOT}/versions/venv
-Installing pip from https://bootstrap.pypa.io/pip/2.7/get-pip.py...
+Installing setuptools from https://bootstrap.pypa.io/ez_setup.py...
 Installing pip from https://bootstrap.pypa.io/get-pip.py...
 rehashed
 OUT
  assert [ -x "${PYENV_ROOT}/versions/2.7.11/envs/venv/bin/pydoc" ]
  assert_success
  unstub_pyenv
  unstub pyenv-version-name
  unstub pyenv-virtualenv-prefix
  unstub pyenv-exec
  unstub curl
 }
@test "no whitespace allowed in virtualenv name" {
-  run pyenv-virtualenv "2.7.11" "foo bar"
+  run pyenv-virtualenv "3.2.1" "foo bar"
  assert_failure
  assert_output <<OUT
@ -174,54 +139,10 @@ OUT
 }
@test "no tab allowed in virtualenv name" {
-  run pyenv-virtualenv "2.7.11" "foo	bar baz"
+  run pyenv-virtualenv "3.2.1" "foo	bar baz"
  assert_failure
  assert_output <<OUT
 pyenv-virtualenv: no whitespace allowed in virtualenv name.
 OUT
 }
@test "system not allowed as virtualenv name" {
  run pyenv-virtualenv "2.7.11" "system"
  assert_failure
  assert_output <<OUT
 pyenv-virtualenv: \`system' is not allowed as virtualenv name.
 OUT
 }
@test "no slash allowed in virtualenv name" {
  run pyenv-virtualenv "2.7.11" "foo/bar"
  assert_failure
  assert_output <<OUT
 pyenv-virtualenv: no slash allowed in virtualenv name.
 OUT
 }
@test "slash allowed if it is the long name of the virtualenv" {
  export PYENV_VERSION="2.7.11"
  stub_pyenv "${PYENV_VERSION}"
  stub pyenv-virtualenv-prefix " : false"
  stub pyenv-exec "python -m venv --help : false"
  stub pyenv-exec "virtualenv * : 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 "2.7.11" "2.7.11/envs/foo"
  assert_output <<OUT
 PYENV_VERSION=2.7.11 virtualenv ${PYENV_ROOT}/versions/2.7.11/envs/foo
 Installing pip from https://bootstrap.pypa.io/pip/2.7/get-pip.py...
 rehashed
 OUT
  assert [ -x "${PYENV_ROOT}/versions/2.7.11/envs/foo/bin/pydoc" ]
  assert_success
  unstub_pyenv
  unstub pyenv-virtualenv-prefix
  unstub pyenv-exec
  unstub curl
 }
--- a/test/virtualenvs.bats
+++ b/test/virtualenvs.bats
@ -2,181 +2,67 @@
 load test_helper
 create_m_system_venv() {
  # Create a mock virtual environment in the same way a venv created from
  # the system Python version looks.
  #
  # The venv is in ${PYENV_ROOT}/versions, is not a symlink, and
  # home is /usr/bin in the pyenv.cfg.
  create_executable "$2" "python"
  create_executable "$2" "activate"
  local version="$1"
  local venv="$2"
  local venv_dir="${PYENV_ROOT}/versions/${venv}"
  echo "home = /usr/bin" > "${venv_dir}/pyvenv.cfg"
 }
 create_m_venv() {
  # Create a mock virtual environment from an installed (not system) Python version.
  #
  # The venv name is a symlink inside ${PYENV_ROOT}/versions that points to
  # the real venv directory inside the Python version used to created and
  # home points to the bin directory inside the venv dir.
  setup_m_venv "$1/envs/$2"
  local version="$1"
  local venv="$2"
  local venv_dir="${PYENV_ROOT}/versions/${version}/envs/${venv}"
  echo "home = ${PYENV_ROOT}/versions/${version}/bin" > "${venv_dir}/pyvenv.cfg"
  ln -sf "${venv_dir}" "${PYENV_ROOT}/versions/${venv}"
 }
 setup() {
  export PYENV_ROOT="${TMP}/pyenv"
  mkdir -p "${PYENV_ROOT}/versions/2.7.6"
  mkdir -p "${PYENV_ROOT}/versions/3.3.3"
  mkdir -p "${PYENV_ROOT}/versions/venv27"
  mkdir -p "${PYENV_ROOT}/versions/venv33"
 }
-@test "system venv" {
+@test "list virtual environments only" {
  stub pyenv-version-name ": echo venv314"
  stub pyenv-version-origin ": echo PYENV_VERSION"
  create_m_venv "3.14.3" "venv314"
  create_m_system_venv "3.9.11" "system_venv"
  run pyenv-virtualenvs
  assert_success
  assert_output <<OUT
  3.14.3/envs/venv314 (created from ${PYENV_ROOT}/versions/3.14.3)
  system_venv (created from /usr)
 * venv314 --> ${PYENV_ROOT}/versions/3.14.3/envs/venv314 (set by PYENV_VERSION)
 OUT
  unstub pyenv-version-name
  unstub pyenv-version-origin
 }
@test "list virtual environments" {
  stub pyenv-version-name ": echo system"
-  stub pyenv-virtualenv-prefix "2.7.6/envs/venv27 : echo \"${PYENV_ROOT}/versions/2.7.6\""
+  stub pyenv-versions "--bare : echo \"system\";echo \"2.7.6\";echo \"3.3.3\";echo \"venv27\";echo \"venv33\""
-  stub pyenv-virtualenv-prefix "3.3.3/envs/venv33 : echo \"${PYENV_ROOT}/versions/3.3.3\""
+  stub pyenv-virtualenv-prefix "2.7.6 : false"
-
+  stub pyenv-virtualenv-prefix "3.3.3 : false"
-  create_m_venv "2.7.6" "venv27"
+  stub pyenv-virtualenv-prefix "venv27 : echo \"${PYENV_ROOT}/versions/2.7.6\""
-  create_m_venv "3.3.3" "venv33"
+  stub pyenv-virtualenv-prefix "venv33 : echo \"${PYENV_ROOT}/versions/3.3.3\""
  run pyenv-virtualenvs
  unstub pyenv-version-name
  unstub pyenv-versions
  unstub pyenv-virtualenv-prefix
  assert_success
  assert_output <<OUT
-  2.7.6/envs/venv27 (created from ${PYENV_ROOT}/versions/2.7.6)
+  venv27 (created from ${PYENV_ROOT}/versions/2.7.6)
-  3.3.3/envs/venv33 (created from ${PYENV_ROOT}/versions/3.3.3)
+  venv33 (created from ${PYENV_ROOT}/versions/3.3.3)
  venv27 --> ${PYENV_ROOT}/versions/2.7.6/envs/venv27
  venv33 --> ${PYENV_ROOT}/versions/3.3.3/envs/venv33
 OUT
  unstub pyenv-version-name
  unstub pyenv-virtualenv-prefix
 }
@test "list virtual environments with hit prefix" {
-  stub pyenv-version-name ": echo 3.3.3/envs/venv33"
+  stub pyenv-version-name ": echo venv33"
-  stub pyenv-version-origin ": echo PYENV_VERSION"
+  stub pyenv-versions "--bare : echo \"system\";echo \"venv27\";echo \"venv33\""
-
+  stub pyenv-virtualenv-prefix "venv27 : echo \"/usr\""
-  create_m_venv "2.7.6" "venv27"
+  stub pyenv-virtualenv-prefix "venv33 : echo \"/usr\""
  create_m_venv "3.3.3" "venv33"
  run pyenv-virtualenvs
  unstub pyenv-version-name
  unstub pyenv-versions
  unstub pyenv-virtualenv-prefix
  assert_success
  assert_output <<OUT
-  2.7.6/envs/venv27 (created from ${PYENV_ROOT}/versions/2.7.6)
+  venv27 (created from /usr)
-* 3.3.3/envs/venv33 (created from ${PYENV_ROOT}/versions/3.3.3) (set by PYENV_VERSION)
+* venv33 (created from /usr)
  venv27 --> ${PYENV_ROOT}/versions/2.7.6/envs/venv27
  venv33 --> ${PYENV_ROOT}/versions/3.3.3/envs/venv33
 OUT
  unstub pyenv-version-name
  unstub pyenv-version-origin
 }
-@test "list bare virtual environments" {
+@test "list virtual environments with --bare" {
-  create_m_venv "2.7.6" "venv27"
+  stub pyenv-versions "--bare : echo \"system\";echo \"venv27\";echo \"venv33\""
-  create_m_venv "3.3.3" "venv33"
+  stub pyenv-virtualenv-prefix "venv27 : echo \"/usr\""
  stub pyenv-virtualenv-prefix "venv33 : echo \"/usr\""
  run pyenv-virtualenvs --bare
  unstub pyenv-versions
  unstub pyenv-virtualenv-prefix
  assert_success
  assert_output <<OUT
 2.7.6/envs/venv27
 3.3.3/envs/venv33
 venv27
 venv33
 OUT
 }
@test "list bare virtual environments without aliases" {
  create_m_venv "2.7.6" "venv27"
  create_m_venv "3.3.3" "venv33"
  run pyenv-virtualenvs --bare --skip-aliases
  assert_success
  assert_output <<OUT
 2.7.6/envs/venv27
 3.3.3/envs/venv33
 OUT
 }
@test "list virtual environments without aliases" {
  stub pyenv-version-name ": echo system"
  create_m_venv "2.7.6" "venv27"
  create_m_venv "3.3.3" "venv33"
  run pyenv-virtualenvs --skip-aliases
  assert_success
  assert_output <<OUT
  2.7.6/envs/venv27 (created from ${PYENV_ROOT}/versions/2.7.6)
  3.3.3/envs/venv33 (created from ${PYENV_ROOT}/versions/3.3.3)
 OUT
  unstub pyenv-version-name
 }
@test "hit prefix matches alias version name" {
  stub pyenv-version-name ": echo venv27"
  stub pyenv-version-origin ": echo PYENV_VERSION"
  create_m_venv "2.7.6" "venv27"
  create_m_venv "3.3.3" "venv33"
  run pyenv-virtualenvs
  assert_success
  assert_output <<OUT
  2.7.6/envs/venv27 (created from ${PYENV_ROOT}/versions/2.7.6)
  3.3.3/envs/venv33 (created from ${PYENV_ROOT}/versions/3.3.3)
 * venv27 --> ${PYENV_ROOT}/versions/2.7.6/envs/venv27 (set by PYENV_VERSION)
  venv33 --> ${PYENV_ROOT}/versions/3.3.3/envs/venv33
 OUT
  unstub pyenv-version-name
  unstub pyenv-version-origin
 }
@test "completions output" {
  create_m_venv "2.7.6" "venv27"
  create_m_venv "3.3.3" "venv33"
  run pyenv-virtualenvs --complete
  assert_success
  assert_output <<OUT
 --bare
 --skip-aliases
 OUT
 }