rbenv 1.3.2

Fix traversing PATH for bash < 4.4

.gitattributes

@@ -0,0 +1 @@
+/share/man/man[1-8]/*.[1-8] linguist-generated

.github/dependabot.yml

@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: 'github-actions'
+    directory: '/'
+    schedule:
+      interval: 'weekly'

.github/workflows/ci.yml

@@ -0,0 +1,17 @@
+name: CI
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+    
+    steps:
+    - uses: actions/checkout@v4
+    - name: Install bats
+      run: git clone --depth 1 --branch v1.10.0 https://github.com/bats-core/bats-core.git bats
+    - name: Run tests
+      run: PATH="./bats/bin:$PATH" test/run

.github/workflows/lint.yml

@@ -0,0 +1,29 @@
+---
+
+name: Lint
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+
+permissions:
+  contents: read
+
+jobs:
+  shellcheck:
+    runs-on: ubuntu-latest
+
+    permissions:
+      security-events: write
+
+    steps:
+      - name: Repository checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Differential ShellCheck
+        uses: redhat-plumbers-in-action/differential-shellcheck@v5
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/release.yml

@@ -0,0 +1,16 @@
+name: Release
+on:
+  push:
+    tags: 'v*'
+
+jobs:
+  homebrew:
+    name: Bump Homebrew formula
+    runs-on: ubuntu-latest
+    steps:
+      - uses: mislav/bump-homebrew-formula-action@v3.2
+        if: "!contains(github.ref, '-')" # skip prereleases
+        with:
+          formula-name: rbenv
+        env:
+          COMMITTER_TOKEN: ${{ secrets.COMMITTER_TOKEN }}

.gitignore

@@ -7,3 +7,4 @@
 /libexec/*.dylib
 /src/Makefile
 /src/*.o
+/gems

.travis.yml

@@ -1,7 +0,0 @@
-sudo: false
-install: git clone --depth 1 https://github.com/sstephenson/bats.git
-script: PATH="./bats/bin:$PATH" test/run
-language: c
-env:
-  - RBENV_NATIVE_EXT=
-  - RBENV_NATIVE_EXT=1

.vimrc

@@ -0,0 +1 @@
+set wildignore+=versions/*,cache/*

CODE_OF_CONDUCT.md

@@ -0,0 +1,80 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting one of the project maintainers listed below. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Project Maintainers
+
+* Sam Stephenson <<sstephenson@gmail.com>>
+* Mislav Marohnić <<mislav.marohnic@gmail.com>>
+* Erik Michaels-Ober <<sferik@gmail.com>>
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

Makefile

@@ -0,0 +1,4 @@
+release_version := $(shell GIT_CEILING_DIRECTORIES=$(PWD) bin/rbenv --version | cut -d' ' -f2)
+
+share/man/man1/rbenv.1: share/man/man1/rbenv.1.adoc
+	asciidoctor -b manpage -a version=$(release_version:v%=%) $<

README.md

@@ -1,290 +1,169 @@
-# Groom your app’s Ruby environment with rbenv.
+# Seamlessly manage your app’s Ruby environment with rbenv.
 
-Use rbenv to pick a Ruby version for your application and guarantee
+rbenv is a version manager tool for the Ruby programming language on Unix-like systems. It is useful for switching between multiple Ruby versions on the same machine and for ensuring that each project you are working on always runs on the correct Ruby version.
-that your development environment matches production. Put rbenv to work
-with [Bundler](http://bundler.io/) for painless Ruby upgrades and
-bulletproof deployments.
-
-**Powerful in development.** Specify your app's Ruby version once,
-  in a single file. Keep all your teammates on the same page. No
-  headaches running apps on different versions of Ruby. Just Works™
-  from the command line and with app servers like [Pow](http://pow.cx).
-  Override the Ruby version anytime: just set an environment variable.
-
-**Rock-solid in production.** Your application's executables are its
-  interface with ops. With rbenv and [Bundler
-  binstubs](https://github.com/sstephenson/rbenv/wiki/Understanding-binstubs)
-  you'll never again need to `cd` in a cron job or Chef recipe to
-  ensure you've selected the right runtime. The Ruby version
-  dependency lives in one place—your app—so upgrades and rollbacks are
-  atomic, even when you switch versions.
-
-**One thing well.** rbenv is concerned solely with switching Ruby
-  versions. It's simple and predictable. A rich plugin ecosystem lets
-  you tailor it to suit your needs. Compile your own Ruby versions, or
-  use the [ruby-build][]
-  plugin to automate the process. Specify per-application environment
-  variables with [rbenv-vars](https://github.com/sstephenson/rbenv-vars).
-  See more [plugins on the
-  wiki](https://github.com/sstephenson/rbenv/wiki/Plugins).
-
-[**Why choose rbenv over
-RVM?**](https://github.com/sstephenson/rbenv/wiki/Why-rbenv%3F)
-
-## Table of Contents
-
-* [How It Works](#how-it-works)
-  * [Understanding PATH](#understanding-path)
-  * [Understanding Shims](#understanding-shims)
-  * [Choosing the Ruby Version](#choosing-the-ruby-version)
-  * [Locating the Ruby Installation](#locating-the-ruby-installation)
-* [Installation](#installation)
-  * [Basic GitHub Checkout](#basic-github-checkout)
-    * [Upgrading](#upgrading)
-  * [Homebrew on Mac OS X](#homebrew-on-mac-os-x)
-  * [How rbenv hooks into your shell](#how-rbenv-hooks-into-your-shell)
-  * [Installing Ruby Versions](#installing-ruby-versions)
-  * [Uninstalling Ruby Versions](#uninstalling-ruby-versions)
-* [Command Reference](#command-reference)
-  * [rbenv local](#rbenv-local)
-  * [rbenv global](#rbenv-global)
-  * [rbenv shell](#rbenv-shell)
-  * [rbenv versions](#rbenv-versions)
-  * [rbenv version](#rbenv-version)
-  * [rbenv rehash](#rbenv-rehash)
-  * [rbenv which](#rbenv-which)
-  * [rbenv whence](#rbenv-whence)
-* [Development](#development)
 
 ## How It Works
 
-At a high level, rbenv intercepts Ruby commands using shim
+After rbenv injects itself into your PATH at installation time, any invocation of `ruby`, `gem`, `bundler`, or other Ruby-related executable will first activate rbenv. Then, rbenv scans the current project directory for a file named `.ruby-version`. If found, that file determines the version of Ruby that should be used within that directory. Finally, rbenv looks up that Ruby version among those installed under `~/.rbenv/versions/`.
-executables injected into your `PATH`, determines which Ruby version
-has been specified by your application, and passes your commands along
-to the correct Ruby installation.
 
-### Understanding PATH
+You can choose the Ruby version for your project with, for example:
+```sh
+cd myproject
+# choose Ruby version 3.1.2:
+rbenv local 3.1.2
+```
 
-When you run a command like `ruby` or `rake`, your operating system
+Doing so will create or update the `.ruby-version` file in the current directory with the version that you've chosen. A different project of yours that is another directory might be using a different version of Ruby altogether—rbenv will seamlessly transition from one Ruby version to another when you switch projects.
-searches through a list of directories to find an executable file with
-that name. This list of directories lives in an environment variable
-called `PATH`, with each directory in the list separated by a colon:
 
-    /usr/local/bin:/usr/bin:/bin
+Finally, almost every aspect of rbenv's mechanism is [customizable via plugins][plugins] written in bash.
 
-Directories in `PATH` are searched from left to right, so a matching
+The simplicity of rbenv has its benefits, but also some downsides. See the [comparison of version managers][alternatives] for more details and some alternatives.
-executable in a directory at the beginning of the list takes
-precedence over another one at the end. In this example, the
-`/usr/local/bin` directory will be searched first, then `/usr/bin`,
-then `/bin`.
-
-### Understanding Shims
-
-rbenv works by inserting a directory of _shims_ at the front of your
-`PATH`:
-
-    ~/.rbenv/shims:/usr/local/bin:/usr/bin:/bin
-
-Through a process called _rehashing_, rbenv maintains shims in that
-directory to match every Ruby command across every installed version
-of Ruby—`irb`, `gem`, `rake`, `rails`, `ruby`, and so on.
-
-Shims are lightweight executables that simply pass your command along
-to rbenv. So with rbenv installed, when you run, say, `rake`, your
-operating system will do the following:
-
-* Search your `PATH` for an executable file named `rake`
-* Find the rbenv shim named `rake` at the beginning of your `PATH`
-* Run the shim named `rake`, which in turn passes the command along to
-  rbenv
-
-### Choosing the Ruby Version
-
-When you execute a shim, rbenv determines which Ruby version to use by
-reading it from the following sources, in this order:
-
-1. The `RBENV_VERSION` environment variable, if specified. You can use
-   the [`rbenv shell`](#rbenv-shell) command to set this environment
-   variable in your current shell session.
-
-2. The first `.ruby-version` file found by searching the directory of the
-   script you are executing and each of its parent directories until reaching
-   the root of your filesystem.
-
-3. The first `.ruby-version` file found by searching the current working
-   directory and each of its parent directories until reaching the root of your
-   filesystem. You can modify the `.ruby-version` file in the current working
-   directory with the [`rbenv local`](#rbenv-local) command.
-
-4. The global `~/.rbenv/version` file. You can modify this file using
-   the [`rbenv global`](#rbenv-global) command. If the global version
-   file is not present, rbenv assumes you want to use the "system"
-   Ruby—i.e. whatever version would be run if rbenv weren't in your
-   path.
-
-### Locating the Ruby Installation
-
-Once rbenv has determined which version of Ruby your application has
-specified, it passes the command along to the corresponding Ruby
-installation.
-
-Each Ruby version is installed into its own directory under
-`~/.rbenv/versions`. For example, you might have these versions
-installed:
-
-* `~/.rbenv/versions/1.8.7-p371/`
-* `~/.rbenv/versions/1.9.3-p327/`
-* `~/.rbenv/versions/jruby-1.7.1/`
-
-Version names to rbenv are simply the names of the directories in
-`~/.rbenv/versions`.
 
 ## Installation
 
-**Compatibility note**: rbenv is _incompatible_ with RVM. Please make
+On systems with Homebrew package manager, the “Using Package Managers” method is recommended. On other systems, “Basic Git Checkout” might be the easiest way of ensuring that you are always installing the latest version of rbenv.
-  sure to fully uninstall RVM and remove any references to it from
-  your shell initialization files before installing rbenv.
 
-If you're on Mac OS X, consider
+### Using Package Managers
-[installing with Homebrew](#homebrew-on-mac-os-x).
 
-### Basic GitHub Checkout
+1. Install rbenv using one of the following approaches.
 
-This will get you going with the latest version of rbenv and make it
+   #### Homebrew
-easy to fork and contribute any changes back upstream.
+   
+   On macOS or Linux, we recommend installing rbenv with [Homebrew](https://brew.sh).
+   
+   ```sh
+   brew install rbenv
+   ```
+   
+   #### Debian, Ubuntu, and their derivatives
+       
+   > [!CAUTION]   
+   > The version of rbenv that is packaged and maintained in official
+   Debian and Ubuntu repositories is _out of date_. To install the latest
+   version, it is recommended to [install rbenv using git](#basic-git-checkout).
+   
+   ```sh
+   sudo apt install rbenv
+   ```
+   
+   #### Arch Linux and its derivatives
+   
+   Archlinux has an [AUR Package](https://aur.archlinux.org/packages/rbenv/) for
+   rbenv and you can install it from the AUR using the instructions from this
+   [wiki page](https://wiki.archlinux.org/index.php/Arch_User_Repository#Installing_and_upgrading_packages).
 
-1. Check out rbenv into `~/.rbenv`.
+   #### Fedora
 
-    ~~~ sh
+   Fedora has an [official package](https://packages.fedoraproject.org/pkgs/rbenv/rbenv/) which you can install:
-    $ git clone https://github.com/sstephenson/rbenv.git ~/.rbenv
-    ~~~
 
-2. Add `~/.rbenv/bin` to your `$PATH` for access to the `rbenv`
+   ```sh
-   command-line utility.
+   sudo dnf install rbenv
+   ```
 
-    ~~~ sh
+2. Set up your shell to load rbenv.
-    $ echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bash_profile
-    ~~~
 
-    **Ubuntu Desktop note**: Modify your `~/.bashrc` instead of `~/.bash_profile`.
+    ```sh
+    rbenv init
+    ```
 
-    **Zsh note**: Modify your `~/.zshrc` file instead of `~/.bash_profile`.
+3. Close your Terminal window and open a new one so your changes take effect.
 
-3. Add `rbenv init` to your shell to enable shims and autocompletion.
+That's it! You are now ready to [install some Ruby versions](#installing-ruby-versions).
 
-    ~~~ sh
+### Basic Git Checkout
-    $ echo 'eval "$(rbenv init -)"' >> ~/.bash_profile
-    ~~~
 
-    _Same as in previous step, use `~/.bashrc` on Ubuntu, or `~/.zshrc` for Zsh._
+> [!NOTE]   
+> For a more automated install, you can use [rbenv-installer](https://github.com/rbenv/rbenv-installer#rbenv-installer). If you do not want to execute scripts downloaded from a web URL or simply prefer a manual approach, follow the steps below.
 
-4. Restart your shell so that PATH changes take effect. (Opening a new
+This will get you going with the latest version of rbenv without needing a system-wide install.
-   terminal tab will usually do it.) Now check if rbenv was set up:
 
-    ~~~ sh
+1. Clone rbenv into `~/.rbenv`.
-    $ type rbenv
-    #=> "rbenv is a function"
-    ~~~
 
-5. _(Optional)_ Install [ruby-build][], which provides the
+    ```sh
-   `rbenv install` command that simplifies the process of
+    git clone https://github.com/rbenv/rbenv.git ~/.rbenv
-   [installing new Ruby versions](#installing-ruby-versions).
+    ```
 
-#### Upgrading
+2. Set up your shell to load rbenv.
 
-If you've installed rbenv manually using git, you can upgrade your
+    ```sh
-installation to the cutting-edge version at any time.
+    ~/.rbenv/bin/rbenv init
+    ```
 
-~~~ sh
+   If you are curious, see here to [understand what `init` does](#how-rbenv-hooks-into-your-shell).
-$ cd ~/.rbenv
-$ git pull
-~~~
 
-To use a specific release of rbenv, check out the corresponding tag:
+3. Restart your shell so that these changes take effect. (Opening a new terminal tab will usually do it.)
 
-~~~ sh
+#### Shell completions
-$ cd ~/.rbenv
-$ git fetch
-$ git checkout v0.3.0
-~~~
 
-If you've [installed via Homebrew](#homebrew-on-mac-os-x), then upgrade
+When _manually_ installing rbenv, it might be useful to note how completion scripts for various shells work. Completion scripts help with typing rbenv commands by expanding partially entered rbenv command names and option flags; typically this is invoked by pressing <kbd>Tab</kbd> key in an interactive shell.
-via its `brew` command:
 
-~~~ sh
+- The **bash** completion script for rbenv ships with the project and gets [loaded by the `rbenv init` mechanism](#how-rbenv-hooks-into-your-shell).
-$ brew update
-$ brew upgrade rbenv ruby-build
-~~~
 
-### Homebrew on Mac OS X
+- The **zsh** completion script ships with the project, but needs to be added to FPATH in zsh before it can be discovered by the shell. One way to do this would be to edit `~/.zshrc`:
 
-As an alternative to installation via GitHub checkout, you can install
+  ```sh
-rbenv and [ruby-build][] using the [Homebrew](http://brew.sh) package
+  # assuming that rbenv was installed to `~/.rbenv`
-manager on Mac OS X:
+  FPATH=~/.rbenv/completions:"$FPATH"
 
-~~~
+  autoload -U compinit
-$ brew update
+  compinit
-$ brew install rbenv ruby-build
+  ```
-~~~
 
-Afterwards you'll still need to add `eval "$(rbenv init -)"` to your
+- The **fish** completion script for rbenv ships with the fish shell itself and is not maintained by the rbenv project.
-profile as stated in the caveats. You'll only ever have to do this
-once.
 
-### How rbenv hooks into your shell
+### Installing Ruby versions
 
-Skip this section unless you must know what every line in your shell
+The `rbenv install` command does not ship with rbenv out-of-the-box, but is provided by the [ruby-build][] plugin.
-profile is doing.
 
-`rbenv init` is the only command that crosses the line of loading
+Before attempting to install Ruby, **check that [your build environment](https://github.com/rbenv/ruby-build/wiki#suggested-build-environment) has the necessary tools and libraries**. Then:
-extra commands into your shell. Coming from RVM, some of you might be
-opposed to this idea. Here's what `rbenv init` actually does:
 
-1. Sets up your shims path. This is the only requirement for rbenv to
+```sh
-   function properly. You can do this by hand by prepending
+# list latest stable versions:
-   `~/.rbenv/shims` to your `$PATH`.
+rbenv install -l
 
-2. Installs autocompletion. This is entirely optional but pretty
+# list all local versions:
-   useful. Sourcing `~/.rbenv/completions/rbenv.bash` will set that
+rbenv install -L
-   up. There is also a `~/.rbenv/completions/rbenv.zsh` for Zsh
-   users.
-
-3. Rehashes shims. From time to time you'll need to rebuild your
-   shim files. Doing this automatically makes sure everything is up to
-   date. You can always run `rbenv rehash` manually.
-
-4. Installs the sh dispatcher. This bit is also optional, but allows
-   rbenv and plugins to change variables in your current shell, making
-   commands like `rbenv shell` possible. The sh dispatcher doesn't do
-   anything crazy like override `cd` or hack your shell prompt, but if
-   for some reason you need `rbenv` to be a real script rather than a
-   shell function, you can safely skip it.
-
-Run `rbenv init -` for yourself to see exactly what happens under the
-hood.
-
-### Installing Ruby Versions
-
-The `rbenv install` command doesn't ship with rbenv out of the box, but
-is provided by the [ruby-build][] project. If you installed it either
-as part of GitHub checkout process outlined above or via Homebrew, you
-should be able to:
-
-~~~ sh
-# list all available versions:
-$ rbenv install -l
 
 # install a Ruby version:
-$ rbenv install 2.0.0-p247
+rbenv install 3.1.2
-~~~
+```
 
-Alternatively to the `install` command, you can download and compile
+For troubleshooting `BUILD FAILED` scenarios, check the [ruby-build Discussions section](https://github.com/rbenv/ruby-build/discussions/categories/build-failures).
-Ruby manually as a subdirectory of `~/.rbenv/versions/`. An entry in
-that directory can also be a symlink to a Ruby version installed
-elsewhere on the filesystem. rbenv doesn't care; it will simply treat
-any entry in the `versions/` directory as a separate Ruby version.
 
-### Uninstalling Ruby Versions
+> [!NOTE]  
+> If the `rbenv install` command wasn't found, you can install ruby-build as a plugin:
+> ```sh
+> git clone https://github.com/rbenv/ruby-build.git "$(rbenv root)"/plugins/ruby-build
+> ```
+
+Set a Ruby version to finish installation and start using Ruby:
+```sh
+rbenv global 3.1.2   # set the default Ruby version for this machine
+# or:
+rbenv local 3.1.2    # set the Ruby version for this directory
+```
+
+Alternatively to the `rbenv install` command, you can download and compile Ruby manually as a subdirectory of `~/.rbenv/versions`. An entry in that directory can also be a symlink to a Ruby version installed elsewhere on the filesystem.
+
+#### Installing Ruby gems
+
+Select a Ruby version for your project using `rbenv local 3.1.2`, for example. Then, proceed to install gems as you normally would:
+
+```sh
+gem install bundler
+```
+
+> [!NOTE]  
+> You _should not use sudo_ to install gems. Typically, the Ruby versions will be installed under your home directory and thus writeable by your user. If you get the “you don't have write permissions” error when installing gems, it's likely that your "system" Ruby version is still a global default. Change that with `rbenv global <version>` and try again.
+
+Check the location where gems are being installed with `gem env`:
+
+```sh
+gem env home
+# => ~/.rbenv/versions/<version>/lib/ruby/gems/...
+```
+
+#### Uninstalling Ruby versions
 
 As time goes on, Ruby versions you install will accumulate in your
 `~/.rbenv/versions` directory.
@@ -292,70 +171,14 @@ As time goes on, Ruby versions you install will accumulate in your
 To remove old Ruby versions, simply `rm -rf` the directory of the
 version you want to remove. You can find the directory of a particular
 Ruby version with the `rbenv prefix` command, e.g. `rbenv prefix
-1.8.7-p357`.
+2.7.0`.
 
 The [ruby-build][] plugin provides an `rbenv uninstall` command to
 automate the removal process.
 
 ## Command Reference
 
-Like `git`, the `rbenv` command delegates to subcommands based on its
+The main rbenv commands you need to know are:
-first argument. The most common subcommands are:
-
-### rbenv local
-
-Sets a local application-specific Ruby version by writing the version
-name to a `.ruby-version` file in the current directory. This version
-overrides the global version, and can be overridden itself by setting
-the `RBENV_VERSION` environment variable or with the `rbenv shell`
-command.
-
-    $ rbenv local 1.9.3-p327
-
-When run without a version number, `rbenv local` reports the currently
-configured local version. You can also unset the local version:
-
-    $ rbenv local --unset
-
-Previous versions of rbenv stored local version specifications in a
-file named `.rbenv-version`. For backwards compatibility, rbenv will
-read a local version specified in an `.rbenv-version` file, but a
-`.ruby-version` file in the same directory will take precedence.
-
-### rbenv global
-
-Sets the global version of Ruby to be used in all shells by writing
-the version name to the `~/.rbenv/version` file. This version can be
-overridden by an application-specific `.ruby-version` file, or by
-setting the `RBENV_VERSION` environment variable.
-
-    $ rbenv global 1.8.7-p352
-
-The special version name `system` tells rbenv to use the system Ruby
-(detected by searching your `$PATH`).
-
-When run without a version number, `rbenv global` reports the
-currently configured global version.
-
-### rbenv shell
-
-Sets a shell-specific Ruby version by setting the `RBENV_VERSION`
-environment variable in your shell. This version overrides
-application-specific versions and the global version.
-
-    $ rbenv shell jruby-1.7.1
-
-When run without a version number, `rbenv shell` reports the current
-value of `RBENV_VERSION`. You can also unset the shell version:
-
-    $ rbenv shell --unset
-
-Note that you'll need rbenv's shell integration enabled (step 3 of
-the installation instructions) in order to use this command. If you
-prefer not to use shell integration, you may simply set the
-`RBENV_VERSION` variable yourself:
-
-    $ export RBENV_VERSION=jruby-1.7.1
 
 ### rbenv versions
 
@@ -378,13 +201,61 @@ how it was set.
     $ rbenv version
     1.9.3-p327 (set by /Users/sam/.rbenv/version)
 
+### rbenv local
+
+Sets a local application-specific Ruby version by writing the version
+name to a `.ruby-version` file in the current directory. This version
+overrides the global version, and can be overridden itself by setting
+the `RBENV_VERSION` environment variable or with the `rbenv shell`
+command.
+
+    rbenv local 3.1.2
+
+When run without a version number, `rbenv local` reports the currently
+configured local version. You can also unset the local version:
+
+    rbenv local --unset
+
+### rbenv global
+
+Sets the global version of Ruby to be used in all shells by writing
+the version name to the `~/.rbenv/version` file. This version can be
+overridden by an application-specific `.ruby-version` file, or by
+setting the `RBENV_VERSION` environment variable.
+
+    rbenv global 3.1.2
+
+The special version name `system` tells rbenv to use the system Ruby
+(detected by searching your `$PATH`).
+
+When run without a version number, `rbenv global` reports the
+currently configured global version.
+
+### rbenv shell
+
+Sets a shell-specific Ruby version by setting the `RBENV_VERSION`
+environment variable in your shell. This version overrides
+application-specific versions and the global version.
+
+    rbenv shell jruby-1.7.1
+
+When run without a version number, `rbenv shell` reports the current
+value of `RBENV_VERSION`. You can also unset the shell version:
+
+    rbenv shell --unset
+
+Note that you'll need rbenv's shell integration enabled (step 3 of
+the installation instructions) in order to use this command. If you
+prefer not to use shell integration, you may simply set the
+`RBENV_VERSION` variable yourself:
+
+    export RBENV_VERSION=jruby-1.7.1
+
 ### rbenv rehash
 
-Installs shims for all Ruby executables known to rbenv (i.e.,
+Installs shims for all Ruby executables known to rbenv (`~/.rbenv/versions/*/bin/*`). Typically you do not need to run this command, as it will run automatically after installing gems.
-`~/.rbenv/versions/*/bin/*`). Run this command after you install a new
-version of Ruby, or install a gem that provides commands.
 
-    $ rbenv rehash
+    rbenv rehash
 
 ### rbenv which
 
@@ -396,26 +267,84 @@ you run the given command.
 
 ### rbenv whence
 
-Lists all Ruby versions with the given command installed.
+Lists all Ruby versions that contain the specified executable name.
 
     $ rbenv whence rackup
     1.9.3-p327
     jruby-1.7.1
     ree-1.8.7-2011.03
 
+## Environment variables
+
+You can affect how rbenv operates with the following settings:
+
+name | default | description
+-----|---------|------------
+`RBENV_VERSION` | | Specifies the Ruby version to be used.<br>Also see [`rbenv shell`](#rbenv-shell)
+`RBENV_ROOT` | `~/.rbenv` | Defines the directory under which Ruby versions and shims reside.<br>Also see `rbenv root`
+`RBENV_DEBUG` | | Outputs debug information.<br>Also as: `rbenv --debug <subcommand>`
+`RBENV_HOOK_PATH` | [_see wiki_][hooks] | Colon-separated list of paths searched for rbenv hooks.
+`RBENV_DIR` | `$PWD` | Directory to start searching for `.ruby-version` files.
+
+### How rbenv hooks into your shell
+
+`rbenv init` is a helper command to hook rbenv into a shell. This helper is part of the recommended installation instructions, but optional, as an experienced user can set up the following tasks manually. The `rbenv init` command has two modes of operation:
+
+1. `rbenv init`: made for humans, this command edits your shell initialization files on disk to add rbenv to shell startup. (Prior to rbenv 1.3.0, this mode only printed user instructions to the terminal, but did nothing else.)
+
+2. `rbenv init -`: made for machines, this command outputs a shell script suitable to be eval'd by the user's shell.
+
+When `rbenv init` is invoked from a bash shell, for example, it will add the following to the user's `~/.bashrc` or `~/.bash_profile`:
+
+```sh
+# Added by `rbenv init` on <DATE>
+eval "$(rbenv init - --no-rehash bash)"
+```
+
+You may add this line to your shell initialization files manually if you want to avoid running `rbenv init` as part of the setup process. Here is what the eval'd script does:
+
+0. Adds `rbenv` executable to PATH if necessary.
+
+1. Prepends `~/.rbenv/shims` directory to PATH. This is basically the only requirement for rbenv to function properly.
+
+2. Installs bash shell completion for rbenv commands.
+
+3. Regenerates rbenv shims. If this step slows down your shell startup, you can invoke `rbenv init -` with the `--no-rehash` flag.
+
+4. Installs the "sh" dispatcher. This bit is also optional, but allows rbenv and plugins to change variables in your current shell, making commands like `rbenv shell` possible.
+
+
+### Uninstalling rbenv
+
+The simplicity of rbenv makes it easy to temporarily disable it, or
+uninstall from the system.
+
+1. To **disable** rbenv managing your Ruby versions, simply comment or remove the `rbenv init` line from your shell startup configuration. This will remove rbenv shims directory from PATH, and future invocations like `ruby` will execute the system Ruby version, bypassing rbenv completely.
+
+   While disabled, `rbenv` will still be accessible on the command line, but your Ruby apps won't be affected by version switching.
+
+2. To completely **uninstall** rbenv, perform step (1) and then remove the rbenv root directory. This will **delete all Ruby versions** that were installed under `` `rbenv root`/versions/ ``:
+
+       rm -rf "$(rbenv root)"
+
+   If you've installed rbenv using a package manager, as a final step
+   perform the rbenv package removal:
+   - Homebrew: `brew uninstall rbenv`
+   - Debian, Ubuntu, and their derivatives: `sudo apt purge rbenv`
+   - Archlinux and its derivatives: `sudo pacman -R rbenv`
+
 ## Development
 
-The rbenv source code is [hosted on
+Tests are executed using [Bats](https://github.com/bats-core/bats-core):
-GitHub](https://github.com/sstephenson/rbenv). It's clean, modular,
-and easy to understand, even if you're not a shell hacker.
-
-Tests are executed using [Bats](https://github.com/sstephenson/bats):
 
     $ bats test
     $ bats test/<file>.bats
 
 Please feel free to submit pull requests and file bugs on the [issue
-tracker](https://github.com/sstephenson/rbenv/issues).
+tracker](https://github.com/rbenv/rbenv/issues).
 
 
-  [ruby-build]: https://github.com/sstephenson/ruby-build#readme
+  [ruby-build]: https://github.com/rbenv/ruby-build#readme
+  [hooks]: https://github.com/rbenv/rbenv/wiki/Authoring-plugins#rbenv-hooks
+  [alternatives]: https://github.com/rbenv/rbenv/wiki/Comparison-of-version-managers
+  [plugins]: https://github.com/rbenv/rbenv/wiki/Plugins

bin/ruby-local-exec

@@ -1,23 +0,0 @@
-#!/usr/bin/env bash
-#
-# `ruby-local-exec` is a drop-in replacement for the standard Ruby
-# shebang line:
-#
-#    #!/usr/bin/env ruby-local-exec
-#
-# Use it for scripts inside a project with an `.rbenv-version`
-# file. When you run the scripts, they'll use the project-specified
-# Ruby version, regardless of what directory they're run from. Useful
-# for e.g. running project tasks in cron scripts without needing to
-# `cd` into the project first.
-
-set -e
-export RBENV_DIR="${1%/*}"
-
-[ -n "$RBENV_SILENCE_WARNINGS" ] || {
-  echo "rbenv: \`ruby-local-exec' is deprecated and will be removed in the next release."
-  echo "       To upgrade: https://github.com/sstephenson/rbenv/wiki/ruby-local-exec"
-  echo
-} >&2
-
-exec ruby "$@"

completions/_rbenv

@@ -0,0 +1,13 @@
+#compdef rbenv
+
+_rbenv() {
+  local completions
+
+  if [ "${#words}" -eq 2 ]; then
+    completions=(${(f)"$(rbenv help --complete-commands "${words[2]}")"})
+    _describe 'rbenv commands' completions
+  else
+    completions="$(rbenv completions ${words[2,-2]})"
+    compadd - "${(ps:\n:)completions}"
+  fi
+}

completions/rbenv.bash

@@ -6,8 +6,8 @@ _rbenv() {
     COMPREPLY=( $(compgen -W "$(rbenv commands)" -- "$word") )
   else
     local words=("${COMP_WORDS[@]}")
-    unset words[0]
+    unset "words[0]"
-    unset words[$COMP_CWORD]
+    unset "words[$COMP_CWORD]"
     local completions=$(rbenv completions "${words[@]}")
     COMPREPLY=( $(compgen -W "$completions" -- "$word") )
   fi

completions/rbenv.fish

@@ -1,22 +0,0 @@
-function __fish_rbenv_needs_command
-  set cmd (commandline -opc)
-  if [ (count $cmd) -eq 1 -a $cmd[1] = 'rbenv' ]
-    return 0
-  end
-  return 1
-end
-
-function __fish_rbenv_using_command
-  set cmd (commandline -opc)
-  if [ (count $cmd) -gt 1 ]
-    if [ $argv[1] = $cmd[2] ]
-      return 0
-    end
-  end
-  return 1
-end
-
-complete -f -c rbenv -n '__fish_rbenv_needs_command' -a '(rbenv commands)'
-for cmd in (rbenv commands)
-  complete -f -c rbenv -n "__fish_rbenv_using_command $cmd" -a "(rbenv completions $cmd)"
-end

completions/rbenv.zsh

@@ -1,18 +0,0 @@
-if [[ ! -o interactive ]]; then
-    return
-fi
-
-compctl -K _rbenv rbenv
-
-_rbenv() {
-  local words completions
-  read -cA words
-
-  if [ "${#words}" -eq 2 ]; then
-    completions="$(rbenv commands)"
-  else
-    completions="$(rbenv completions ${words[2,-2]})"
-  fi
-
-  reply=("${(ps:\n:)completions}")
-}

libexec/rbenv

@@ -1,6 +1,5 @@
 #!/usr/bin/env bash
 set -e
-export -n CDPATH
 
 if [ "$1" = "--debug" ]; then
   export RBENV_DEBUG=1
@@ -8,45 +7,19 @@ if [ "$1" = "--debug" ]; then
 fi
 
 if [ -n "$RBENV_DEBUG" ]; then
-  export PS4='+ [${BASH_SOURCE##*/}:${LINENO}] '
+  # https://web.archive.org/web/20221105082147/https://wiki-dev.bash-hackers.org/scripting/debuggingtips#making_xtrace_more_useful
+  export PS4='+(${BASH_SOURCE}:${LINENO}): ${FUNCNAME[0]:+${FUNCNAME[0]}(): }'
   set -x
 fi
 
-if enable -f "${0%/*}"/../libexec/rbenv-realpath.dylib realpath 2>/dev/null; then
+abort() {
-  abs_dirname() {
+  { if [ "$#" -eq 0 ]; then cat -
-    local path="$(realpath "$1")"
+    else echo "rbenv: $*"
-    echo "${path%/*}"
+    fi
-  }
+  } >&2
-else
-  if [ -n "$RBENV_NATIVE_EXT" ]; then
-    echo "rbenv: failed to load \`realpath' builtin" >&2
-    exit 1
-  fi
-READLINK=$(type -p greadlink readlink | head -1)
-if [ -z "$READLINK" ]; then
-  echo "rbenv: cannot find readlink - are you missing GNU coreutils?" >&2
   exit 1
-fi
-
-resolve_link() {
-  $READLINK "$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"
-}
-fi
-
 if [ -z "${RBENV_ROOT}" ]; then
   RBENV_ROOT="${HOME}/.rbenv"
 else
@@ -55,35 +28,65 @@ fi
 export RBENV_ROOT
 
 if [ -z "${RBENV_DIR}" ]; then
-  RBENV_DIR="$(pwd)"
+  RBENV_DIR="$PWD"
 else
-  cd "$RBENV_DIR" 2>/dev/null || {
+  [[ $RBENV_DIR == /* ]] || RBENV_DIR="$PWD/$RBENV_DIR"
-    echo "rbenv: cannot change working directory to \`$RBENV_DIR'"
+  cd "$RBENV_DIR" 2>/dev/null || abort "cannot change working directory to \`$RBENV_DIR'"
-    exit 1
+  RBENV_DIR="$PWD"
-  } >&2
-  RBENV_DIR="$(pwd)"
   cd "$OLDPWD"
 fi
 export RBENV_DIR
 
+[ -n "$RBENV_ORIG_PATH" ] || export RBENV_ORIG_PATH="$PATH"
+
+canonicalize() {
+  local readlink resolved_path
+  if readlink="$(type -P greadlink)" || readlink="$(type -P readlink)"; then
+    # happy path: GNU & BSD readlink, macOS 12.3+
+    if resolved_path="$("$readlink" -f "$1" 2>/dev/null)"; then
+      printf "%s\n" "$resolved_path"
+      return 0
+    fi
+    # likely macOS < 12.3 with old readlink
+    local path="$1"
+    while [ -L "$path" ]; do
+      resolved_path="$("$readlink" "$path" 2>/dev/null)"
+      [[ $resolved_path == /* ]] || resolved_path="$(cd "${path%/*}/${resolved_path%/*}" && pwd)/${resolved_path##*/}"
+      path="$resolved_path"
+    done
+    printf "%s\n" "$path"
+    return 0
+  fi
+  # fail if the argument is a symlink and was not canonicalized
+  [ ! -L "$1" ] || return 1
+}
 
 shopt -s nullglob
 
-bin_path="$(abs_dirname "$0")"
+# all this trouble just to find out where rbenv's executables live
+rbenv_bin="${BASH_SOURCE:-$0}"
+if libexec_dir="$(canonicalize "$rbenv_bin")"; then
+  libexec_dir="${libexec_dir%/*}"
+else
+  libexec_dir="${rbenv_bin%/*}"
+  [ "$libexec_dir" != "." ] || libexec_dir="$PWD"
+fi
+
 for plugin_bin in "${RBENV_ROOT}/plugins/"*/bin; do
   PATH="${plugin_bin}:${PATH}"
 done
-export PATH="${bin_path}:${PATH}"
+export PATH="${libexec_dir}:${PATH}"
 
 RBENV_HOOK_PATH="${RBENV_HOOK_PATH}:${RBENV_ROOT}/rbenv.d"
-if [ "${bin_path%/*}" != "$RBENV_ROOT" ]; then
+if [ ! "${libexec_dir%/*}"/rbenv.d -ef "$RBENV_ROOT"/rbenv.d ]; then
   # Add rbenv's own `rbenv.d` unless rbenv was cloned to RBENV_ROOT
-  RBENV_HOOK_PATH="${RBENV_HOOK_PATH}:${bin_path%/*}/rbenv.d"
+  RBENV_HOOK_PATH="${RBENV_HOOK_PATH}:${libexec_dir%/*}/rbenv.d"
 fi
-RBENV_HOOK_PATH="${RBENV_HOOK_PATH}:/usr/local/etc/rbenv.d:/etc/rbenv.d:/usr/lib/rbenv/hooks"
+RBENV_HOOK_PATH="${RBENV_HOOK_PATH}:/usr/etc/rbenv.d:/usr/local/etc/rbenv.d:/etc/rbenv.d:/usr/lib/rbenv/hooks"
 for plugin_hook in "${RBENV_ROOT}/plugins/"*/etc/rbenv.d; do
   RBENV_HOOK_PATH="${RBENV_HOOK_PATH}:${plugin_hook}"
 done
+RBENV_HOOK_PATH="${RBENV_HOOK_PATH#:}"
 export RBENV_HOOK_PATH
 
 shopt -u nullglob
@@ -91,20 +94,36 @@ shopt -u nullglob
 
 command="$1"
 case "$command" in
-"" | "-h" | "--help" )
+"" )
-  echo -e "$(rbenv---version)\n$(rbenv-help)" >&2
+  { rbenv---version
+    rbenv-help
+  } | abort
   ;;
-"-v" )
+-v | --version )
   exec rbenv---version
   ;;
+-h | --help )
+  exec rbenv-help
+  ;;
 * )
-  command_path="$(command -v "rbenv-$command" || true)"
+  command_path="$(type -P "rbenv-$command" || true)"
   if [ -z "$command_path" ]; then
-    echo "rbenv: no such command \`$command'" >&2
+    if [ "$command" == "shell" ]; then
-    exit 1
+      abort "shell integration not enabled. Run \`rbenv init' for instructions."
+    else
+      abort "no such command \`$command'"
+    fi
   fi
 
   shift 1
-  exec "$command_path" "$@"
+  if [ "$1" = --help ]; then
+    if [[ "$command" == "sh-"* ]]; then
+      echo "rbenv help \"$command\""
+    else
+      exec rbenv-help "$command"
+    fi
+  else
+    exec "$command_path" "$@"
+  fi
   ;;
 esac

libexec/rbenv---version

@@ -12,9 +12,10 @@
 set -e
 [ -n "$RBENV_DEBUG" ] && set -x
 
-version="0.4.0"
+version="1.3.2"
+git_revision=""
 
-if cd "$RBENV_ROOT" 2>/dev/null; then
+if cd "${BASH_SOURCE%/*}" 2>/dev/null && git remote -v 2>/dev/null | grep -q rbenv; then
   git_revision="$(git describe --tags HEAD 2>/dev/null || true)"
   git_revision="${git_revision#v}"
 fi

libexec/rbenv-commands

@@ -1,6 +1,12 @@
 #!/usr/bin/env bash
 # Summary: List all available rbenv commands
 # Usage: rbenv commands [--sh|--no-sh]
+#
+# List names of all rbenv commands, including 3rd-party ones found in the
+# PATH or in rbenv plugins. With `--sh`, list only shell commands.
+#
+# This functionality is mainly meant for scripting. To see usage help for
+# rbenv, run `rbenv help`.
 
 set -e
 [ -n "$RBENV_DEBUG" ] && set -x
@@ -12,32 +18,33 @@ if [ "$1" = "--complete" ]; then
   exit
 fi
 
+exclude_shell=
+command_prefix="rbenv-"
+
 if [ "$1" = "--sh" ]; then
-  sh=1
+  command_prefix="rbenv-sh-"
   shift
 elif [ "$1" = "--no-sh" ]; then
-  nosh=1
+  exclude_shell=1
   shift
 fi
 
-IFS=: paths=($PATH)
-
 shopt -s nullglob
 
-{ for path in "${paths[@]}"; do
+{
-    for command in "${path}/rbenv-"*; do
+  PATH_remain="$PATH"
-      command="${command##*rbenv-}"
+  # traverse PATH to find "rbenv-" prefixed commands
-      if [ -n "$sh" ]; then
+  while true; do
-        if [ ${command:0:3} = "sh-" ]; then
+    path="${PATH_remain%%:*}"
-          echo ${command##sh-}
+    if [ -n "$path" ]; then
+      for rbenv_command in "${path}/${command_prefix}"*; do
+        rbenv_command="${rbenv_command##*rbenv-}"
+        if [[ -z $exclude_shell || $rbenv_command != sh-* ]]; then
+          echo "${rbenv_command##sh-}"
         fi
-      elif [ -n "$nosh" ]; then
+      done
-        if [ ${command:0:3} != "sh-" ]; then
+    fi
-          echo ${command##sh-}
+    [[ $PATH_remain == *:* ]] || break
-        fi
+    PATH_remain="${PATH_remain#*:}"
-      else
-        echo ${command##sh-}
-      fi
-    done
   done
 } | sort | uniq

libexec/rbenv-completions

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# Usage: rbenv completions <command> [arg1 arg2...]
+# Usage: rbenv completions <command> [<args>...]
 
 set -e
 [ -n "$RBENV_DEBUG" ] && set -x
@@ -10,7 +10,16 @@ if [ -z "$COMMAND" ]; then
   exit 1
 fi
 
-COMMAND_PATH="$(command -v "rbenv-$COMMAND" || command -v "rbenv-sh-$COMMAND")"
+# Provide rbenv completions
+if [ "$COMMAND" = "--complete" ]; then
+  exec rbenv-commands
+fi
+
+COMMAND_PATH="$(type -P "rbenv-$COMMAND" "rbenv-sh-$COMMAND" | head -n1)"
+
+# --help is provided automatically
+echo --help
+
 if grep -iE "^([#%]|--|//) provide rbenv completions" "$COMMAND_PATH" >/dev/null; then
   shift
   exec "$COMMAND_PATH" --complete "$@"

libexec/rbenv-exec

@@ -2,7 +2,7 @@
 #
 # Summary: Run an executable with the selected Ruby version
 #
-# Usage: rbenv exec <command> [arg1 arg2...]
+# Usage: rbenv exec <command> [<args>...]
 #
 # Runs an executable by first preparing PATH so that the selected Ruby
 # version's `bin' directory is at the front.
@@ -33,10 +33,9 @@ export RBENV_VERSION
 RBENV_COMMAND_PATH="$(rbenv-which "$RBENV_COMMAND")"
 RBENV_BIN_PATH="${RBENV_COMMAND_PATH%/*}"
 
-OLDIFS="$IFS"
+IFS=$'\n' read -d '' -r -a scripts <<<"$(rbenv-hooks exec)" || true
-IFS=$'\n' scripts=(`rbenv-hooks exec`)
-IFS="$OLDIFS"
 for script in "${scripts[@]}"; do
+  # shellcheck disable=SC1090
   source "$script"
 done
 

libexec/rbenv-global

@@ -27,8 +27,5 @@ RBENV_VERSION_FILE="${RBENV_ROOT}/version"
 if [ -n "$RBENV_VERSION" ]; then
   rbenv-version-file-write "$RBENV_VERSION_FILE" "$RBENV_VERSION"
 else
-  rbenv-version-file-read "$RBENV_VERSION_FILE" ||
+  rbenv-version-file-read "$RBENV_VERSION_FILE" || echo system
-  rbenv-version-file-read "${RBENV_ROOT}/global" ||
-  rbenv-version-file-read "${RBENV_ROOT}/default" ||
-  echo system
 fi

libexec/rbenv-help

@@ -15,9 +15,15 @@
 set -e
 [ -n "$RBENV_DEBUG" ] && set -x
 
+# Provide rbenv completions
+if [ "$1" = "--complete" ]; then
+  echo --usage
+  exec rbenv-commands
+fi
+
 command_path() {
   local command="$1"
-  command -v rbenv-"$command" || command -v rbenv-sh-"$command" || true
+  type -P rbenv-"$command" rbenv-sh-"$command" | head -n1
 }
 
 extract_initial_comment_block() {
@@ -36,7 +42,15 @@ extract_initial_comment_block() {
 }
 
 collect_documentation() {
-  $(type -p gawk awk | head -1) '
+  local awk
+  awk="$(type -P gawk)" || awk="$(type -P awk)" || true
+  if [ -z "$awk" ]; then
+    echo "rbenv: cannot find awk" >&2
+    return 1
+  fi
+
+  # shellcheck disable=SC2016
+  "$awk" '
     /^Summary:/ {
       summary = substr($0, 10)
       next
@@ -80,7 +94,8 @@ collect_documentation() {
 }
 
 documentation_for() {
-  local filename="$(command_path "$1")"
+  local filename
+  filename="$(command_path "$1")"
   if [ -n "$filename" ]; then
     extract_initial_comment_block < "$filename" | collect_documentation
   fi
@@ -108,7 +123,7 @@ print_help() {
   eval "$(documentation_for "$command")"
   [ -n "$help" ] || help="$summary"
 
-  if [ -n "$usage" -o -n "$summary" ]; then
+  if [ -n "$usage" ] || [ -n "$summary" ]; then
     if [ -n "$usage" ]; then
       echo "$usage"
     else
@@ -129,9 +144,41 @@ print_usage() {
   local command="$1"
   local summary usage help
   eval "$(documentation_for "$command")"
-  [ -z "$usage" ] || echo "$usage"
+  if [ -n "$usage" ]; then
+    echo "$usage"
+  else
+    echo "Usage: rbenv ${command}"
+  fi
 }
 
+if [ "$1" = "--complete-commands" ]; then
+  command_prefix="${2:-}"
+  seen=()
+  shopt -s nullglob
+  PATH_remain="$PATH"
+  # traverse PATH to find "rbenv-" prefixed commands
+  while true; do
+    path="${PATH_remain%%:*}"
+    if [ -n "$path" ]; then
+      for rbenv_command in "${path}/rbenv-"*; do
+        command_name="${rbenv_command##*/}"
+        command_name="${command_name#rbenv-}"
+        command_name="${command_name#sh-}"
+        [[ $command_name == "${command_prefix}"* ]] || continue
+        [[ " ${seen[*]} " != *" ${command_name} "* ]] || continue
+        seen+=("$command_name")
+        summary=""
+        eval "$(extract_initial_comment_block < "$rbenv_command" | collect_documentation)"
+        [ -n "$summary" ] || continue
+        printf "%s:%s\n" "$command_name" "$summary"
+      done
+    fi
+    [[ $PATH_remain == *:* ]] || break
+    PATH_remain="${PATH_remain#*:}"
+  done
+  exit 0
+fi
+
 unset usage
 if [ "$1" = "--usage" ]; then
   usage="1"
@@ -139,14 +186,20 @@ if [ "$1" = "--usage" ]; then
 fi
 
 if [ -z "$1" ] || [ "$1" == "rbenv" ]; then
-  echo "Usage: rbenv <command> [<args>]"
+  if [ -z "$usage" ] && [ -t 1 ] && type -P man >/dev/null; then
-  [ -z "$usage" ] || exit
+    MANPATH="${BASH_SOURCE%/*}/../share/man:$MANPATH" exec man rbenv
+  fi
+  echo "Usage: rbenv <command> [<args>...]"
+  [ -n "$usage" ] && exit
   echo
-  echo "Some useful rbenv commands are:"
+  echo "Commands to manage available Ruby versions:"
-  print_summaries commands local global shell install uninstall rehash version versions which whence
+  print_summaries versions install uninstall rehash
+  echo
+  echo "Commands to view or change the current Ruby version:"
+  print_summaries version local global shell
   echo
   echo "See \`rbenv help <command>' for information on a specific command."
-  echo "For full documentation, see: https://github.com/sstephenson/rbenv#readme"
+  echo "For full documentation, see: https://github.com/rbenv/rbenv#readme"
 else
   command="$1"
   if [ -n "$(command_path "$command")" ]; then

libexec/rbenv-hooks

@@ -9,6 +9,8 @@ set -e
 if [ "$1" = "--complete" ]; then
   echo exec
   echo rehash
+  echo version-name
+  echo version-origin
   echo which
   exit
 fi
@@ -19,42 +21,12 @@ if [ -z "$RBENV_COMMAND" ]; then
   exit 1
 fi
 
-if ! enable -f "${BASH_SOURCE%/*}"/rbenv-realpath.dylib realpath 2>/dev/null; then
+IFS=: read -r -a hook_paths <<<"$RBENV_HOOK_PATH"
-  if [ -n "$RBENV_NATIVE_EXT" ]; then
-    echo "rbenv: failed to load \`realpath' builtin" >&2
-    exit 1
-  fi
-READLINK=$(type -p greadlink readlink | head -1)
-if [ -z "$READLINK" ]; then
-  echo "rbenv: cannot find readlink - are you missing GNU coreutils?" >&2
-  exit 1
-fi
-
-resolve_link() {
-  $READLINK "$1"
-}
-
-realpath() {
-  local cwd="$(pwd)"
-  local path="$1"
-
-  while [ -n "$path" ]; do
-    cd "${path%/*}"
-    local name="${path##*/}"
-    path="$(resolve_link "$name" || true)"
-  done
-
-  echo "$(pwd)/$name"
-  cd "$cwd"
-}
-fi
-
-IFS=: hook_paths=($RBENV_HOOK_PATH)
 
 shopt -s nullglob
 for path in "${hook_paths[@]}"; do
   for script in "$path/$RBENV_COMMAND"/*.bash; do
-    realpath "$script"
+    echo "$script"
   done
 done
 shopt -u nullglob

libexec/rbenv-init

@@ -1,97 +1,178 @@
 #!/usr/bin/env bash
 # Summary: Configure the shell environment for rbenv
-# Usage: eval "$(rbenv init - [--no-rehash] [<shell>])"
+# Usage: rbenv init [<shells>...]
+#        rbenv init - [--no-rehash] [<shell>]
+#
+# Modifies shell initialization files to bootstrap rbenv functionality.
+# Typically, this will add a line that eval's the output of `rbenv init -`.
+# If no shells are named by arguments, the current shell will be detected
+# by inspecting the parent process. If a shell is already configured for
+# rbenv, the init command does nothing and exits with zero status.
+#
+# In the `rbenv init -` mode, this outputs a script to be eval'd in the
+# current shell. Most importantly, that script prepends the rbenv shims
+# directory to the PATH environment variable. To aid interactive shells,
+# the script also installs the magic `rbenv()` shell function and loads
+# shell completions for rbenv commands.
 
 set -e
 [ -n "$RBENV_DEBUG" ] && set -x
 
-print=""
+# Provide rbenv completions
-no_rehash=""
+if [ "$1" = "--complete" ]; then
-for args in "$@"
+  echo -
-do
+  echo --no-rehash
-  if [ "$args" = "-" ]; then
+  echo bash
-    print=1
+  echo fish
-    shift
+  echo ksh
-  fi
+  echo zsh
-
+  exit
-  if [ "$args" = "--no-rehash" ]; then
-    no_rehash=1
-    shift
-  fi
-done
-
-shell="$1"
-if [ -z "$shell" ]; then
-  shell="$(ps c -p "$PPID" -o 'ucomm=' 2>/dev/null || true)"
-  shell="${shell##-}"
-  shell="${shell%% *}"
-  shell="$(basename "${shell:-$SHELL}")"
 fi
 
-root="${0%/*}/.."
+print=""
-
+no_rehash=""
-if [ -z "$print" ]; then
+shells=()
-  case "$shell" in
+while [ $# -gt 0 ]; do
-  bash )
+  case "$1" in
-    profile='~/.bash_profile'
+  "-" )
+    print=1
     ;;
-  zsh )
+  "--no-rehash" )
-    profile='~/.zshrc'
+    no_rehash=1
-    ;;
-  ksh )
-    profile='~/.profile'
-    ;;
-  fish )
-    profile='~/.config/fish/config.fish'
     ;;
   * )
-    profile='your profile'
+    shells+=("$1")
     ;;
   esac
+  shift
+done
 
-  { echo "# Load rbenv automatically by adding"
+if [ "${#shells[@]}" -eq 0 ]; then
-    echo "# the following to ${profile}:"
+  shell="$(ps -p "$PPID" -o 'args=' 2>/dev/null || true)"
-    echo
+  shell="${shell%% *}"
+  shell="${shell##-}"
+  shell="${shell:-$SHELL}"
+  shell="${shell##*/}"
+  shells=("${shell%%-*}")
+fi
+
+root="${BASH_SOURCE:-$0}"
+root="${root%/*}"
+root="${root%/*}"
+
+rbenv_in_path=true
+if [ -n "$RBENV_ORIG_PATH" ]; then
+  PATH="$RBENV_ORIG_PATH" type -P rbenv >/dev/null || rbenv_in_path=""
+fi
+
+if [ -z "$print" ]; then
+  display_path() {
+    if [ "${1/#$HOME\/}" != "$1" ]; then
+      # shellcheck disable=SC2088
+      printf '~/%s' "${1/#$HOME\/}"
+    else
+      printf '%s' "$1"
+    fi
+  }
+
+  rbenv_command=rbenv
+  if [ -z "$rbenv_in_path" ]; then
+    rbenv_command="$(display_path "$root/bin/rbenv")"
+  fi
+
+  color_start=""
+  color_end=""
+  if [ -t 1 ]; then
+    color_start=$'\e[33;1m'
+    color_end=$'\e[m'
+  fi
+
+  write_config() {
+    if grep -q "rbenv init" "$1" 2>/dev/null; then
+      printf 'skipping %s%s%s: already configured for rbenv.\n' "$color_start" "$(display_path "$1")" "$color_end"
+      return 0
+    fi
+    mkdir -p "${1%/*}"
+    # shellcheck disable=SC2016
+    printf '\n# Added by `rbenv init` on %s\n%s\n' "$(date)" "$2" >> "$1"
+    printf 'writing %s%s%s: now configured for rbenv.\n' "$color_start" "$(display_path "$1")" "$color_end"
+  }
+
+  status=0
+  for shell in "${shells[@]}"; do
     case "$shell" in
+    bash )
+      if [ -f ~/.bashrc ] && [ ! -f ~/.bash_profile ]; then
+        profile="$HOME/.bashrc"
+      else
+        # shellcheck disable=SC2012
+        profile="$(ls ~/.bash_profile ~/.bash_login ~/.profile 2>/dev/null | head -n1)"
+        [ -n "$profile" ] || profile="$HOME/.bash_profile"
+      fi
+      write_config "$profile" \
+        "eval \"\$($rbenv_command init - --no-rehash bash)\""
+      ;;
+    zsh )
+      # check zshrc for backward compatibility with older rbenv init
+      if grep -q rbenv "${ZDOTDIR:-$HOME}/.zshrc" 2>/dev/null; then
+        profile="${ZDOTDIR:-$HOME}/.zshrc"
+      else
+        profile="${ZDOTDIR:-$HOME}/.zprofile"
+      fi
+      write_config "$profile" \
+        "eval \"\$($rbenv_command init - --no-rehash zsh)\""
+      ;;
+    ksh | ksh93 | mksh )
+      # There are two implementations of Korn shell: AT&T (ksh93) and Mir (mksh).
+      # Systems may have them installed under those names, or as ksh, so those
+      # are recognized here. The obsolete ksh88 (subsumed by ksh93) and pdksh
+      # (subsumed by mksh) are not included, since they are unlikely to still
+      # be in use as interactive shells anywhere.
+      write_config "$HOME/.profile" \
+        "eval \"\$($rbenv_command init - ksh)\""
+      ;;
     fish )
-      echo 'status --is-interactive; and . (rbenv init -|psub)'
+      write_config "${XDG_CONFIG_HOME:-$HOME/.config}/fish/config.fish" \
+        "status --is-interactive; and $rbenv_command init - --no-rehash fish | source"
       ;;
     * )
-      echo 'eval "$(rbenv init -)"'
+      printf 'unsupported shell: "%s"\n' "$shell" >&2
+      status=1
       ;;
     esac
-    echo
+  done
-  } >&2
+  exit $status
-
-  exit 1
 fi
 
 mkdir -p "${RBENV_ROOT}/"{shims,versions}
 
+shell="${shells[0]}"
 case "$shell" in
 fish )
-  echo "setenv PATH '${RBENV_ROOT}/shims' \$PATH"
+  [ -n "$rbenv_in_path" ] || printf "set -gx PATH '%s/bin' \$PATH\n" "$root"
-  echo "setenv RBENV_SHELL $shell"
+  printf "set -gx PATH '%s/shims' \$PATH\n" "$RBENV_ROOT"
+  printf 'set -gx RBENV_SHELL %s\n' "$shell"
 ;;
 * )
-  echo 'export PATH="'${RBENV_ROOT}'/shims:${PATH}"'
+  # shellcheck disable=SC2016
-  echo "export RBENV_SHELL=$shell"
+  [ -n "$rbenv_in_path" ] || printf 'export PATH="%s/bin:${PATH}"\n' "$root"
+  # shellcheck disable=SC2016
+  printf 'export PATH="%s/shims:${PATH}"\n' "$RBENV_ROOT"
+  printf 'export RBENV_SHELL=%s\n' "$shell"
+
+  completion="${root}/completions/rbenv.${shell}"
+  if [ -r "$completion" ]; then
+    printf "source '%s'\n" "$completion"
+  fi
 ;;
 esac
 
-completion="${root}/completions/rbenv.${shell}"
-if [ -r "$completion" ]; then
-  case "$shell" in
-  fish ) echo ". '$completion'" ;;
-  *    ) echo "source '$completion'" ;;
-  esac
-fi
-
 if [ -z "$no_rehash" ]; then
-  echo 'rbenv rehash 2>/dev/null'
+  echo 'command rbenv rehash 2>/dev/null'
 fi
 
-commands=(`rbenv-commands --sh`)
+IFS=$'\n' read -d '' -r -a commands <<<"$(rbenv-commands --sh)" || true
+
 case "$shell" in
 fish )
   cat <<EOS
@@ -101,14 +182,14 @@ function rbenv
 
   switch "\$command"
   case ${commands[*]}
-    eval (rbenv "sh-\$command" \$argv)
+    rbenv "sh-\$command" \$argv|source
   case '*'
     command rbenv "\$command" \$argv
   end
 end
 EOS
   ;;
-ksh )
+ksh | ksh93 | mksh )
   cat <<EOS
 function rbenv {
   typeset command
@@ -125,14 +206,14 @@ esac
 if [ "$shell" != "fish" ]; then
 IFS="|"
 cat <<EOS
-  command="\$1"
+  command="\${1:-}"
   if [ "\$#" -gt 0 ]; then
     shift
   fi
 
   case "\$command" in
   ${commands[*]})
-    eval "\`rbenv "sh-\$command" "\$@"\`";;
+    eval "\$(rbenv "sh-\$command" "\$@")";;
   *)
     command rbenv "\$command" "\$@";;
   esac

libexec/rbenv-local

@@ -15,10 +15,6 @@
 # `RBENV_VERSION' environment variable takes precedence over local
 # and global versions.
 #
-# For backwards compatibility, rbenv will also read version
-# specifications from `.rbenv-version' files, but a `.ruby-version'
-# file in the same directory takes precedence.
-#
 # <version> should be a string matching a Ruby version known to rbenv.
 # The special version string `system' will use your default system Ruby.
 # Run `rbenv versions' for a list of available Ruby versions.
@@ -36,20 +32,14 @@ fi
 RBENV_VERSION="$1"
 
 if [ "$RBENV_VERSION" = "--unset" ]; then
-  rm -f .ruby-version .rbenv-version
+  rm -f .ruby-version
 elif [ -n "$RBENV_VERSION" ]; then
-  previous_file="$(RBENV_VERSION= rbenv-version-origin || true)"
   rbenv-version-file-write .ruby-version "$RBENV_VERSION"
-  if [ "$previous_file" -ef .rbenv-version ]; then
-    rm -f .rbenv-version
-    { echo "rbenv: removed existing \`.rbenv-version' file and migrated"
-      echo "       local version specification to \`.ruby-version' file"
-    } >&2
-  fi
 else
-  rbenv-version-file-read .ruby-version ||
+  if version_file="$(rbenv-version-file "$PWD")"; then
-  rbenv-version-file-read .rbenv-version ||
+    rbenv-version-file-read "$version_file"
-  { echo "rbenv: no local version configured for this directory"
+  else
+    echo "rbenv: no local version configured for this directory" >&2
     exit 1
-  } >&2
+  fi
 fi

libexec/rbenv-prefix

@@ -22,9 +22,10 @@ elif [ -z "$RBENV_VERSION" ]; then
 fi
 
 if [ "$RBENV_VERSION" = "system" ]; then
-  if RUBY_PATH="$(rbenv-which ruby 2>/dev/null)"; then
+  if RUBY_PATH="$(rbenv-which ruby)"; then
     RUBY_PATH="${RUBY_PATH%/*}"
-    echo "${RUBY_PATH%/bin}"
+    RBENV_PREFIX_PATH="${RUBY_PATH%/bin}"
+    echo "${RBENV_PREFIX_PATH:-/}"
     exit
   else
     echo "rbenv: system version not found in PATH" >&2

libexec/rbenv-rehash

@@ -1,5 +1,16 @@
 #!/usr/bin/env bash
-# Summary: Rehash rbenv shims (run this after installing executables)
+# Summary: Regenerate rbenv shims
+#
+# Regenerate shims for every Ruby executable in `$RBENV_ROOT/versions/*/bin'
+# and write them to the `$RBENV_ROOT/shims' directory. A shell environment
+# properly set up for rbenv will have this shims directory in PATH, which is
+# the core mechanism for Ruby version switching.
+#
+# Running rbenv rehash should only be necessary after installing new Ruby
+# versions or gems. Note that this is sometimes done automatically: the
+# `rbenv install' command from the ruby-build plugin runs rehash after
+# every successful installation, and a RubyGems plugin that ships with
+# rbenv runs rehash after every `gem install' command.
 
 set -e
 [ -n "$RBENV_DEBUG" ] && set -x
@@ -16,7 +27,7 @@ mkdir -p "$SHIM_PATH"
 # to stderr and exit with a non-zero status.
 set -o noclobber
 { echo > "$PROTOTYPE_SHIM_PATH"
-} 2>/dev/null ||
+} 2>| /dev/null ||
 { if [ -w "$SHIM_PATH" ]; then
     echo "rbenv: cannot rehash: $PROTOTYPE_SHIM_PATH exists"
   else
@@ -34,6 +45,21 @@ remove_prototype_shim() {
   rm -f "$PROTOTYPE_SHIM_PATH"
 }
 
+# Locates rbenv as found in the user's PATH. Otherwise, returns an
+# absolute path to the rbenv executable itself.
+rbenv_path() {
+  local found
+  found="$(PATH="$RBENV_ORIG_PATH" type -P rbenv)"
+  if [[ $found == /* ]]; then
+    echo "$found"
+  elif [[ -n "$found" ]]; then
+    echo "$PWD/${found#./}"
+  else
+    # Assume rbenv isn't in PATH.
+    echo "${BASH_SOURCE%/*}/rbenv"
+  fi
+}
+
 # The prototype shim file is a script that re-execs itself, passing
 # its filename and any arguments to `rbenv exec`. This file is
 # hard-linked for every executable and then removed. The linking
@@ -61,7 +87,7 @@ if [ "\$program" = "ruby" ]; then
 fi
 
 export RBENV_ROOT="$RBENV_ROOT"
-exec "$(command -v rbenv)" exec "\$program" "\$@"
+exec "$(rbenv_path)" exec "\$program" "\$@"
 SH
   chmod +x "$PROTOTYPE_SHIM_PATH"
 }
@@ -81,10 +107,18 @@ remove_outdated_shims() {
 
 # List basenames of executables for every Ruby version
 list_executable_names() {
-  local file
+  local version file
-  for file in "$RBENV_ROOT"/versions/*/bin/*; do
+  rbenv-versions --bare --skip-aliases | \
-    echo "${file##*/}"
+  while read -r version; do
+    for file in "${RBENV_ROOT}/versions/${version}/bin/"*; do
+      echo "${file##*/}"
+    done
   done
+  if [ -n "$GEM_HOME" ]; then
+    for file in "$GEM_HOME"/bin/*; do
+      echo "${file##*/}"
+    done
+  fi
 }
 
 # The basename of each argument passed to `make_shims` will be
@@ -94,23 +128,21 @@ make_shims() {
   local file shim
   for file; do
     shim="${file##*/}"
-    register_shim "$shim"
+    registered_shims+=("$shim")
   done
 }
 
-registered_shims=" "
-
 # Registers the name of a shim to be generated.
 register_shim() {
-  registered_shims="${registered_shims}${1} "
+  registered_shims+=("$1")
 }
 
 # Install all the shims registered via `make_shims` or `register_shim` directly.
 install_registered_shims() {
   local shim file
-  for shim in $registered_shims; do
+  for shim in "${registered_shims[@]}"; do
     file="${SHIM_PATH}/${shim}"
-    [ -e "$file" ] || ln -f "$PROTOTYPE_SHIM_PATH" "$file"
+    [ -e "$file" ] || cp "$PROTOTYPE_SHIM_PATH" "$file"
   done
 }
 
@@ -120,8 +152,9 @@ install_registered_shims() {
 # removed.
 remove_stale_shims() {
   local shim
+  local known_shims=" ${registered_shims[*]} "
   for shim in "$SHIM_PATH"/*; do
-    if [[ "$registered_shims" != *" ${shim##*/} "* ]]; then
+    if [[ "$known_shims" != *" ${shim##*/} "* ]]; then
       rm -f "$shim"
     fi
   done
@@ -133,15 +166,13 @@ shopt -s nullglob
 # executables.
 create_prototype_shim
 remove_outdated_shims
-make_shims $(list_executable_names | sort -u)
+# shellcheck disable=SC2207
-
+registered_shims=( $(list_executable_names | sort -u) )
 
 # Allow plugins to register shims.
-OLDIFS="$IFS"
+IFS=$'\n' read -d '' -r -a scripts <<<"$(rbenv-hooks rehash)" || true
-IFS=$'\n' scripts=(`rbenv-hooks rehash`)
-IFS="$OLDIFS"
-
 for script in "${scripts[@]}"; do
+  # shellcheck disable=SC1090
   source "$script"
 done
 

libexec/rbenv-root

@@ -1,3 +1,3 @@
 #!/usr/bin/env bash
 # Summary: Display the root directory where versions and shims are kept
-echo $RBENV_ROOT
+echo "$RBENV_ROOT"

libexec/rbenv-sh-shell

@@ -3,6 +3,7 @@
 # Summary: Set or show the shell-specific Ruby version
 #
 # Usage: rbenv shell <version>
+#        rbenv shell -
 #        rbenv shell --unset
 #
 # Sets a shell-specific Ruby version by setting the `RBENV_VERSION'
@@ -12,6 +13,11 @@
 # <version> should be a string matching a Ruby version known to rbenv.
 # The special version string `system' will use your default system Ruby.
 # Run `rbenv versions' for a list of available Ruby versions.
+#
+# When `-` is passed instead of the version string, the previously set
+# version will be restored. With `--unset`, the `RBENV_VERSION`
+# environment variable gets unset, restoring the environment to the
+# state before the first `rbenv shell` call.
 
 set -e
 [ -n "$RBENV_DEBUG" ] && set -x
@@ -31,7 +37,7 @@ if [ -z "$version" ]; then
     echo "rbenv: no shell-specific version configured" >&2
     exit 1
   else
-    echo "echo \"\$RBENV_VERSION\""
+    echo 'echo "$RBENV_VERSION"'
     exit
   fi
 fi
@@ -39,25 +45,99 @@ fi
 if [ "$version" = "--unset" ]; then
   case "$shell" in
   fish )
+    echo 'set -gu RBENV_VERSION_OLD "$RBENV_VERSION"'
     echo "set -e RBENV_VERSION"
     ;;
-  * )
+  zsh )
+    echo "typeset -g RBENV_VERSION_OLD=\"\${RBENV_VERSION-}\""
     echo "unset RBENV_VERSION"
     ;;
+  * )
+    echo 'RBENV_VERSION_OLD="${RBENV_VERSION-}"'
+    echo "unset RBENV_VERSION"
+    ;;
+  esac
+  exit
+fi
+
+if [ "$version" = "-" ]; then
+  case "$shell" in
+  fish )
+    cat <<EOS
+if set -q RBENV_VERSION_OLD
+  if [ -n "\$RBENV_VERSION_OLD" ]
+    set RBENV_VERSION_OLD_ "\$RBENV_VERSION"
+    set -gx RBENV_VERSION "\$RBENV_VERSION_OLD"
+    set -gu RBENV_VERSION_OLD "\$RBENV_VERSION_OLD_"
+    set -e RBENV_VERSION_OLD_
+  else
+    set -gu RBENV_VERSION_OLD "\$RBENV_VERSION"
+    set -e RBENV_VERSION
+  end
+else
+  echo "rbenv: RBENV_VERSION_OLD is not set" >&2
+  false
+end
+EOS
+    ;;
+  zsh )
+    cat <<EOS
+if [ -n "\${RBENV_VERSION_OLD+x}" ]; then
+  if [ -n "\$RBENV_VERSION_OLD" ]; then
+    local RBENV_VERSION_OLD_="\$RBENV_VERSION"
+    export RBENV_VERSION="\$RBENV_VERSION_OLD"
+    RBENV_VERSION_OLD="\$RBENV_VERSION_OLD_"
+    unset RBENV_VERSION_OLD_
+  else
+    typeset -g RBENV_VERSION_OLD="\$RBENV_VERSION"
+    unset RBENV_VERSION
+  fi
+else
+  echo "rbenv: RBENV_VERSION_OLD is not set" >&2
+  false
+fi
+EOS
+    ;;
+  * )
+    cat <<EOS
+if [ -n "\${RBENV_VERSION_OLD+x}" ]; then
+  if [ -n "\$RBENV_VERSION_OLD" ]; then
+    RBENV_VERSION_OLD_="\$RBENV_VERSION"
+    export RBENV_VERSION="\$RBENV_VERSION_OLD"
+    RBENV_VERSION_OLD="\$RBENV_VERSION_OLD_"
+    unset RBENV_VERSION_OLD_
+  else
+    RBENV_VERSION_OLD="\$RBENV_VERSION"
+    unset RBENV_VERSION
+  fi
+else
+  echo "rbenv: RBENV_VERSION_OLD is not set" >&2
+  false
+fi
+EOS
+    ;;
   esac
   exit
 fi
 
 # Make sure the specified version is installed.
 if rbenv-prefix "$version" >/dev/null; then
-  case "$shell" in
+  if [ "$version" != "$RBENV_VERSION" ]; then
-  fish )
+    case "$shell" in
-    echo "setenv RBENV_VERSION \"${version}\""
+    fish )
-    ;;
+      echo 'set -gu RBENV_VERSION_OLD "$RBENV_VERSION"'
-  * )
+      echo "set -gx RBENV_VERSION \"$version\""
-    echo "export RBENV_VERSION=\"${version}\""
+      ;;
-    ;;
+    zsh )
-  esac
+      echo "typeset -g RBENV_VERSION_OLD=\"\${RBENV_VERSION-}\""
+      echo "export RBENV_VERSION=\"$version\""
+      ;;
+    * )
+      echo 'RBENV_VERSION_OLD="${RBENV_VERSION-}"'
+      echo "export RBENV_VERSION=\"$version\""
+      ;;
+    esac
+  fi
 else
   echo "false"
   exit 1

libexec/rbenv-version

@@ -8,4 +8,11 @@
 set -e
 [ -n "$RBENV_DEBUG" ] && set -x
 
-echo "$(rbenv-version-name) (set by $(rbenv-version-origin))"
+version_name="$(rbenv-version-name)"
+version_origin="$(rbenv-version-origin)"
+
+if [ "$version_origin" = "${RBENV_ROOT}/version" ] && [ ! -e "$version_origin" ]; then
+  echo "$version_name"
+else
+  echo "$version_name (set by $version_origin)"
+fi

libexec/rbenv-version-file

@@ -1,33 +1,34 @@
 #!/usr/bin/env bash
+# Usage: rbenv version-file [<dir>]
 # Summary: Detect the file that sets the current rbenv version
+#
+# Detects and prints the location of a `.ruby-version` file that sets the
+# version for the current working directory. If no file found, this prints
+# the location of the global version file, even if that file does
+# not exist.
+
 set -e
 [ -n "$RBENV_DEBUG" ] && set -x
 
+target_dir="$1"
+
 find_local_version_file() {
   local root="$1"
-  while [ -n "$root" ]; do
+  while ! [[ "$root" =~ ^//[^/]*$ ]]; do
-    if [ -e "${root}/.ruby-version" ]; then
+    if [ -s "${root}/.ruby-version" ]; then
       echo "${root}/.ruby-version"
-      exit
+      return 0
-    elif [ -e "${root}/.rbenv-version" ]; then
-      echo "${root}/.rbenv-version"
-      exit
     fi
+    [ -n "$root" ] || break
     root="${root%/*}"
   done
+  return 1
 }
 
-find_local_version_file "$RBENV_DIR"
+if [ -n "$target_dir" ]; then
-[ "$RBENV_DIR" = "$PWD" ] || find_local_version_file "$PWD"
+  find_local_version_file "$target_dir"
-
-global_version_file="${RBENV_ROOT}/version"
-
-if [ -e "$global_version_file" ]; then
-  echo "$global_version_file"
-elif [ -e "${RBENV_ROOT}/global" ]; then
-  echo "${RBENV_ROOT}/global"
-elif [ -e "${RBENV_ROOT}/default" ]; then
-  echo "${RBENV_ROOT}/default"
 else
-  echo "$global_version_file"
+  find_local_version_file "$RBENV_DIR" || {
+    [ "$RBENV_DIR" != "$PWD" ] && find_local_version_file "$PWD"
+  } || echo "${RBENV_ROOT}/version"
 fi

libexec/rbenv-version-file-read

@@ -5,14 +5,14 @@ set -e
 
 VERSION_FILE="$1"
 
-if [ -e "$VERSION_FILE" ]; then
+if [ -s "$VERSION_FILE" ]; then
-  # Read the first non-whitespace word from the specified version file.
+  # Read the first word from the specified version file. Avoid reading it whole.
-  # Be careful not to load it whole in case there's something crazy in it.
   IFS="${IFS}"$'\r'
-  words=( $(cut -b 1-1024 "$VERSION_FILE") )
+  read -n 1024 -d "" -r version _ <"$VERSION_FILE" || :
-  version="${words[0]}"
 
-  if [ -n "$version" ]; then
+  if [ "$version" = ".." ] || [[ $version == */* ]]; then
+    echo "rbenv: invalid version in \`$VERSION_FILE'" >&2
+  elif [ -n "$version" ]; then
     echo "$version"
     exit
   fi

libexec/rbenv-version-name

@@ -8,6 +8,12 @@ if [ -z "$RBENV_VERSION" ]; then
   RBENV_VERSION="$(rbenv-version-file-read "$RBENV_VERSION_FILE" || true)"
 fi
 
+IFS=$'\n' read -d '' -r -a scripts <<<"$(rbenv-hooks version-name)" || true
+for script in "${scripts[@]}"; do
+  # shellcheck disable=SC1090
+  source "$script"
+done
+
 if [ -z "$RBENV_VERSION" ] || [ "$RBENV_VERSION" = "system" ]; then
   echo "system"
   exit
@@ -23,6 +29,6 @@ if version_exists "$RBENV_VERSION"; then
 elif version_exists "${RBENV_VERSION#ruby-}"; then
   echo "${RBENV_VERSION#ruby-}"
 else
-  echo "rbenv: version \`$RBENV_VERSION' is not installed" >&2
+  echo "rbenv: version \`$RBENV_VERSION' is not installed (set by $(rbenv-version-origin))" >&2
   exit 1
 fi

libexec/rbenv-version-origin

@@ -3,7 +3,17 @@
 set -e
 [ -n "$RBENV_DEBUG" ] && set -x
 
-if [ -n "$RBENV_VERSION" ]; then
+unset RBENV_VERSION_ORIGIN
+
+IFS=$'\n' read -d '' -r -a scripts <<<"$(rbenv-hooks version-origin)" || true
+for script in "${scripts[@]}"; do
+  # shellcheck disable=SC1090
+  source "$script"
+done
+
+if [ -n "$RBENV_VERSION_ORIGIN" ]; then
+  echo "$RBENV_VERSION_ORIGIN"
+elif [ -n "$RBENV_VERSION" ]; then
   echo "RBENV_VERSION environment variable"
 else
   rbenv-version-file

libexec/rbenv-versions

@@ -1,49 +1,83 @@
 #!/usr/bin/env bash
-# Summary: List all Ruby versions available to rbenv
+# Summary: List installed Ruby versions
-# Usage: rbenv versions [--bare]
+# Usage: rbenv versions [--bare] [--skip-aliases]
 #
 # Lists all Ruby versions found in `$RBENV_ROOT/versions/*'.
 
 set -e
 [ -n "$RBENV_DEBUG" ] && set -x
 
-if [ "$1" = "--bare" ]; then
+unset bare
-  hit_prefix=""
+unset skip_aliases
-  miss_prefix=""
+# Provide rbenv completions
-  current_version=""
+for arg; do
-  include_system=""
+  case "$arg" in
-else
+  --complete )
-  hit_prefix="* "
+    echo --bare
-  miss_prefix="  "
+    echo --skip-aliases
-  current_version="$(rbenv-version-name || true)"
+    exit ;;
-  include_system="1"
+  --bare ) bare=1 ;;
-fi
+  --skip-aliases ) skip_aliases=1 ;;
+  * )
+    rbenv-help --usage versions >&2
+    exit 1
+    ;;
+  esac
+done
 
-num_versions=0
+canonicalize_dir() {
-
+  { cd "$1" && pwd -P
-print_version() {
+  } 2>/dev/null || echo "$1"
-  if [ "$1" == "$current_version" ]; then
-    echo "${hit_prefix}$(rbenv-version 2>/dev/null)"
-  else
-    echo "${miss_prefix}$1"
-  fi
-  num_versions=$((num_versions + 1))
 }
 
-# Include "system" in the non-bare output, if it exists
+versions_dir="${RBENV_ROOT}/versions"
-if [ -n "$include_system" ] && RBENV_VERSION=system rbenv-which ruby >/dev/null 2>&1; then
+if [ -n "$skip_aliases" ]; then
-  print_version system
+  versions_dir="$(canonicalize_dir "$versions_dir")"
 fi
 
-shopt -s nullglob
+list_versions() {
-for path in "${RBENV_ROOT}/versions/"*; do
+  local path
-  if [ -d "$path" ]; then
+  local target
-    print_version "${path##*/}"
+  shopt -s nullglob
-  fi
+  for path in "$versions_dir"/*; do
-done
+    if [ -d "$path" ]; then
-shopt -u nullglob
+      if [ -n "$skip_aliases" ] && [ -L "$path" ]; then
+        target="$(canonicalize_dir "$path")"
+        [ "${target%/*}" != "$versions_dir" ] || continue
+      fi
+      echo "${path##*/}"
+    fi
+  done
+  shopt -u nullglob
+}
 
-if [ "$num_versions" -eq 0 ] && [ -n "$include_system" ]; then
+if [ -n "$bare" ]; then
+  list_versions
+  exit 0
+fi
+
+sort_versions() {
+  sed 'h; s/[+-]/./g; s/.p\([[:digit:]]\)/.z.\1/; s/$/.z/; G; s/\n/ /' | \
+    LC_ALL=C sort -t. -k 1,1 -k 2,2n -k 3,3n -k 4,4n -k 5,5n | awk '{print $2}'
+}
+
+versions="$(
+  if RBENV_VERSION=system rbenv-which ruby >/dev/null 2>&1; then
+    echo system
+  fi
+  list_versions | sort_versions
+)"
+
+if [ -z "$versions" ]; then
   echo "Warning: no Ruby detected on the system" >&2
   exit 1
 fi
+
+current_version="$(rbenv-version-name || true)"
+while read -r version; do
+  if [ "$version" == "$current_version" ]; then
+    echo "* $(rbenv-version 2>/dev/null)"
+  else
+    echo "  $version"
+  fi
+done <<<"$versions"

libexec/rbenv-whence

@@ -20,7 +20,7 @@ fi
 
 whence() {
   local command="$1"
-  rbenv-versions --bare | while read version; do
+  rbenv-versions --bare | while read -r version; do
     path="$(rbenv-prefix "$version")/bin/${command}"
     if [ -x "$path" ]; then
       [ "$print_paths" ] && echo "$path" || echo "$version"

libexec/rbenv-which

@@ -18,12 +18,13 @@ fi
 remove_from_path() {
   local path_to_remove="$1"
   local path_before
-  local result=":$PATH:"
+  local result=":${PATH//\~/$HOME}:"
   while [ "$path_before" != "$result" ]; do
     path_before="$result"
     result="${result//:$path_to_remove:/:}"
   done
-  echo "${result%:}"
+  result="${result%:}"
+  echo "${result#:}"
 }
 
 RBENV_COMMAND="$1"
@@ -36,23 +37,26 @@ fi
 RBENV_VERSION="${RBENV_VERSION:-$(rbenv-version-name)}"
 
 if [ "$RBENV_VERSION" = "system" ]; then
-  PATH="$(remove_from_path "${RBENV_ROOT}/shims")"
+  PATH="$(remove_from_path "${RBENV_ROOT}/shims")" \
-  RBENV_COMMAND_PATH="$(command -v "$RBENV_COMMAND" || true)"
+    RBENV_COMMAND_PATH="$(command -v "$RBENV_COMMAND" || true)"
 else
   RBENV_COMMAND_PATH="${RBENV_ROOT}/versions/${RBENV_VERSION}/bin/${RBENV_COMMAND}"
 fi
 
-OLDIFS="$IFS"
+if [[ ! -x "$RBENV_COMMAND_PATH" && -n "$GEM_HOME" && -x "${GEM_HOME}/bin/${RBENV_COMMAND}" ]]; then
-IFS=$'\n' scripts=(`rbenv-hooks which`)
+  RBENV_COMMAND_PATH="${GEM_HOME}/bin/${RBENV_COMMAND}"
-IFS="$OLDIFS"
+fi
+
+IFS=$'\n' read -d '' -r -a scripts <<<"$(rbenv-hooks which)" || true
 for script in "${scripts[@]}"; do
+  # shellcheck disable=SC1090
   source "$script"
 done
 
 if [ -x "$RBENV_COMMAND_PATH" ]; then
   echo "$RBENV_COMMAND_PATH"
-elif ! [ -d "${RBENV_ROOT}/versions/${RBENV_VERSION}" ]; then
+elif [ "$RBENV_VERSION" != "system" ] && [ ! -d "${RBENV_ROOT}/versions/${RBENV_VERSION}" ]; then
-  echo "rbenv: version \`$RBENV_VERSION' is not installed" >&2
+  echo "rbenv: version \`$RBENV_VERSION' is not installed (set by $(rbenv-version-origin))" >&2
   exit 1
 else
   echo "rbenv: $RBENV_COMMAND: command not found" >&2

rbenv.d/exec/gem-rehash/rubygems_plugin.rb

@@ -6,13 +6,40 @@ hook = lambda do |installer|
       `rbenv rehash`
     end
   rescue
-    warn "rbenv: error in gem-rehash (#{$!})"
+    warn "rbenv: error in gem-rehash (#{$!.class.name}: #{$!.message})"
   end
 end
 
-begin
+if defined?(Bundler::Installer) &&
-  Gem.post_install(&hook)
+   Bundler::Installer.private_method_defined?(:install) &&
-  Gem.post_uninstall(&hook)
+   !Bundler::Installer.private_method_defined?(:install_without_rbenv_rehash)
-rescue
+  Bundler::Installer.class_eval do
-  warn "rbenv: error installing gem-rehash hooks (#{$!})"
+    private
+
+    alias install_without_rbenv_rehash install
+    def install(options)
+      begin
+        if Gem.default_path.include?(Bundler.bundle_path.to_s)
+          bin_dir = Gem.bindir(Bundler.bundle_path.to_s)
+          bins_before = File.exist?(bin_dir) ? Dir.entries(bin_dir).size : 2
+        end
+      rescue
+        warn "rbenv: error in Bundler post-install hook (#{$!.class.name}: #{$!.message})"
+      end
+
+      result = install_without_rbenv_rehash(options)
+
+      if bin_dir && File.exist?(bin_dir) && Dir.entries(bin_dir).size > bins_before
+        `rbenv rehash`
+      end
+      result
+    end
+  end
+else
+  begin
+    Gem.post_install(&hook)
+    Gem.post_uninstall(&hook)
+  rescue
+    warn "rbenv: error installing gem-rehash hooks (#{$!.class.name}: #{$!.message})"
+  end
 end

share/man/man1/rbenv.1

@@ -0,0 +1,163 @@
+'\" t
+.\"     Title: rbenv
+.\"    Author: Mislav Marohnić
+.\" Generator: Asciidoctor 2.0.20
+.\"      Date: 2023-11-08
+.\"    Manual: Rbenv Manual
+.\"    Source: rbenv 1.3.2
+.\"  Language: English
+.\"
+.TH "RBENV" "1" "2023-11-08" "rbenv 1.3.2" "Rbenv Manual"
+.ie \n(.g .ds Aq \(aq
+.el       .ds Aq '
+.ss \n[.ss] 0
+.nh
+.ad l
+.de URL
+\fI\\$2\fP <\\$1>\\$3
+..
+.als MTO URL
+.if \n[.g] \{\
+.  mso www.tmac
+.  am URL
+.    ad l
+.  .
+.  am MTO
+.    ad l
+.  .
+.  LINKSTYLE blue R < >
+.\}
+.SH "NAME"
+rbenv \- manage your application\*(Aqs Ruby environment
+.SH "SYNOPSIS"
+.sp
+\fBrbenv\fP \fI<command>\fP [\fI<args>\fP...]
+.SH "DESCRIPTION"
+.sp
+rbenv respects the \fI.ruby\-version\fP file in a project directory by making sure that any \fBruby\fP, \fBgem\fP, \fBbundle\fP, or other Ruby command invocation automatically invokes the Ruby version configured for that project.
+.sp
+It does so by generating shims for all Ruby executables. As long as rbenv shims directory is prepended to PATH, rbenv automatically ensures transparent switching between Ruby versions.
+.sp
+rbenv looks for available Ruby versions in the \fI$RBENV_ROOT/versions\fP directory.
+.SH "COMMANDS"
+.sp
+\fBrbenv global\fP [\fI<version>\fP]
+.RS 4
+View or change the global Ruby version
+.RE
+.sp
+\fBrbenv local\fP [\fI<version>\fP]
+.RS 4
+View or change the local Ruby version
+.RE
+.sp
+\fBrbenv shell\fP [\fI<version>\fP]
+.RS 4
+View or change the Ruby version for the current shell session
+.RE
+.sp
+\fBrbenv version\fP
+.RS 4
+View the currently active Ruby version and where it is set from
+.RE
+.sp
+\fBrbenv versions\fP
+.RS 4
+List all locally installed Ruby versions known to rbenv
+.RE
+.sp
+\fBrbenv install\fP [\fI<version>\fP]
+.RS 4
+(Provided by the \fBruby\-build\fP plugin) Download and install a new Ruby version
+.RE
+.sp
+\fBrbenv rehash\fP
+.RS 4
+Regenerate shims for all known Ruby executables
+.RE
+.sp
+\fBrbenv which\fP [\fI<command>\fP]
+.RS 4
+View the executable path that a command resolves to
+.RE
+.sp
+\fBrbenv init\fP
+.RS 4
+Help bootstrap rbenv into the current shell environment
+.RE
+.sp
+\fBrbenv help\fP [\fI<command>\fP]
+.RS 4
+View help text for any rbenv command
+.RE
+.SH "ENVIRONMENT VARIABLES"
+.sp
+\fBRBENV_VERSION\fP (default: read from \fI.ruby\-version\fP file)
+.RS 4
+The Ruby version name to be used
+.RE
+.sp
+\fBRBENV_ROOT\fP (default: \fI~/.rbenv\fP)
+.RS 4
+The location where rbenv discovers Ruby versions, plugins, and other configuration
+.RE
+.sp
+\fBRBENV_DEBUG\fP
+.RS 4
+Activates printing debug information about rbenv internals to standard error
+.RE
+.sp
+\fBRBENV_HOOK_PATH\fP
+.RS 4
+Colon\-separated list of paths searched for rbenv plugin scripts
+.RE
+.sp
+\fBRBENV_DIR\fP (default: \fI$PWD\fP)
+.RS 4
+Directory to traverse bottom\-up to locate the \fI.ruby\-version\fP file
+.RE
+.SH "PLUGINS"
+.sp
+As its core functionality, rbenv only switches between Ruby versions and does nothing else, but offers a plugin mechanism to hook into and override almost any aspect of its default behavior.
+.sp
+The most common plugin for rbenv is \fBruby\-build\fP which facilitates installing new Ruby versions into the \fI$RBENV_ROOT/versions\fP directory.
+.sp
+Read more at \c
+.URL "https://github.com/rbenv/rbenv/wiki/Plugins" "" ""
+.SH "NOTES"
+.sp
+.RS 4
+.ie n \{\
+\h'-04'\(bu\h'+03'\c
+.\}
+.el \{\
+.  sp -1
+.  IP \(bu 2.3
+.\}
+.URL "https://github.com/rbenv/rbenv/discussions" "" ""
+.RE
+.sp
+.RS 4
+.ie n \{\
+\h'-04'\(bu\h'+03'\c
+.\}
+.el \{\
+.  sp -1
+.  IP \(bu 2.3
+.\}
+.URL "https://github.com/rbenv/rbenv/wiki" "" ""
+.RE
+.sp
+.RS 4
+.ie n \{\
+\h'-04'\(bu\h'+03'\c
+.\}
+.el \{\
+.  sp -1
+.  IP \(bu 2.3
+.\}
+.URL "https://github.com/rbenv/ruby\-build#readme" "" ""
+.RE
+.SH "AUTHOR"
+.sp
+Mislav Marohnić

share/man/man1/rbenv.1.adoc

@@ -0,0 +1,87 @@
+= rbenv(1)
+Mislav Marohnić
+:doctype: manpage
+:man manual: Rbenv Manual
+:man source: rbenv {version}
+:man-linkstyle: pass:[blue R < >]
+
+== Name
+
+rbenv - manage your application's Ruby environment
+
+== Synopsis
+
+*rbenv* _<command>_ [_<args>_...]
+
+== Description
+
+rbenv respects the _.ruby-version_ file in a project directory by making sure that any *ruby*, *gem*, *bundle*, or other Ruby command invocation automatically invokes the Ruby version configured for that project.
+
+It does so by generating shims for all Ruby executables. As long as rbenv shims directory is prepended to PATH, rbenv automatically ensures transparent switching between Ruby versions.
+
+rbenv looks for available Ruby versions in the _$RBENV_ROOT/versions_ directory.
+
+== Commands
+
+*rbenv global* [_<version>_]::
+  View or change the global Ruby version
+
+*rbenv local* [_<version>_]::
+  View or change the local Ruby version
+
+*rbenv shell* [_<version>_]::
+  View or change the Ruby version for the current shell session
+
+*rbenv version*::
+  View the currently active Ruby version and where it is set from
+
+*rbenv versions*::
+  List all locally installed Ruby versions known to rbenv
+
+*rbenv install* [_<version>_]::
+  (Provided by the *ruby-build* plugin) Download and install a new Ruby version
+
+*rbenv rehash*::
+  Regenerate shims for all known Ruby executables
+
+*rbenv which* [_<command>_]::
+  View the executable path that a command resolves to
+
+*rbenv init*::
+  Help bootstrap rbenv into the current shell environment
+
+*rbenv help* [_<command>_]::
+  View help text for any rbenv command
+
+== Environment Variables
+
+*RBENV_VERSION* (default: read from _.ruby-version_ file)::
+  The Ruby version name to be used
+
+*RBENV_ROOT* (default: _~/.rbenv_)::
+  The location where rbenv discovers Ruby versions, plugins, and other configuration
+
+*RBENV_DEBUG*::
+  Activates printing debug information about rbenv internals to standard error
+
+*RBENV_HOOK_PATH*::
+  Colon-separated list of paths searched for rbenv plugin scripts
+
+*RBENV_DIR* (default: _$PWD_)::
+  Directory to traverse bottom-up to locate the _.ruby-version_ file
+
+== Plugins
+
+As its core functionality, rbenv only switches between Ruby versions and does nothing else, but offers a plugin mechanism to hook into and override almost any aspect of its default behavior.
+
+The most common plugin for rbenv is *ruby-build* which facilitates installing new Ruby versions into the _$RBENV_ROOT/versions_ directory.
+
+Read more at https://github.com/rbenv/rbenv/wiki/Plugins
+
+== Notes
+
+* https://github.com/rbenv/rbenv/discussions
+
+* https://github.com/rbenv/rbenv/wiki
+
+* https://github.com/rbenv/ruby-build#readme

src/Makefile.in

@@ -1,25 +1,8 @@
-CC = @CC@
+../libexec/rbenv-realpath.dylib:
-
+	@echo "Warning: this Makefile is obsolete and kept only for backwards compatibility." >&2
-CFLAGS = @CFLAGS@
+	@echo "You can remove the \`configure && make ...' step from your rbenv setup." >&2
-LOCAL_CFLAGS = @LOCAL_CFLAGS@
-DEFS = @DEFS@
-LOCAL_DEFS = @LOCAL_DEFS@
-
-CCFLAGS = $(DEFS) $(LOCAL_DEFS) $(LOCAL_CFLAGS) $(CFLAGS)
-
-SHOBJ_CC = @SHOBJ_CC@
-SHOBJ_CFLAGS = @SHOBJ_CFLAGS@
-SHOBJ_LD = @SHOBJ_LD@
-SHOBJ_LDFLAGS = @SHOBJ_LDFLAGS@
-SHOBJ_XLDFLAGS = @SHOBJ_XLDFLAGS@
-SHOBJ_LIBS = @SHOBJ_LIBS@
-SHOBJ_STATUS = @SHOBJ_STATUS@
-
-.c.o:
-	$(SHOBJ_CC) $(SHOBJ_CFLAGS) $(CCFLAGS) -c -o $@ $<
-
-../libexec/rbenv-realpath.dylib: realpath.o
-	$(SHOBJ_LD) $(SHOBJ_LDFLAGS) $(SHOBJ_XLDFLAGS) -o $@ realpath.o $(SHOBJ_LIBS)
 
 clean:
 	rm -f *.o ../libexec/*.dylib
+
+.PHONY: ../libexec/rbenv-realpath.dylib clean

src/bash.h

@@ -1,31 +0,0 @@
-#ifndef __BASH_H__
-#define __BASH_H__
-
-#define EXECUTION_SUCCESS 0
-#define EXECUTION_FAILURE 1
-#define EX_USAGE 258
-
-#define BUILTIN_ENABLED 1
-
-typedef struct word_desc {
-  char *word;
-  int flags;
-} WORD_DESC;
-
-typedef struct word_list {
-  struct word_list *next;
-  WORD_DESC *word;
-} WORD_LIST;
-
-typedef int sh_builtin_func_t(WORD_LIST *);
-
-struct builtin {
-  char *name;
-  sh_builtin_func_t *function;
-  int flags;
-  char * const *long_doc;
-  const char *short_doc;
-  char *unused;
-};
-
-#endif

src/configure

@@ -1,46 +1,7 @@
 #!/usr/bin/env bash
+# Warning: this configure script is obsolete and kept only for backwards compatibility.
 set -e
 
 src_dir="${0%/*}"
 
-if [ -z "$CC" ]; then
+cp "$src_dir"/Makefile.in "$src_dir"/Makefile
-  if type -p gcc >/dev/null; then
-    CC=gcc
-  else
-    echo "warning: gcc not found; using CC=cc" >&2
-    CC=cc
-  fi
-fi
-
-if ! type -p "$CC" >/dev/null; then
-  echo "aborted: compiler not found: $CC" >&2
-  exit 1
-fi
-
-case "$(uname -s)" in
-Darwin* )
-  host_os="darwin$(uname -r)"
-  ;;
-OpenBSD* )
-  host_os="openbsd$(uname -r)"
-  ;;
-* )
-  host_os="linux-gnu"
-esac
-
-eval "$("$src_dir"/shobj-conf -C "$CC" -o "$host_os")"
-
-sed "
-  s,@CC@,${CC},
-  s,@CFLAGS@,${CFLAGS},
-  s,@LOCAL_CFLAGS@,${LOCAL_CFLAGS},
-  s,@DEFS@,${DEFS},
-  s,@LOCAL_DEFS@,${LOCAL_DEFS},
-  s,@SHOBJ_CC@,${SHOBJ_CC},
-  s,@SHOBJ_CFLAGS@,${SHOBJ_CFLAGS},
-  s,@SHOBJ_LD@,${SHOBJ_LD},
-  s,@SHOBJ_LDFLAGS@,${SHOBJ_LDFLAGS//,/\,},
-  s,@SHOBJ_XLDFLAGS@,${SHOBJ_XLDFLAGS//,/\,},
-  s,@SHOBJ_LIBS@,${SHOBJ_LIBS},
-  s,@SHOBJ_STATUS@,${SHOBJ_STATUS},
-" "$src_dir"/Makefile.in > "$src_dir"/Makefile

src/realpath.c

@@ -1,43 +0,0 @@
-#include "bash.h"
-#include <stdlib.h>
-#include <stdio.h>
-
-int realpath_builtin(list)
-WORD_LIST *list;
-{
-	int es;
-	char *realbuf, *p;
-
-	if (list == 0) {
-		// builtin_usage();
-		return (EX_USAGE);
-	}
-
-	for (es = EXECUTION_SUCCESS; list; list = list->next) {
-		p = list->word->word;
-		realbuf = realpath(p, NULL);
-		if (realbuf == NULL) {
-			es = EXECUTION_FAILURE;
-			// builtin_error("%s: cannot resolve: %s", p, strerror(errno));
-		} else {
-			printf("%s\n", realbuf);
-			free(realbuf);
-		}
-	}
-	return es;
-}
-
-char *realpath_doc[] = {
-	"Display each PATHNAME argument, resolving symbolic links. The exit status",
-	"is 0 if each PATHNAME was resolved; non-zero otherwise.",
-	(char *)NULL
-};
-
-struct builtin realpath_struct = {
-	"realpath",
-	realpath_builtin,
-	BUILTIN_ENABLED,
-	realpath_doc,
-	"realpath pathname [pathname...]",
-	0
-};

src/shobj-conf

@@ -1,558 +0,0 @@
-#! /bin/sh
-#
-# shobj-conf -- output a series of variable assignments to be substituted
-#		into a Makefile by configure which specify system-dependent
-#		information for creating shared objects that may be loaded
-#		into bash with `enable -f'
-#
-# usage: shobj-conf [-C compiler] -c host_cpu -o host_os -v host_vendor
-#
-# Chet Ramey
-# chet@po.cwru.edu
-
-# Copyright (C) 1996-2002 Free Software Foundation, Inc.
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2, or (at your option)
-# any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA.
-
-#
-# defaults
-#
-SHOBJ_STATUS=supported
-SHLIB_STATUS=supported
-
-SHOBJ_CC=cc
-SHOBJ_CFLAGS=
-SHOBJ_LD=
-SHOBJ_LDFLAGS=
-SHOBJ_XLDFLAGS=
-SHOBJ_LIBS=
-
-SHLIB_XLDFLAGS=
-SHLIB_LIBS=
-
-SHLIB_DOT='.'
-SHLIB_LIBPREF='lib'
-SHLIB_LIBSUFF='so'
-
-SHLIB_LIBVERSION='$(SHLIB_LIBSUFF)'
-SHLIB_DLLVERSION='$(SHLIB_MAJOR)'
-
-PROGNAME=`basename $0`
-USAGE="$PROGNAME [-C compiler] -c host_cpu -o host_os -v host_vendor"
-
-while [ $# -gt 0 ]; do
-	case "$1" in
-	-C)	shift; SHOBJ_CC="$1"; shift ;;
-	-c)	shift; host_cpu="$1"; shift ;;
-	-o)	shift; host_os="$1"; shift ;;
-	-v)	shift; host_vendor="$1"; shift ;;
-	*)	echo "$USAGE" >&2 ; exit 2;;
-	esac
-done
-
-case "${host_os}-${SHOBJ_CC}" in
-sunos4*-*gcc*)
-	SHOBJ_CFLAGS=-fpic
-	SHOBJ_LD=/usr/bin/ld
-	SHOBJ_LDFLAGS='-assert pure-text'
-
-	SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)$(SHLIB_MINOR)'
-	;;
-
-sunos4*)
-	SHOBJ_CFLAGS=-pic
-	SHOBJ_LD=/usr/bin/ld
-	SHOBJ_LDFLAGS='-assert pure-text'
-
-	SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)$(SHLIB_MINOR)'
-	;;
-
-sunos5*-*gcc*|solaris2*-*gcc*)
-	SHOBJ_CFLAGS=-fpic
-	SHOBJ_LD='${CC}'
-	ld_used=`gcc -print-prog-name=ld`
-	if ${ld_used} -V 2>&1 | grep GNU >/dev/null 2>&1; then
-		# This line works for the GNU ld
-		SHOBJ_LDFLAGS='-shared -Wl,-h,$@'
-	else
-		# This line works for the Solaris linker in /usr/ccs/bin/ld
-		SHOBJ_LDFLAGS='-shared -Wl,-i -Wl,-h,$@'
-	fi
-
-#	SHLIB_XLDFLAGS='-R $(libdir)'
-	SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)'
-	;;
-
-sunos5*|solaris2*)
-	SHOBJ_CFLAGS='-K pic'
-	SHOBJ_LD=/usr/ccs/bin/ld
-	SHOBJ_LDFLAGS='-G -dy -z text -i -h $@'
-
-#	SHLIB_XLDFLAGS='-R $(libdir)'
-	SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)'
-	;;
-
-# All versions of Linux or the semi-mythical GNU Hurd.
-linux*-*|gnu*-*|k*bsd*-gnu-*)
-	SHOBJ_CFLAGS=-fPIC
-	SHOBJ_LD='${CC}'
-	SHOBJ_LDFLAGS='-shared -Wl,-soname,$@'
-
-	SHLIB_XLDFLAGS='-Wl,-rpath,$(libdir) -Wl,-soname,`basename $@ $(SHLIB_MINOR)`'
-	SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)$(SHLIB_MINOR)'
-	;;
-
-freebsd2* | netbsd*)
-	SHOBJ_CFLAGS=-fpic
-	SHOBJ_LD=ld
-	SHOBJ_LDFLAGS='-x -Bshareable'
-
-	SHLIB_XLDFLAGS='-R$(libdir)'
-	SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)$(SHLIB_MINOR)'
-	;;
-
-# FreeBSD-3.x ELF
-freebsd[3-9]*|freebsdelf[3-9]*|freebsdaout[3-9]*|dragonfly*)
-	SHOBJ_CFLAGS=-fpic
-	SHOBJ_LD='${CC}'
-
-	if [ -x /usr/bin/objformat ] && [ "`/usr/bin/objformat`" = "elf" ]; then
-		SHOBJ_LDFLAGS='-shared -Wl,-soname,$@'
-
-		SHLIB_XLDFLAGS='-Wl,-rpath,$(libdir)'
-		SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)'
-	else
-		SHOBJ_LDFLAGS='-shared'
-
-		SHLIB_XLDFLAGS='-R$(libdir)'
-		SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)$(SHLIB_MINOR)'
-	fi
-	;;
-
-# Darwin/MacOS X
-darwin1*)
-	SHOBJ_STATUS=supported
-	SHLIB_STATUS=supported
-	
-	SHOBJ_CFLAGS=''
-	SHLIB_LIBSUFF='dylib'
-
-	SHOBJ_LD='${CC}'
-	SHOBJ_LDFLAGS='-dynamiclib'
-	;;
-
-darwin8*)
-	SHOBJ_STATUS=supported
-	SHLIB_STATUS=supported
-	
-	SHOBJ_CFLAGS='-fno-common'
-
-	SHOBJ_LD='MACOSX_DEPLOYMENT_TARGET=10.3 ${CC}'
-
-	SHLIB_LIBVERSION='$(SHLIB_MAJOR)$(SHLIB_MINOR).$(SHLIB_LIBSUFF)'
-	SHLIB_LIBSUFF='dylib'
-
-	SHOBJ_LDFLAGS='-undefined dynamic_lookup'
-	SHLIB_XLDFLAGS='-dynamiclib -arch_only `/usr/bin/arch` -install_name $(libdir)/$@ -current_version $(SHLIB_MAJOR)$(SHLIB_MINOR) -compatibility_version $(SHLIB_MAJOR) -v'
-
-	SHLIB_LIBS='-lncurses'	# see if -lcurses works on MacOS X 10.1 
-	;;
-
-darwin*|macosx*)
-	SHOBJ_STATUS=unsupported
-	SHLIB_STATUS=supported
-
-	SHOBJ_CFLAGS='-fno-common'
-
-	SHOBJ_LD='${CC}'
-
-	SHLIB_LIBVERSION='$(SHLIB_MAJOR)$(SHLIB_MINOR).$(SHLIB_LIBSUFF)'
-	SHLIB_LIBSUFF='dylib'
-
-	case "${host_os}" in
-	darwin[78]*)	SHOBJ_LDFLAGS=''
-			SHLIB_XLDFLAGS='-dynamiclib -arch_only `/usr/bin/arch` -install_name $(libdir)/$@ -current_version $(SHLIB_MAJOR)$(SHLIB_MINOR) -compatibility_version $(SHLIB_MAJOR) -v'
-			;;
-	*)		SHOBJ_LDFLAGS='-dynamic'
-			SHLIB_XLDFLAGS='-arch_only `/usr/bin/arch` -install_name $(libdir)/$@ -current_version $(SHLIB_MAJOR)$(SHLIB_MINOR) -compatibility_version $(SHLIB_MAJOR) -v'
-			;;
-	esac
-
-	SHLIB_LIBS='-lncurses'	# see if -lcurses works on MacOS X 10.1 
-	;;
-
-openbsd*)
-	SHOBJ_CFLAGS=-fPIC
-	SHOBJ_LD='${CC}'
-	SHOBJ_LDFLAGS='-shared'
-
-	SHLIB_XLDFLAGS='-R$(libdir)'
-	SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)$(SHLIB_MINOR)'
-	;;
-
-bsdi2*)
-	SHOBJ_CC=shlicc2
-	SHOBJ_CFLAGS=
-	SHOBJ_LD=ld
-	SHOBJ_LDFLAGS=-r
-	SHOBJ_LIBS=-lc_s.2.1.0
-
-	# BSD/OS 2.x and 3.x `shared libraries' are too much of a pain in
-	# the ass -- they require changing {/usr/lib,etc}/shlib.map on
-	# each system, and the library creation process is byzantine
-	SHLIB_STATUS=unsupported
-	;;
-
-bsdi3*)
-	SHOBJ_CC=shlicc2
-	SHOBJ_CFLAGS=
-	SHOBJ_LD=ld
-	SHOBJ_LDFLAGS=-r
-	SHOBJ_LIBS=-lc_s.3.0.0
-
-	# BSD/OS 2.x and 3.x `shared libraries' are too much of a pain in
-	# the ass -- they require changing {/usr/lib,etc}/shlib.map on
-	# each system, and the library creation process is byzantine
-	SHLIB_STATUS=unsupported
-	;;
-
-bsdi4*)
-	# BSD/OS 4.x now supports ELF and SunOS-style dynamically-linked
-	# shared libraries.  gcc 2.x is the standard compiler, and the
-	# `normal' gcc options should work as they do in Linux.
-
-	SHOBJ_CFLAGS=-fPIC
-	SHOBJ_LD='${CC}'
-	SHOBJ_LDFLAGS='-shared -Wl,-soname,$@'
-
-	SHLIB_XLDFLAGS='-Wl,-soname,`basename $@ $(SHLIB_MINOR)`'
-	SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)$(SHLIB_MINOR)'
-	;;
-
-osf*-*gcc*)
-	# Fix to use gcc linker driver from bfischer@TechFak.Uni-Bielefeld.DE
-	SHOBJ_LD='${CC}'
-	SHOBJ_LDFLAGS='-shared -Wl,-soname,$@'
-
-	SHLIB_XLDFLAGS='-rpath $(libdir)'
-	SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)'
-	;;
-
-osf*)
-	SHOBJ_LD=ld
-	SHOBJ_LDFLAGS='-shared -soname $@ -expect_unresolved "*"'
-
-	SHLIB_XLDFLAGS='-rpath $(libdir)'
-	SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)'
-	;;
-
-aix4.[2-9]*-*gcc*)		# lightly tested by jik@cisco.com
-	SHOBJ_CFLAGS=-fpic
-	SHOBJ_LD='ld'
-	SHOBJ_LDFLAGS='-bdynamic -bnoentry -bexpall'
-	SHOBJ_XLDFLAGS='-G'
-
-	SHLIB_XLDFLAGS='-bM:SRE'
-	SHLIB_LIBS='-lcurses -lc'
-	SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)'
-	;;
-
-aix4.[2-9]*)
-	SHOBJ_CFLAGS=-K
-	SHOBJ_LD='ld'
-	SHOBJ_LDFLAGS='-bdynamic -bnoentry -bexpall'
-	SHOBJ_XLDFLAGS='-G'
-
-	SHLIB_XLDFLAGS='-bM:SRE'
-	SHLIB_LIBS='-lcurses -lc'
-	SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)'
-	;;
-
-#
-# THE FOLLOWING ARE UNTESTED -- and some may not support the dlopen interface
-#
-irix[56]*-*gcc*)
-	SHOBJ_CFLAGS='-fpic'
-	SHOBJ_LD='${CC}'
-	SHOBJ_LDFLAGS='-shared -Wl,-soname,$@'
-
-	SHLIB_XLDFLAGS='-Wl,-rpath,$(libdir)'
-	SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)'
-	;;
-
-irix[56]*)
-	SHOBJ_CFLAGS='-K PIC'
-	SHOBJ_LD=ld
-#	SHOBJ_LDFLAGS='-call_shared -hidden_symbol -no_unresolved -soname $@'
-#	Change from David Kaelbling <drk@sgi.com>.  If you have problems,
-#	remove the `-no_unresolved'
-	SHOBJ_LDFLAGS='-shared -no_unresolved -soname $@'
-
-	SHLIB_XLDFLAGS='-rpath $(libdir)'
-	SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)'
-	;;
-
-hpux9*-*gcc*)
-	# must use gcc; the bundled cc cannot compile PIC code
-	SHOBJ_CFLAGS='-fpic'
-	SHOBJ_LD='${CC}'
-	SHOBJ_LDFLAGS='-shared -Wl,-b -Wl,+s'
-
-	SHLIB_XLDFLAGS='-Wl,+b,$(libdir)'
-	SHLIB_LIBSUFF='sl'
-	SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)'
-	;;
-
-hpux9*)
-	SHOBJ_STATUS=unsupported
-	SHLIB_STATUS=unsupported
-
-	# If you are using the HP ANSI C compiler, you can uncomment and use
-	# this code (I have not tested it)
-#	SHOBJ_STATUS=supported
-#	SHLIB_STATUS=supported
-#
-#	SHOBJ_CFLAGS='+z'
-#	SHOBJ_LD='ld'
-#	SHOBJ_LDFLAGS='-b +s'
-#
-#	SHLIB_XLDFLAGS='+b $(libdir)'
-#	SHLIB_LIBSUFF='sl'
-#	SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)'	
-
-	;;
-
-hpux10*-*gcc*)
-	# must use gcc; the bundled cc cannot compile PIC code
-	SHOBJ_CFLAGS='-fpic'
-	SHOBJ_LD='${CC}'
-	# if you have problems linking here, moving the `-Wl,+h,$@' from
-	# SHLIB_XLDFLAGS to SHOBJ_LDFLAGS has been reported to work
-	SHOBJ_LDFLAGS='-shared -Wl,-b -Wl,+s'
-
-	SHLIB_XLDFLAGS='-Wl,+h,$@ -Wl,+b,$(libdir)'
-	SHLIB_LIBSUFF='sl'
-	SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)'
-	;;
-
-hpux10*)
-	SHOBJ_STATUS=unsupported
-	SHLIB_STATUS=unsupported
-
-	# If you are using the HP ANSI C compiler, you can uncomment and use
-	# this code (I have not tested it)
-#	SHOBJ_STATUS=supported
-#	SHLIB_STATUS=supported
-#
-#	SHOBJ_CFLAGS='+z'
-#	SHOBJ_LD='ld'
-#	SHOBJ_LDFLAGS='-b +s +h $@'
-#
-#	SHLIB_XLDFLAGS='+b $(libdir)'
-#	SHLIB_LIBSUFF='sl'
-#	SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)'	
-
-	;;
-
-hpux11*-*gcc*)
-	# must use gcc; the bundled cc cannot compile PIC code
-	SHOBJ_CFLAGS='-fpic'
-	SHOBJ_LD='${CC}'
-#	SHOBJ_LDFLAGS='-shared -Wl,-b -Wl,-B,symbolic -Wl,+s -Wl,+std -Wl,+h,$@'
-	SHOBJ_LDFLAGS='-shared -fpic -Wl,-b -Wl,+s -Wl,+h,$@'
-
-	SHLIB_XLDFLAGS='-Wl,+b,$(libdir)'
-	SHLIB_LIBSUFF='sl'
-	SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)'
-	;;
-
-hpux11*)
-	SHOBJ_STATUS=unsupported
-	SHLIB_STATUS=unsupported
-
-	# If you are using the HP ANSI C compiler, you can uncomment and use
-	# this code (I have not tested it)
-#	SHOBJ_STATUS=supported
-#	SHLIB_STATUS=supported
-#
-#	SHOBJ_CFLAGS='+z'
-#	SHOBJ_LD='ld'
-#	SHOBJ_LDFLAGS='-b +s +h $@'
-#
-#	SHLIB_XLDFLAGS='+b $(libdir)'
-#	SHLIB_LIBSUFF='sl'
-#	SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)'	
-
-	;;
-
-sysv4*-*gcc*)
-	SHOBJ_CFLAGS=-shared
-	SHOBJ_LDFLAGS='-shared -h $@'
-	SHOBJ_LD='${CC}'
-
-	SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)'
-	;;
-
-sysv4*)
-	SHOBJ_CFLAGS='-K PIC'
-	SHOBJ_LD=ld
-	SHOBJ_LDFLAGS='-dy -z text -G -h $@'
-
-	SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)'
-	;;
-
-sco3.2v5*-*gcc*)
-	SHOBJ_CFLAGS='-fpic'		# DEFAULTS TO ELF
-	SHOBJ_LD='${CC}'
-	SHOBJ_LDFLAGS='-shared'
-
-	SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)'
-	;;
-
-sco3.2v5*)
-	SHOBJ_CFLAGS='-K pic -b elf'
-	SHOBJ_LD=ld
-	SHOBJ_LDFLAGS='-G -b elf -dy -z text -h $@'
-
-	SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)'
-	;;
-
-sysv5uw7*-*gcc*)
-	SHOBJ_CFLAGS='-fpic'
-	SHOBJ_LD='${CC}'
-	SHOBJ_LDFLAGS='-shared'
-
-	SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)'
-	;;
-
-sysv5uw7*)
-	SHOBJ_CFLAGS='-K PIC'
-	SHOBJ_LD=ld
-	SHOBJ_LDFLAGS='-G -dy -z text -h $@'
-
-	SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)'
-	;;
-
-sysv5UnixWare*-*gcc*)
-	SHOBJ_CFLAGS=-fpic
-	SHOBJ_LD='${CC}'
-	SHOBJ_LDFLAGS='-shared'
-
-	SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)'
-	;;
-
-sysv5UnixWare*)
-	SHOBJ_CFLAGS='-K PIC'
-	SHOBJ_LD=ld
-	SHOBJ_LDFLAGS='-G -dy -z text -h $@'
-
-	SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)'
-	;;
-
-sysv5OpenUNIX*-*gcc*)
-	SHOBJ_CFLAGS=-fpic
-	SHOBJ_LD='${CC}'
-	SHOBJ_LDFLAGS='-shared'
-
-	SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)'
-	;;
-
-sysv5OpenUNIX*)
-	SHOBJ_CFLAGS='-K PIC'
-	SHOBJ_LD=ld
-	SHOBJ_LDFLAGS='-G -dy -z text -h $@'
-
-	SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)'
-	;;
-
-dgux*-*gcc*)
-	SHOBJ_CFLAGS=-fpic
-	SHOBJ_LD='${CC}'
-	SHOBJ_LDFLAGS='-shared'
-
-	SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)'
-	;;
-
-dgux*)
-	SHOBJ_CFLAGS='-K pic'
-	SHOBJ_LD=ld
-	SHOBJ_LDFLAGS='-G -dy -h $@'
-
-	SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)'
-	;;
-
-msdos*)
-	SHOBJ_STATUS=unsupported
-	SHLIB_STATUS=unsupported
-	;;
-
-cygwin*)
-	SHOBJ_LD='$(CC)'
-        SHOBJ_LDFLAGS='-shared -Wl,--enable-auto-import -Wl,--enable-auto-image-base -Wl,--export-all -Wl,--out-implib=$(@).a'
-        SHLIB_LIBPREF='cyg'
-        SHLIB_LIBSUFF='dll'
-        SHLIB_LIBVERSION='$(SHLIB_DLLVERSION).$(SHLIB_LIBSUFF)'
-        SHLIB_LIBS='$(TERMCAP_LIB)'
-
-	SHLIB_DOT=
-        # For official cygwin releases, DLLVERSION will be defined in the
-        # environment of configure, and will be incremented any time the API
-        # changes in a non-backwards compatible manner.  Otherwise, it is just
-        # SHLIB_MAJOR.
-        if [ -n "$DLLVERSION" ] ; then
-		SHLIB_DLLVERSION="$DLLVERSION"
-        fi
-	;;
-
-#
-# Rely on correct gcc configuration for everything else
-#
-*-*gcc*)
-	SHOBJ_CFLAGS=-fpic
-	SHOBJ_LD='${CC}'
-	SHOBJ_LDFLAGS='-shared'
-
-	SHLIB_LIBVERSION='$(SHLIB_LIBSUFF).$(SHLIB_MAJOR)'
-	;;
-
-*)
-	SHOBJ_STATUS=unsupported
-	SHLIB_STATUS=unsupported
-	;;
-
-esac
-
-echo SHOBJ_CC=\'"$SHOBJ_CC"\'
-echo SHOBJ_CFLAGS=\'"$SHOBJ_CFLAGS"\'
-echo SHOBJ_LD=\'"$SHOBJ_LD"\'
-echo SHOBJ_LDFLAGS=\'"$SHOBJ_LDFLAGS"\'
-echo SHOBJ_XLDFLAGS=\'"$SHOBJ_XLDFLAGS"\'
-echo SHOBJ_LIBS=\'"$SHOBJ_LIBS"\'
-
-echo SHLIB_XLDFLAGS=\'"$SHLIB_XLDFLAGS"\'
-echo SHLIB_LIBS=\'"$SHLIB_LIBS"\'
-
-echo SHLIB_DOT=\'"$SHLIB_DOT"\'
-
-echo SHLIB_LIBPREF=\'"$SHLIB_LIBPREF"\'
-echo SHLIB_LIBSUFF=\'"$SHLIB_LIBSUFF"\'
-
-echo SHLIB_LIBVERSION=\'"$SHLIB_LIBVERSION"\'
-echo SHLIB_DLLVERSION=\'"$SHLIB_DLLVERSION"\'
-
-echo SHOBJ_STATUS=\'"$SHOBJ_STATUS"\'
-echo SHLIB_STATUS=\'"$SHLIB_STATUS"\'
-
-exit 0

test/--version.bats

@@ -2,10 +2,13 @@
 
 load test_helper
 
+export GIT_DIR="${RBENV_TEST_DIR}/.git"
+
 setup() {
   mkdir -p "$HOME"
   git config --global user.name  "Tester"
   git config --global user.email "tester@test.local"
+  cd "$RBENV_TEST_DIR"
 }
 
 git_commit() {
@@ -16,31 +19,37 @@ git_commit() {
   assert [ ! -e "$RBENV_ROOT" ]
   run rbenv---version
   assert_success
-  [[ $output == "rbenv 0."* ]]
+  [[ $output == "rbenv "?.?.? ]]
+}
+
+@test "doesn't read version from non-rbenv repo" {
+  git init
+  git remote add origin https://github.com/homebrew/homebrew.git
+  git_commit
+  git tag v1.0
+
+  run rbenv---version
+  assert_success
+  [[ $output == "rbenv "?.?.? ]]
 }
 
 @test "reads version from git repo" {
-  mkdir -p "$RBENV_ROOT"
-  cd "$RBENV_ROOT"
   git init
+  git remote add origin https://github.com/rbenv/rbenv.git
   git_commit
   git tag v0.4.1
   git_commit
   git_commit
 
-  cd "$RBENV_TEST_DIR"
   run rbenv---version
-  assert_success
+  assert_success "rbenv 0.4.1-2-g$(git rev-parse --short HEAD)"
-  [[ $output == "rbenv 0.4.1-2-g"* ]]
 }
 
 @test "prints default version if no tags in git repo" {
-  mkdir -p "$RBENV_ROOT"
-  cd "$RBENV_ROOT"
   git init
+  git remote add origin https://github.com/rbenv/rbenv.git
   git_commit
 
-  cd "$RBENV_TEST_DIR"
   run rbenv---version
-  [[ $output == "rbenv 0."* ]]
+  [[ $output == "rbenv "?.?.? ]]
 }

test/completions.bats

@@ -13,7 +13,7 @@ create_command() {
   create_command "rbenv-hello" "#!$BASH
     echo hello"
   run rbenv-completions hello
-  assert_success ""
+  assert_success "--help"
 }
 
 @test "command with completion support" {
@@ -25,7 +25,11 @@ else
   exit 1
 fi"
   run rbenv-completions hello
-  assert_success "hello"
+  assert_success
+  assert_output <<OUT
+--help
+hello
+OUT
 }
 
 @test "forwards extra arguments" {
@@ -40,6 +44,7 @@ fi"
   run rbenv-completions hello happy world
   assert_success
   assert_output <<OUT
+--help
 happy
 world
 OUT

test/exec.bats

@@ -17,7 +17,15 @@ create_executable() {
 @test "fails with invalid version" {
   export RBENV_VERSION="2.0"
   run rbenv-exec ruby -v
-  assert_failure "rbenv: version \`2.0' is not installed"
+  assert_failure "rbenv: version \`2.0' is not installed (set by RBENV_VERSION environment variable)"
+}
+
+@test "fails with invalid version set from file" {
+  mkdir -p "$RBENV_TEST_DIR"
+  cd "$RBENV_TEST_DIR"
+  echo 1.9 > .ruby-version
+  run rbenv-exec rspec
+  assert_failure "rbenv: version \`1.9' is not installed (set by $PWD/.ruby-version)"
 }
 
 @test "completes with names of executables" {
@@ -29,32 +37,20 @@ create_executable() {
   run rbenv-completions exec
   assert_success
   assert_output <<OUT
+--help
 rake
 ruby
 OUT
 }
 
-@test "supports hook path with spaces" {
-  hook_path="${RBENV_TEST_DIR}/custom stuff/rbenv hooks"
-  mkdir -p "${hook_path}/exec"
-  echo "export HELLO='from hook'" > "${hook_path}/exec/hello.bash"
-
-  export RBENV_VERSION=system
-  RBENV_HOOK_PATH="$hook_path" run rbenv-exec env
-  assert_success
-  assert_line "HELLO=from hook"
-}
-
 @test "carries original IFS within hooks" {
-  hook_path="${RBENV_TEST_DIR}/rbenv.d"
+  create_hook exec hello.bash <<SH
-  mkdir -p "${hook_path}/exec"
-  cat > "${hook_path}/exec/hello.bash" <<SH
 hellos=(\$(printf "hello\\tugly world\\nagain"))
 echo HELLO="\$(printf ":%s" "\${hellos[@]}")"
 SH
 
   export RBENV_VERSION=system
-  RBENV_HOOK_PATH="$hook_path" IFS=$' \t\n' run rbenv-exec env
+  IFS=$' \t\n' run rbenv-exec env
   assert_success
   assert_line "HELLO=:hello:ugly:world:again"
 }
@@ -91,7 +87,7 @@ OUT
 if [[ \$1 == "-S"* ]]; then
   found="\$(PATH="\${RUBYPATH:-\$PATH}" which \$2)"
   # assert that the found executable has ruby for shebang
-  if head -1 "\$found" | grep ruby >/dev/null; then
+  if head -n1 "\$found" | grep ruby >/dev/null; then
     \$BASH "\$found"
   else
     echo "ruby: no Ruby script found in input (LoadError)" >&2

test/global.bats

@@ -3,7 +3,7 @@
 load test_helper
 
 @test "default" {
-  run rbenv global
+  run rbenv-global
   assert_success
   assert_output "system"
 }
@@ -20,7 +20,7 @@ load test_helper
   mkdir -p "$RBENV_ROOT/versions/1.2.3"
   run rbenv-global "1.2.3"
   assert_success
-  run rbenv global
+  run rbenv-global
   assert_success "1.2.3"
 }
 

test/help.bats

@@ -5,8 +5,14 @@ load test_helper
 @test "without args shows summary of common commands" {
   run rbenv-help
   assert_success
-  assert_line "Usage: rbenv <command> [<args>]"
+  assert_line "Usage: rbenv <command> [<args>...]"
-  assert_line "Some useful rbenv commands are:"
+  assert_line "Commands to manage available Ruby versions:"
+}
+
+@test "usage flag" {
+  run rbenv-help --usage
+  assert_success
+  assert_output "Usage: rbenv <command> [<args>...]"
 }
 
 @test "invalid command" {
@@ -65,6 +71,18 @@ SH
   assert_success "Usage: rbenv hello <world>"
 }
 
+@test "empty usage section" {
+  mkdir -p "${RBENV_TEST_DIR}/bin"
+  cat > "${RBENV_TEST_DIR}/bin/rbenv-hello" <<SH
+#!shebang
+# Summary: Says "hello" to you, from rbenv
+echo hello
+SH
+
+  run rbenv-help --usage hello
+  assert_success "Usage: rbenv hello"
+}
+
 @test "multiline usage section" {
   mkdir -p "${RBENV_TEST_DIR}/bin"
   cat > "${RBENV_TEST_DIR}/bin/rbenv-hello" <<SH

test/hooks.bats

@@ -2,11 +2,6 @@
 
 load test_helper
 
-create_hook() {
-  mkdir -p "$1/$2"
-  touch "$1/$2/$3"
-}
-
 @test "prints usage help given no argument" {
   run rbenv-hooks
   assert_failure "Usage: rbenv hooks <command>"
@@ -15,11 +10,13 @@ create_hook() {
 @test "prints list of hooks" {
   path1="${RBENV_TEST_DIR}/rbenv.d"
   path2="${RBENV_TEST_DIR}/etc/rbenv_hooks"
-  create_hook "$path1" exec "hello.bash"
+  RBENV_HOOK_PATH="$path1"
-  create_hook "$path1" exec "ahoy.bash"
+  create_hook exec "hello.bash"
-  create_hook "$path1" exec "invalid.sh"
+  create_hook exec "ahoy.bash"
-  create_hook "$path1" which "boom.bash"
+  create_hook exec "invalid.sh"
-  create_hook "$path2" exec "bueno.bash"
+  create_hook which "boom.bash"
+  RBENV_HOOK_PATH="$path2"
+  create_hook exec "bueno.bash"
 
   RBENV_HOOK_PATH="$path1:$path2" run rbenv-hooks exec
   assert_success
@@ -33,8 +30,10 @@ OUT
 @test "supports hook paths with spaces" {
   path1="${RBENV_TEST_DIR}/my hooks/rbenv.d"
   path2="${RBENV_TEST_DIR}/etc/rbenv hooks"
-  create_hook "$path1" exec "hello.bash"
+  RBENV_HOOK_PATH="$path1"
-  create_hook "$path2" exec "ahoy.bash"
+  create_hook exec "hello.bash"
+  RBENV_HOOK_PATH="$path2"
+  create_hook exec "ahoy.bash"
 
   RBENV_HOOK_PATH="$path1:$path2" run rbenv-hooks exec
   assert_success
@@ -44,22 +43,28 @@ ${RBENV_TEST_DIR}/etc/rbenv hooks/exec/ahoy.bash
 OUT
 }
 
-@test "resolves relative paths" {
+@test "does not canonicalize paths" {
-  path="${RBENV_TEST_DIR}/rbenv.d"
+  RBENV_HOOK_PATH="${RBENV_TEST_DIR}/rbenv.d"
-  create_hook "$path" exec "hello.bash"
+  create_hook exec "hello.bash"
   mkdir -p "$HOME"
 
   RBENV_HOOK_PATH="${HOME}/../rbenv.d" run rbenv-hooks exec
-  assert_success "${RBENV_TEST_DIR}/rbenv.d/exec/hello.bash"
+  assert_success "${RBENV_TEST_DIR}/home/../rbenv.d/exec/hello.bash"
 }
 
-@test "resolves symlinks" {
+@test "does not resolve symlinks" {
   path="${RBENV_TEST_DIR}/rbenv.d"
   mkdir -p "${path}/exec"
   mkdir -p "$HOME"
   touch "${HOME}/hola.bash"
   ln -s "../../home/hola.bash" "${path}/exec/hello.bash"
+  touch "${path}/exec/bright.sh"
+  ln -s "bright.sh" "${path}/exec/world.bash"
 
   RBENV_HOOK_PATH="$path" run rbenv-hooks exec
-  assert_success "${HOME}/hola.bash"
+  assert_success
+  assert_output <<OUT
+${RBENV_TEST_DIR}/rbenv.d/exec/hello.bash
+${RBENV_TEST_DIR}/rbenv.d/exec/world.bash
+OUT
 }

test/init.bats

@@ -14,34 +14,102 @@ load test_helper
 @test "auto rehash" {
   run rbenv-init -
   assert_success
-  assert_line "rbenv rehash 2>/dev/null"
+  assert_line "command rbenv rehash 2>/dev/null"
 }
 
 @test "setup shell completions" {
   root="$(cd $BATS_TEST_DIRNAME/.. && pwd)"
   run rbenv-init - bash
   assert_success
-  assert_line "source '${root}/test/../libexec/../completions/rbenv.bash'"
+  assert_line "source '${root}/test/../completions/rbenv.bash'"
 }
 
 @test "detect parent shell" {
-  root="$(cd $BATS_TEST_DIRNAME/.. && pwd)"
   SHELL=/bin/false run rbenv-init -
   assert_success
   assert_line "export RBENV_SHELL=bash"
 }
 
-@test "setup shell completions (fish)" {
+@test "detect parent shell from script" {
+  mkdir -p "$RBENV_TEST_DIR"
+  cd "$RBENV_TEST_DIR"
+  cat > myscript.sh <<OUT
+#!/bin/sh
+eval "\$(rbenv-init -)"
+echo \$RBENV_SHELL
+OUT
+  chmod +x myscript.sh
+  run ./myscript.sh
+  assert_success "sh"
+}
+
+@test "skip shell completions (fish)" {
   root="$(cd $BATS_TEST_DIRNAME/.. && pwd)"
   run rbenv-init - fish
   assert_success
-  assert_line ". '${root}/test/../libexec/../completions/rbenv.fish'"
+  local line="$(grep '^source' <<<"$output")"
+  [ -z "$line" ] || flunk "did not expect line: $line"
 }
 
-@test "fish instructions" {
+@test "set up bash" {
+  assert [ ! -e ~/.bash_profile ]
+  run rbenv-init bash
+  assert_success "writing ~/.bash_profile: now configured for rbenv."
+  run cat ~/.bash_profile
+  # shellcheck disable=SC2016
+  assert_line 'eval "$(rbenv init - --no-rehash bash)"'
+}
+
+@test "set up bash (bashrc)" {
+  mkdir -p "$HOME"
+  touch ~/.bashrc
+  assert [ ! -e ~/.bash_profile ]
+  run rbenv-init bash
+  assert_success "writing ~/.bashrc: now configured for rbenv."
+  run cat ~/.bashrc
+  # shellcheck disable=SC2016
+  assert_line 'eval "$(rbenv init - --no-rehash bash)"'
+}
+
+@test "set up zsh" {
+  unset ZDOTDIR
+  assert [ ! -e ~/.zprofile ]
+  run rbenv-init zsh
+  assert_success "writing ~/.zprofile: now configured for rbenv."
+  run cat ~/.zprofile
+  # shellcheck disable=SC2016
+  assert_line 'eval "$(rbenv init - --no-rehash zsh)"'
+}
+
+@test "set up zsh (zshrc)" {
+  unset ZDOTDIR
+  mkdir -p "$HOME"
+  cat > ~/.zshrc <<<"# rbenv"
+  run rbenv-init zsh
+  assert_success "writing ~/.zshrc: now configured for rbenv."
+  run cat ~/.zshrc
+  # shellcheck disable=SC2016
+  assert_line 'eval "$(rbenv init - --no-rehash zsh)"'
+}
+
+@test "set up fish" {
+  unset XDG_CONFIG_HOME
   run rbenv-init fish
-  assert [ "$status" -eq 1 ]
+  assert_success "writing ~/.config/fish/config.fish: now configured for rbenv."
-  assert_line 'status --is-interactive; and . (rbenv init -|psub)'
+  run cat ~/.config/fish/config.fish
+  assert_line 'status --is-interactive; and rbenv init - --no-rehash fish | source'
+}
+
+@test "set up multiple shells at once" {
+  unset ZDOTDIR
+  unset XDG_CONFIG_HOME
+  run rbenv-init bash zsh fish
+  assert_success
+  assert_output <<OUT
+writing ~/.bash_profile: now configured for rbenv.
+writing ~/.zprofile: now configured for rbenv.
+writing ~/.config/fish/config.fish: now configured for rbenv.
+OUT
 }
 
 @test "option to skip rehash" {
@@ -61,7 +129,7 @@ load test_helper
   export PATH="${BATS_TEST_DIRNAME}/../libexec:/usr/bin:/bin:/usr/local/bin"
   run rbenv-init - fish
   assert_success
-  assert_line 0 "setenv PATH '${RBENV_ROOT}/shims' \$PATH"
+  assert_line 0 "set -gx PATH '${RBENV_ROOT}/shims' \$PATH"
 }
 
 @test "can add shims to PATH more than once" {
@@ -71,11 +139,11 @@ load test_helper
   assert_line 0 'export PATH="'${RBENV_ROOT}'/shims:${PATH}"'
 }
 
-@test "doesn't add shims to PATH more than once (fish)" {
+@test "can add shims to PATH more than once (fish)" {
   export PATH="${RBENV_ROOT}/shims:$PATH"
   run rbenv-init - fish
   assert_success
-  refute_line 'setenv PATH "'${RBENV_ROOT}'/shims" $PATH ;'
+  assert_line 0 "set -gx PATH '${RBENV_ROOT}/shims' \$PATH"
 }
 
 @test "outputs sh-compatible syntax" {

test/local.bats

@@ -19,24 +19,11 @@ setup() {
   assert_success "1.2.3"
 }
 
-@test "supports legacy .rbenv-version file" {
+@test "discovers version file in parent directory" {
-  echo "1.2.3" > .rbenv-version
-  run rbenv-local
-  assert_success "1.2.3"
-}
-
-@test "local .ruby-version has precedence over .rbenv-version" {
-  echo "1.8" > .rbenv-version
-  echo "2.0" > .ruby-version
-  run rbenv-local
-  assert_success "2.0"
-}
-
-@test "ignores version in parent directory" {
   echo "1.2.3" > .ruby-version
   mkdir -p "subdir" && cd "subdir"
   run rbenv-local
-  assert_failure
+  assert_success "1.2.3"
 }
 
 @test "ignores RBENV_DIR" {
@@ -64,40 +51,9 @@ setup() {
   assert [ "$(cat .ruby-version)" = "1.2.3" ]
 }
 
-@test "renames .rbenv-version to .ruby-version" {
-  echo "1.8.7" > .rbenv-version
-  mkdir -p "${RBENV_ROOT}/versions/1.9.3"
-  run rbenv-local
-  assert_success "1.8.7"
-  run rbenv-local "1.9.3"
-  assert_success
-  assert_output <<OUT
-rbenv: removed existing \`.rbenv-version' file and migrated
-       local version specification to \`.ruby-version' file
-OUT
-  assert [ ! -e .rbenv-version ]
-  assert [ "$(cat .ruby-version)" = "1.9.3" ]
-}
-
-@test "doesn't rename .rbenv-version if changing the version failed" {
-  echo "1.8.7" > .rbenv-version
-  assert [ ! -e "${RBENV_ROOT}/versions/1.9.3" ]
-  run rbenv-local "1.9.3"
-  assert_failure "rbenv: version \`1.9.3' not installed"
-  assert [ ! -e .ruby-version ]
-  assert [ "$(cat .rbenv-version)" = "1.8.7" ]
-}
-
 @test "unsets local version" {
   touch .ruby-version
   run rbenv-local --unset
   assert_success ""
-  assert [ ! -e .rbenv-version ]
+  assert [ ! -e .ruby-version ]
-}
-
-@test "unsets alternate version file" {
-  touch .rbenv-version
-  run rbenv-local --unset
-  assert_success ""
-  assert [ ! -e .rbenv-version ]
 }

test/prefix.bats

@@ -24,7 +24,22 @@ load test_helper
   assert_success "$RBENV_TEST_DIR"
 }
 
+@test "prefix for system in /" {
+  mkdir -p "${BATS_TEST_DIRNAME}/libexec"
+  cat >"${BATS_TEST_DIRNAME}/libexec/rbenv-which" <<OUT
+#!/bin/sh
+echo /bin/ruby
+OUT
+  chmod +x "${BATS_TEST_DIRNAME}/libexec/rbenv-which"
+  RBENV_VERSION="system" run rbenv-prefix
+  assert_success "/"
+  rm -f "${BATS_TEST_DIRNAME}/libexec/rbenv-which"
+}
+
 @test "prefix for invalid system" {
   PATH="$(path_without ruby)" run rbenv-prefix system
-  assert_failure "rbenv: system version not found in PATH"
+  assert_failure <<EOF
+rbenv: ruby: command not found
+rbenv: system version not found in PATH"
+EOF
 }

test/rbenv.bats

@@ -4,8 +4,8 @@ load test_helper
 
 @test "blank invocation" {
   run rbenv
-  assert_success
+  assert_failure
-  assert [ "${lines[0]}" = "rbenv 0.4.0" ]
+  assert_line 0 "$(rbenv---version)"
 }
 
 @test "invalid command" {
@@ -61,6 +61,12 @@ load test_helper
   assert_line 2 "${RBENV_ROOT}/plugins/rbenv-each/bin"
 }
 
+@test "RBENV_HOOK_PATH includes etc/rbenv.d folders" {
+  mkdir -p "$RBENV_ROOT"/plugins/rbenv-foo/etc/rbenv.d
+  run rbenv echo -F: "RBENV_HOOK_PATH"
+  assert_line 7 "${RBENV_ROOT}/plugins/rbenv-foo/etc/rbenv.d"
+}
+
 @test "RBENV_HOOK_PATH preserves value from environment" {
   RBENV_HOOK_PATH=/my/hook/path:/other/hooks run rbenv echo -F: "RBENV_HOOK_PATH"
   assert_success
@@ -70,6 +76,7 @@ load test_helper
 }
 
 @test "RBENV_HOOK_PATH includes rbenv built-in plugins" {
+  unset RBENV_HOOK_PATH
   run rbenv echo "RBENV_HOOK_PATH"
-  assert_success ":${RBENV_ROOT}/rbenv.d:${BATS_TEST_DIRNAME%/*}/rbenv.d:/usr/local/etc/rbenv.d:/etc/rbenv.d:/usr/lib/rbenv/hooks"
+  assert_success "${RBENV_ROOT}/rbenv.d:${BATS_TEST_DIRNAME%/*}/rbenv.d:/usr/etc/rbenv.d:/usr/local/etc/rbenv.d:/etc/rbenv.d:/usr/lib/rbenv/hooks"
 }

test/rehash.bats

@@ -3,10 +3,11 @@
 load test_helper
 
 create_executable() {
-  local bin="${RBENV_ROOT}/versions/${1}/bin"
+  local exe="${RBENV_ROOT}/versions/${1}/bin/${2}"
-  mkdir -p "$bin"
+  [ -n "$2" ] || exe="$1"
-  touch "${bin}/$2"
+  mkdir -p "${exe%/*}"
-  chmod +x "${bin}/$2"
+  touch "$exe"
+  chmod +x "$exe"
 }
 
 @test "empty rehash" {
@@ -104,16 +105,45 @@ ruby
 OUT
 }
 
+@test "no shims for user-installed gems" {
+  create_executable "2.7.5" "ruby"
+  create_executable "3.1.2" "ruby"
+  create_executable "${HOME}/.gem/ruby/2.7.0/bin/lolcat"
+  create_executable "${HOME}/.gem/ruby/3.1.0/bin/pinecone"
+
+  run rbenv-rehash
+  assert_success ""
+
+  assert [ ! -e "${RBENV_ROOT}/shims/lolcat" ]
+  assert [ ! -e "${RBENV_ROOT}/shims/pinecone" ]
+}
+
+@test "explicit gem home" {
+  create_executable "${HOME}/mygems/bin/lolcat"
+  create_executable "${HOME}/mygems/bin/pinecone"
+
+  assert [ ! -e "${RBENV_ROOT}/shims/lolcat" ]
+  assert [ ! -e "${RBENV_ROOT}/shims/pinecone" ]
+
+  GEM_HOME="${HOME}/mygems" run rbenv-rehash
+  assert_success ""
+
+  run ls "${RBENV_ROOT}/shims"
+  assert_success
+  assert_output <<OUT
+lolcat
+pinecone
+OUT
+}
+
 @test "carries original IFS within hooks" {
-  hook_path="${RBENV_TEST_DIR}/rbenv.d"
+  create_hook rehash hello.bash <<SH
-  mkdir -p "${hook_path}/rehash"
-  cat > "${hook_path}/rehash/hello.bash" <<SH
 hellos=(\$(printf "hello\\tugly world\\nagain"))
 echo HELLO="\$(printf ":%s" "\${hellos[@]}")"
 exit
 SH
 
-  RBENV_HOOK_PATH="$hook_path" IFS=$' \t\n' run rbenv-rehash
+  IFS=$' \t\n' run rbenv-rehash
   assert_success
   assert_output "HELLO=:hello:ugly:world:again"
 }

test/run

@@ -1,9 +1,4 @@
 #!/usr/bin/env bash
 set -e
 
-if [ -n "$RBENV_NATIVE_EXT" ]; then
+exec bats ${CI:+--tap} "${@:-test}"
-  src/configure
-  make -C src
-fi
-
-exec bats ${CI:+--tap} test

test/shell.bats

@@ -2,6 +2,17 @@
 
 load test_helper
 
+@test "shell integration disabled" {
+  run rbenv shell
+  assert_failure "rbenv: shell integration not enabled. Run \`rbenv init' for instructions."
+}
+
+@test "shell integration enabled" {
+  eval "$(rbenv init -)"
+  run rbenv shell
+  assert_success "rbenv: no shell-specific version configured"
+}
+
 @test "no shell version" {
   mkdir -p "${RBENV_TEST_DIR}/myproject"
   cd "${RBENV_TEST_DIR}/myproject"
@@ -20,14 +31,34 @@ load test_helper
   assert_success 'echo "$RBENV_VERSION"'
 }
 
+@test "shell revert" {
+  RBENV_SHELL=bash run rbenv-sh-shell -
+  assert_success
+  assert_line 0 'if [ -n "${RBENV_VERSION_OLD+x}" ]; then'
+}
+
+@test "shell revert (fish)" {
+  RBENV_SHELL=fish run rbenv-sh-shell -
+  assert_success
+  assert_line 0 'if set -q RBENV_VERSION_OLD'
+}
+
 @test "shell unset" {
   RBENV_SHELL=bash run rbenv-sh-shell --unset
-  assert_success "unset RBENV_VERSION"
+  assert_success
+  assert_output <<OUT
+RBENV_VERSION_OLD="\${RBENV_VERSION-}"
+unset RBENV_VERSION
+OUT
 }
 
 @test "shell unset (fish)" {
   RBENV_SHELL=fish run rbenv-sh-shell --unset
-  assert_success "set -e RBENV_VERSION"
+  assert_success
+  assert_output <<OUT
+set -gu RBENV_VERSION_OLD "\$RBENV_VERSION"
+set -e RBENV_VERSION
+OUT
 }
 
 @test "shell change invalid version" {
@@ -42,11 +73,29 @@ SH
 @test "shell change version" {
   mkdir -p "${RBENV_ROOT}/versions/1.2.3"
   RBENV_SHELL=bash run rbenv-sh-shell 1.2.3
-  assert_success 'export RBENV_VERSION="1.2.3"'
+  assert_success
+  assert_output <<OUT
+RBENV_VERSION_OLD="\${RBENV_VERSION-}"
+export RBENV_VERSION="1.2.3"
+OUT
+}
+
+@test "shell change version (zsh)" {
+  mkdir -p "${RBENV_ROOT}/versions/1.2.3"
+  RBENV_SHELL=zsh run rbenv-sh-shell 1.2.3
+  assert_success
+  assert_output <<OUT
+typeset -g RBENV_VERSION_OLD="\${RBENV_VERSION-}"
+export RBENV_VERSION="1.2.3"
+OUT
 }
 
 @test "shell change version (fish)" {
   mkdir -p "${RBENV_ROOT}/versions/1.2.3"
   RBENV_SHELL=fish run rbenv-sh-shell 1.2.3
-  assert_success 'setenv RBENV_VERSION "1.2.3"'
+  assert_success
+  assert_output <<OUT
+set -gu RBENV_VERSION_OLD "\$RBENV_VERSION"
+set -gx RBENV_VERSION "1.2.3"
+OUT
 }

test/test_helper.bash

@@ -1,20 +1,14 @@
 unset RBENV_VERSION
 unset RBENV_DIR
 
-if enable -f "${BATS_TEST_DIRNAME}"/../libexec/rbenv-realpath.dylib realpath 2>/dev/null; then
-  RBENV_TEST_DIR="$(realpath "$BATS_TMPDIR")/rbenv"
-else
-  if [ -n "$RBENV_NATIVE_EXT" ]; then
-    echo "rbenv: failed to load \`realpath' builtin" >&2
-    exit 1
-  fi
-  RBENV_TEST_DIR="${BATS_TMPDIR}/rbenv"
-fi
-
 # guard against executing this block twice due to bats internals
-if [ "$RBENV_ROOT" != "${RBENV_TEST_DIR}/root" ]; then
+if [ -z "$RBENV_TEST_DIR" ]; then
+  RBENV_TEST_DIR="${BATS_TMPDIR}/rbenv"
+  export RBENV_TEST_DIR="$(mktemp -d "${RBENV_TEST_DIR}.XXX" 2>/dev/null || echo "$RBENV_TEST_DIR")"
+
   export RBENV_ROOT="${RBENV_TEST_DIR}/root"
   export HOME="${RBENV_TEST_DIR}/home"
+  export RBENV_HOOK_PATH="${RBENV_ROOT}/rbenv.d"
 
   PATH=/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin
   PATH="${RBENV_TEST_DIR}/bin:$PATH"
@@ -22,6 +16,9 @@ if [ "$RBENV_ROOT" != "${RBENV_TEST_DIR}/root" ]; then
   PATH="${BATS_TEST_DIRNAME}/libexec:$PATH"
   PATH="${RBENV_ROOT}/shims:$PATH"
   export PATH
+
+  for xdg_var in `env 2>/dev/null | grep ^XDG_ | cut -d= -f1`; do unset "$xdg_var"; done
+  unset xdg_var
 fi
 
 teardown() {
@@ -106,20 +103,29 @@ assert() {
 # but in which system utils necessary for rbenv operation are still available.
 path_without() {
   local exe="$1"
-  local path="${PATH}:"
+  local path=":${PATH}:"
   local found alt util
-  for found in $(which -a "$exe"); do
+  for found in $(type -aP "$exe"); do
     found="${found%/*}"
     if [ "$found" != "${RBENV_ROOT}/shims" ]; then
       alt="${RBENV_TEST_DIR}/$(echo "${found#/}" | tr '/' '-')"
       mkdir -p "$alt"
-      for util in bash head cut readlink greadlink; do
+      for util in bash head cut readlink greadlink sed sort awk; do
         if [ -x "${found}/$util" ]; then
           ln -s "${found}/$util" "${alt}/$util"
         fi
       done
-      path="${path/${found}:/${alt}:}"
+      path="${path/:${found}:/:${alt}:}"
     fi
   done
+  path="${path#:}"
   echo "${path%:}"
 }
+
+create_hook() {
+  mkdir -p "${RBENV_HOOK_PATH}/$1"
+  touch "${RBENV_HOOK_PATH}/$1/$2"
+  if [ ! -t 0 ]; then
+    cat > "${RBENV_HOOK_PATH}/$1/$2"
+  fi
+}

test/version-file-read.bats

@@ -70,3 +70,19 @@ IN
   run rbenv-version-file-read my-version
   assert_success "1.9.3"
 }
+
+@test "prevents directory traversal" {
+  cat > my-version <<<".."
+  run rbenv-version-file-read my-version
+  assert_failure "rbenv: invalid version in \`my-version'"
+
+  cat > my-version <<<"../foo"
+  run rbenv-version-file-read my-version
+  assert_failure "rbenv: invalid version in \`my-version'"
+}
+
+@test "disallows path segments in version string" {
+  cat > my-version <<<"foo/bar"
+  run rbenv-version-file-read my-version
+  assert_failure "rbenv: invalid version in \`my-version'"
+}

test/version-file.bats

@@ -9,7 +9,13 @@ setup() {
 
 create_file() {
   mkdir -p "$(dirname "$1")"
-  touch "$1"
+  echo "system" > "$1"
+}
+
+@test "detects global 'version' file" {
+  create_file "${RBENV_ROOT}/version"
+  run rbenv-version-file
+  assert_success "${RBENV_ROOT}/version"
 }
 
 @test "prints global file if no version files exist" {
@@ -19,45 +25,12 @@ create_file() {
   assert_success "${RBENV_ROOT}/version"
 }
 
-@test "detects 'global' file" {
-  create_file "${RBENV_ROOT}/global"
-  run rbenv-version-file
-  assert_success "${RBENV_ROOT}/global"
-}
-
-@test "detects 'default' file" {
-  create_file "${RBENV_ROOT}/default"
-  run rbenv-version-file
-  assert_success "${RBENV_ROOT}/default"
-}
-
-@test "'version' has precedence over 'global' and 'default'" {
-  create_file "${RBENV_ROOT}/version"
-  create_file "${RBENV_ROOT}/global"
-  create_file "${RBENV_ROOT}/default"
-  run rbenv-version-file
-  assert_success "${RBENV_ROOT}/version"
-}
-
 @test "in current directory" {
   create_file ".ruby-version"
   run rbenv-version-file
   assert_success "${RBENV_TEST_DIR}/.ruby-version"
 }
 
-@test "legacy file in current directory" {
-  create_file ".rbenv-version"
-  run rbenv-version-file
-  assert_success "${RBENV_TEST_DIR}/.rbenv-version"
-}
-
-@test ".ruby-version has precedence over legacy file" {
-  create_file ".ruby-version"
-  create_file ".rbenv-version"
-  run rbenv-version-file
-  assert_success "${RBENV_TEST_DIR}/.ruby-version"
-}
-
 @test "in parent directory" {
   create_file ".ruby-version"
   mkdir -p project
@@ -74,14 +47,6 @@ create_file() {
   assert_success "${RBENV_TEST_DIR}/project/.ruby-version"
 }
 
-@test "legacy file has precedence if higher" {
-  create_file ".ruby-version"
-  create_file "project/.rbenv-version"
-  cd project
-  run rbenv-version-file
-  assert_success "${RBENV_TEST_DIR}/project/.rbenv-version"
-}
-
 @test "RBENV_DIR has precedence over PWD" {
   create_file "widget/.ruby-version"
   create_file "project/.ruby-version"
@@ -97,3 +62,14 @@ create_file() {
   RBENV_DIR="${RBENV_TEST_DIR}/widget/blank" run rbenv-version-file
   assert_success "${RBENV_TEST_DIR}/project/.ruby-version"
 }
+
+@test "finds version file in target directory" {
+  create_file "project/.ruby-version"
+  run rbenv-version-file "${PWD}/project"
+  assert_success "${RBENV_TEST_DIR}/project/.ruby-version"
+}
+
+@test "fails when no version file in target directory" {
+  run rbenv-version-file "$PWD"
+  assert_failure ""
+}

test/version-name.bats

@@ -17,11 +17,32 @@ setup() {
   assert_success "system"
 }
 
-@test "system version is not checked for existance" {
+@test "system version is not checked for existence" {
   RBENV_VERSION=system run rbenv-version-name
   assert_success "system"
 }
 
+@test "RBENV_VERSION can be overridden by hook" {
+  create_version "1.8.7"
+  create_version "1.9.3"
+  create_hook version-name test.bash <<<"RBENV_VERSION=1.9.3"
+
+  RBENV_VERSION=1.8.7 run rbenv-version-name
+  assert_success "1.9.3"
+}
+
+@test "carries original IFS within hooks" {
+  create_hook version-name hello.bash <<SH
+hellos=(\$(printf "hello\\tugly world\\nagain"))
+echo HELLO="\$(printf ":%s" "\${hellos[@]}")"
+SH
+
+  export RBENV_VERSION=system
+  IFS=$' \t\n' run rbenv-version-name env
+  assert_success
+  assert_line "HELLO=:hello:ugly:world:again"
+}
+
 @test "RBENV_VERSION has precedence over local" {
   create_version "1.8.7"
   create_version "1.9.3"
@@ -49,7 +70,7 @@ setup() {
 
 @test "missing version" {
   RBENV_VERSION=1.2 run rbenv-version-name
-  assert_failure "rbenv: version \`1.2' is not installed"
+  assert_failure "rbenv: version \`1.2' is not installed (set by RBENV_VERSION environment variable)"
 }
 
 @test "version with prefix in name" {

test/version-origin.bats

@@ -26,13 +26,31 @@ setup() {
 }
 
 @test "detects local file" {
-  touch .ruby-version
+  echo "system" > .ruby-version
   run rbenv-version-origin
   assert_success "${PWD}/.ruby-version"
 }
 
-@test "detects alternate version file" {
+@test "reports from hook" {
-  touch .rbenv-version
+  create_hook version-origin test.bash <<<"RBENV_VERSION_ORIGIN=plugin"
-  run rbenv-version-origin
+
-  assert_success "${PWD}/.rbenv-version"
+  RBENV_VERSION=1 run rbenv-version-origin
+  assert_success "plugin"
+}
+
+@test "carries original IFS within hooks" {
+  create_hook version-origin hello.bash <<SH
+hellos=(\$(printf "hello\\tugly world\\nagain"))
+echo HELLO="\$(printf ":%s" "\${hellos[@]}")"
+SH
+
+  export RBENV_VERSION=system
+  IFS=$' \t\n' run rbenv-version-origin env
+  assert_success
+  assert_line "HELLO=:hello:ugly:world:again"
+}
+
+@test "doesn't inherit RBENV_VERSION_ORIGIN from environment" {
+  RBENV_VERSION_ORIGIN=ignored run rbenv-version-origin
+  assert_success "${RBENV_ROOT}/version"
 }

test/version.bats

@@ -14,7 +14,7 @@ setup() {
 @test "no version selected" {
   assert [ ! -d "${RBENV_ROOT}/versions" ]
   run rbenv-version
-  assert_success "system (set by ${RBENV_ROOT}/version)"
+  assert_success "system"
 }
 
 @test "set by RBENV_VERSION" {
@@ -36,3 +36,12 @@ setup() {
   run rbenv-version
   assert_success "1.9.3 (set by ${RBENV_ROOT}/version)"
 }
+
+@test "prefer local over global file" {
+  create_version "1.9.3"
+  create_version "3.0.0"
+  cat > ".ruby-version" <<<"1.9.3"
+  cat > "${RBENV_ROOT}/version" <<<"3.0.0"
+  run rbenv-version
+  assert_success "1.9.3 (set by ${PWD}/.ruby-version)"
+}

test/versions.bats

@@ -21,7 +21,7 @@ stub_system_ruby() {
   stub_system_ruby
   assert [ ! -d "${RBENV_ROOT}/versions" ]
   run rbenv-versions
-  assert_success "* system (set by ${RBENV_ROOT}/version)"
+  assert_success "* system"
 }
 
 @test "not even system ruby available" {
@@ -42,7 +42,7 @@ stub_system_ruby() {
   run rbenv-versions
   assert_success
   assert_output <<OUT
-* system (set by ${RBENV_ROOT}/version)
+* system
   1.9
 OUT
 }
@@ -56,15 +56,21 @@ OUT
 @test "multiple versions" {
   stub_system_ruby
   create_version "1.8.7"
-  create_version "1.9.3"
+  create_version "1.9.3-p13"
-  create_version "2.0.0"
+  create_version "1.9.3-p2"
+  create_version "2.2.10"
+  create_version "2.2.3"
+  create_version "2.2.3-pre.2"
   run rbenv-versions
   assert_success
   assert_output <<OUT
-* system (set by ${RBENV_ROOT}/version)
+* system
   1.8.7
-  1.9.3
+  1.9.3-p2
-  2.0.0
+  1.9.3-p13
+  2.2.3-pre.2
+  2.2.3
+  2.2.10
 OUT
 }
 
@@ -139,3 +145,18 @@ OUT
 1.8.7
 OUT
 }
+
+@test "doesn't list symlink aliases when --skip-aliases" {
+  create_version "1.8.7"
+  ln -s "1.8.7" "${RBENV_ROOT}/versions/1.8"
+  mkdir moo
+  ln -s "${PWD}/moo" "${RBENV_ROOT}/versions/1.9"
+
+  run rbenv-versions --bare --skip-aliases
+  assert_success
+
+  assert_output <<OUT
+1.8.7
+1.9
+OUT
+}

test/which.bats

@@ -56,24 +56,42 @@ create_executable() {
   assert_success "${RBENV_TEST_DIR}/bin/kill-all-humans"
 }
 
+@test "doesn't include current directory in PATH search" {
+  bats_require_minimum_version 1.5.0
+  mkdir -p "$RBENV_TEST_DIR"
+  cd "$RBENV_TEST_DIR"
+  touch kill-all-humans
+  chmod +x kill-all-humans
+  PATH="$(path_without "kill-all-humans")" RBENV_VERSION=system run -127 rbenv-which kill-all-humans
+  assert_failure "rbenv: kill-all-humans: command not found"
+}
+
 @test "version not installed" {
   create_executable "2.0" "rspec"
   RBENV_VERSION=1.9 run rbenv-which rspec
-  assert_failure "rbenv: version \`1.9' is not installed"
+  assert_failure "rbenv: version \`1.9' is not installed (set by RBENV_VERSION environment variable)"
 }
 
 @test "no executable found" {
+  bats_require_minimum_version 1.5.0
   create_executable "1.8" "rspec"
-  RBENV_VERSION=1.8 run rbenv-which rake
+  RBENV_VERSION=1.8 run -127 rbenv-which rake
+  assert_failure "rbenv: rake: command not found"
+}
+
+@test "no executable found for system version" {
+  bats_require_minimum_version 1.5.0
+  PATH="$(path_without "rake")" RBENV_VERSION=system run -127 rbenv-which rake
   assert_failure "rbenv: rake: command not found"
 }
 
 @test "executable found in other versions" {
+  bats_require_minimum_version 1.5.0
   create_executable "1.8" "ruby"
   create_executable "1.9" "rspec"
   create_executable "2.0" "rspec"
 
-  RBENV_VERSION=1.8 run rbenv-which rspec
+  RBENV_VERSION=1.8 run -127 rbenv-which rspec
   assert_failure
   assert_output <<OUT
 rbenv: rspec: command not found
@@ -84,16 +102,37 @@ The \`rspec' command exists in these Ruby versions:
 OUT
 }
 
+@test "executable not found in user gems" {
+  bats_require_minimum_version 1.5.0
+  create_executable "2.7.6" "ruby"
+  create_executable "${HOME}/.gem/ruby/2.7.0/bin" "rake"
+  GEM_HOME='' RBENV_VERSION=2.7.6 run -127 rbenv-which rake
+  assert_failure
+}
+
+@test "executable found in gem home" {
+  create_executable "2.7.6" "ruby"
+  create_executable "${HOME}/mygems/bin" "rake"
+  create_executable "${HOME}/.gem/ruby/2.7.0/bin" "rake"
+  GEM_HOME="${HOME}/mygems" RBENV_VERSION=2.7.6 run rbenv-which rake
+  assert_success "${HOME}/mygems/bin/rake"
+}
+
+@test "executable found in gem home (system ruby)" {
+  create_executable "${HOME}/mygems/bin" "rbenv-test-lolcat"
+  create_executable "${HOME}/.gem/ruby/2.6.0/bin" "rbenv-test-lolcat"
+  GEM_HOME="${HOME}/mygems" RBENV_VERSION=system run rbenv-which rbenv-test-lolcat
+  assert_success "${HOME}/mygems/bin/rbenv-test-lolcat"
+}
+
 @test "carries original IFS within hooks" {
-  hook_path="${RBENV_TEST_DIR}/rbenv.d"
+  create_hook which hello.bash <<SH
-  mkdir -p "${hook_path}/which"
-  cat > "${hook_path}/which/hello.bash" <<SH
 hellos=(\$(printf "hello\\tugly world\\nagain"))
 echo HELLO="\$(printf ":%s" "\${hellos[@]}")"
 exit
 SH
 
-  RBENV_HOOK_PATH="$hook_path" IFS=$' \t\n' RBENV_VERSION=system run rbenv-which anything
+  IFS=$' \t\n' RBENV_VERSION=system run rbenv-which anything
   assert_success
   assert_output "HELLO=:hello:ugly:world:again"
 }
@@ -106,6 +145,6 @@ SH
   mkdir -p "$RBENV_TEST_DIR"
   cd "$RBENV_TEST_DIR"
 
-  RBENV_VERSION= run rbenv-which ruby
+  RBENV_VERSION='' run rbenv-which ruby
   assert_success "${RBENV_ROOT}/versions/1.8/bin/ruby"
 }