Install Ruby before bundler (#1684)

* Revert "Revert v334 (#1682)"

This reverts commit 57462aa.

* Changelog

* Inject environment name

The modification in #1676 accidentally saw "test" replaced with "production" as the inheritance-based logic was no longer being invoked.

This change threads the value ("production" or "test") used through the lifecycle of the buildpack.

* Don't export bootstrap Ruby on PATH (And Fix "herokuish" CI test case)

Previously the Ruby buildpack worked like this:

- Install a "bootstrap" version of Ruby
- Use bootstrap ruby to execute the buildpack code (written in ruby)
- Download customer's bundler version
- Run that bundler version with bootstrap ruby to determine customer's ruby version `bundle platform --ruby`
- ...

With that flow, it's required that the Ruby program must be able to re-exec itself since it must have a Ruby version to run and a ruby version to run `bundle platform --ruby`.

The code was changed such that it now looks like this:

- Install a "bootstrap" version of Ruby
- Use bootstrap ruby to execute the buildpack code (written in ruby)
- Statically determine Ruby version from the Gemfile.lock
- Install customer's Ruby version
- Install customer's bundler version
- ...

With this flow, we do not ever need to re-exec the bootstrap ruby version. This lets us remove exporting it to the PATH which has caused a LOT of problems over the years.

As mentioned it also fixes the "herokuish" bug that was introduced in v334 (then rolled back). I was able to reproduce the bug via a test added in #1687. The test uses a different version of Ruby than the "bootstrap" version. The problem was this error:

```
Running: which -a ruby
  /app/bin/ruby
  /tmp/tmp.Dx6ifBJLoP/bin//ruby
  /app/bin/ruby
Running: which -a bundle
  /tmp/tmp.Dx6ifBJLoP/bin//bundle
  /app/vendor/bundle/bin/bundle
  /app/vendor/bundle/ruby/3.1.0/bin/bundle
Running: bundle list
/tmp/buildpacks/5332b9a13007e20408c130cf3c47b025a8417ef0/lib/language_pack/helpers/bundle_list.rb:56:in `call': Error detecting dependencies (LanguagePack::Helpers::BundleList::CmdError)

The Ruby buildpack requires information about your application???s dependencies to
complete the build. Without this information, the Ruby buildpack cannot continue.

Command failed: `bundle list`

Could not find sinatra-4.2.1, puma-7.1.0, rack-3.2.4, rake-13.3.1, rackup-2.3.1, rack-test-2.2.0, test-unit-3.7.3, logger-1.7.0, mustermann-3.0.4, rack-protection-4.2.1, rack-session-2.1.1, tilt-2.6.1, nio4r-2.7.4, power_assert-3.0.1, base64-0.3.0 in locally installed gems
Install missing gems with `bundle install`.
```

(Debugging output added for later explanation)

This comes from a Heroku CI run which works by executing `bin/test-compile` (installing ruby and bundler etc.) and then calling `bin/test`. The `bin/test` already has a full ruby + bundler environment setup and ready to go, but we still download a bootstrap version of ruby so that the code only ever has to support one Ruby version (rather than N versions across the lifecycle of M stacks).

What's happening in the output is that we see that `ruby` being used is `/app/bin/ruby` (local `./bin` binstub) because we forced it onto the path via: 

```
LanguagePack::ShellHelpers.user_env_hash["PATH"] = "#{app_path.join("bin")}:#{ENV["PATH"]}"
```

However the `bundle` executable is pointing to `/tmp/tmp.Dx6ifBJLoP/bin//bundle` instead of the correct `/app/vendor/bundle/bin/bundle` because we don't symlink that to the binstub directory (people expect to check in their `./bin/bundle` binstub and not have it overwritten). And because the PATH has the bootstrap ruby directory `/tmp/tmp.Dx6ifBJLoP/bin/` and that also includes a `bundle` executable, it uses that to call `gem list`.

Why weren't all of the tests failing? Well, the gems are installed to `./vendor/bundle/ruby/<major>.<minor>.0/`. The bundler that ships with ruby doesn't use PATH but instead is hardcoded to use the version of ruby it was shipped with:

```
$ chruby 3.3.9
$ cat $HOME/.rubies/ruby-3.3.9/bin/bundle
#!/Users/rschneeman/.rubies/ruby-3.3.9/bin/ruby
```

Or

```
$ curl https://heroku-buildpack-ruby.s3.us-east-1.amazonaws.com/heroku-24/arm64/ruby-4.0.0.preview3-bb0a79e.tgz -O
$ ...
$ cat ruby-4.0.0.preview3-bb0a79e/bin/bundle
#!/bin/sh
# -*- ruby -*-
# This file was generated by RubyGems.
#
# The application 'bundler' is installed as part of a gem, and
# this file is here to facilitate running it.
#
_=_\
=begin
bindir="${0%/*}"
exec "$bindir/ruby" "-x" "$0" "$@"
=end
#!/usr/bin/env ruby
```

Now, bundler is smart enough to look in `./vendor/bundle/ruby/<major>.<minor>.0/` when BUNDLE_DEPLOYMENT is set, BUT since it's being executed with the bootstrap ruby version, it will always be looking in `./vendor/bundle/ruby/3.3.0/` (bootstrap ruby version is 3.3.9 now). The test fails because it's using Ruby 3.1.3 which has gems installed to `./vendor/bundle/ruby/3.1.0/` which doesn't exist, so `gem list` fails to find any of the gems (because it's looking at the wrong directory because it was accidentally executed with the wrong ruby version.

Previously the fix was to exploit the "user provided environment variables" for a purpose it was never intended for, to put the customer's PATH first (in front of the bootstrap ruby version):

```
# - Add bundler's bin directory to the PATH
# - Always make sure `$HOME/bin` is first on the path
user_env_hash["PATH"] = "#{build_dir}/bin:#{bundler.bundler_path}/bin:#{user_env_hash["PATH"]}"
user_env_hash["GEM_PATH"] = LanguagePack::Ruby.slug_vendor_base
```

This approach requires knowing the bundler_path which is now derived like this:

```
  # ...
  class RubyVersion
    # Ruby versioned bundler directory
    #
    # When installing gems via `BUNDLE_DEPLOYMENT=1 bundle install`, they're installed into a versioned directory based on the ruby version.
    #
    # This becomes the location of GEM_PATH on disk https://www.schneems.com/2014/04/15/gem-path.html.
    # - Executables are at bundler_directory.join("bin")
    # - Gems are at bundler_directory.join("gems")
    #
    # For example:
    #
    # - Ruby 3.4.7 would be "vendor/bundle/ruby/3.4.0"
    # - JRuby 9.4.14.0 would be "vendor/bundle/jruby/3.1.0" (As it implements Ruby 3.1.7 spec)
    def bundler_directory
      "vendor/bundle/#{engine}/#{major}.#{minor}.0"
    end
```

OR previously it was the same as `slug_vendor_base` which is derived by shelling out:

```
  # For example "vendor/bundle/ruby/2.6.0"
  def self.slug_vendor_base
    @slug_vendor_base ||= begin
      command = %q(ruby -e "require 'rbconfig';puts \"vendor/bundle/#{RUBY_ENGINE}/#{RbConfig::CONFIG['ruby_version']}\"")
      out = run_no_pipe(command, user_env: true).strip
      error "Problem detecting bundler vendor directory: #{out}" unless $?.success?
      out
    end
  end
```

A better approach such as un-shifting the first value of path, or passing the bootstrap ruby version wasn't really feasible due to the architecture of the program. The refactoring that happened in v334 (that is reverted and re-applied in this PR) enabled this seemingly small, but very impactful simplification (removing re-exporting of the bootstrap PATH).

* Modify CI test to exercise `bin/test` code

Previously this test worked by using the `app.json` to define a test script. When that happens, the `bin/test` code is completely bypassed, so it's not under test.

This new modification instead uses the `bin/test` logic to call `bin/rake test` and that file prints the same information using the same script.

While the assertions in the test on this branch didn't need to change (except for asserting `bin/rake` is now in the `bin` directory), they will fail on `main` due to the way that `bin/test` is implemented, it resolves path order differently which can cause different execution behavior than if you define a test via `app.json` and different than the normally deployed Heroku app (in production).

* CHANGELOG

* Fix CI failure

With the new fix for PATH for `bin/test` Heroku CI users, this was accidentally working. This is the change in that test app:

```
$ git diff HEAD~1
diff --git a/Gemfile.lock b/Gemfile.lock
index 89b041a..b8f5c7a 100644
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -1,8 +1,10 @@
 GEM
   remote: https://rubygems.org/
   specs:
-    minitest (5.11.3)
-    rake (12.3.1)
+    minitest (6.0.0)
+      prism (~> 1.5)
+    prism (1.7.0)
+    rake (13.2.1)

 PLATFORMS
   ruby
```

When the path was fixed it started failing with an error:

```
-----> Running test: rake test
rake aborted!
NoMethodError: undefined method `=~' for an instance of Proc
/app/vendor/bundle/ruby/3.3.0/gems/rake-12.3.1/exe/rake:27:in `<top (required)>'
(See full trace by running task with --trace)
-----> Ruby buildpack tests failed with exit status 1
# ./vendor/bundle/ruby/3.3.0/gems/heroku_hatchet-8.0.6/lib/hatchet/test_run.rb:135:in `block in wait!'
# /opt/hostedtoolcache/Ruby/3.3.9/x64/lib/ruby/3.3.0/timeout.rb:186:in `block in timeout'
# /opt/hostedtoolcache/Ruby/3.3.9/x64/lib/ruby/3.3.0/timeout.rb:41:in `handle_timeout'
# /opt/hostedtoolcache/Ruby/3.3.9/x64/lib/ruby/3.3.0/timeout.rb:195:in `timeout'
# ./vendor/bundle/ruby/3.3.0/gems/heroku_hatchet-8.0.6/lib/hatchet/test_run.rb:127:in `wait!'
```

It was working before because previously the path was different:

```
$ which -a rake
vendor/bundle/ruby/3.3.0/bin/rake
/tmp/tmp.V7sALmG2lV/bin//rake
/app/vendor/bundle/bin/rake
/app/vendor/bundle/ruby/3.3.0/bin/rake
```

This called `/app/vendor/bundle/ruby/3.3.0/bin/rake` (expanded from relative path) this is a RubyGems binstub and not a Bundler binstub. That means it does NOT use the Gemfile.lock to load gems. This is the binstub:

```
~ $ cat vendor/bundle/ruby/3.3.0/bin/rake
#!/usr/bin/env ruby
#
# This file was generated by RubyGems.
#
# The application 'rake' is installed as part of a gem, and
# this file is here to facilitate running it.
#

require 'rubygems'

Gem.use_gemdeps

version = ">= 0.a"

str = ARGV.first
if str
  str = str.b[/\A_(.*)_\z/, 1]
  if str and Gem::Version.correct?(str)
    version = str
    ARGV.shift
  end
end

if Gem.respond_to?(:activate_bin_path)
load Gem.activate_bin_path('rake', 'rake', version)
else
gem "rake", version
load Gem.bin_path("rake", "rake", version)
end
```

This code will execute this path:

```
load Gem.activate_bin_path('rake', 'rake', version)
```

With a version of `>= 0.a` and produce a load path of `/app/vendor/ruby-3.3.9/lib/ruby/gems/3.3.0/gems/rake-13.1.0/exe/rake` this path is the default gem that ships with Ruby 3.3.0.

But now:

```
$ which -a rake
/app/vendor/bundle/bin/rake
/app/vendor/bundle/ruby/3.3.0/bin/rake
```

This will call `/app/vendor/bundle/bin` which loads bundler and is effectively the same as calling `bundle exec rake`.

```
~ $ cat vendor/bundle/bin/rake
#!/usr/bin/env ruby
# frozen_string_literal: true

#
# This file was generated by Bundler.
#
# The application 'rake' is installed as part of a gem, and
# this file is here to facilitate running it.
#

ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../../Gemfile", __dir__)

bundle_binstub = File.expand_path("bundle", __dir__)

if File.file?(bundle_binstub)
  if File.read(bundle_binstub, 300).include?("This file was generated by Bundler")
    load(bundle_binstub)
  else
    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
  end
end

require "rubygems"
require "bundler/setup"

load Gem.bin_path("rake", "rake")
```

This will use the bundled version of rake such that `Gem.bin_path` returns `/app/vendor/bundle/ruby/3.3.0/gems/rake-12.3.1/exe/rake` and Rake 12.3.1 is used.

Rake 12.3.1 is incompatible with Ruby 3.3 so it fails.

Notably it SHOULD fail as this is what happens when you `git push heroku` on the same code:

```
~ $ rake -v
rake aborted!
NoMethodError: undefined method `=~' for an instance of Proc
/app/vendor/bundle/ruby/3.3.0/gems/rake-12.3.1/exe/rake:27:in `<top (required)>'
```

So the problem is in the app, which needs to be updated.

Author: schneems

CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+- Ruby is now installed before bundler. Previously, Bundler was used to detect the Ruby version by calling
+  `bundle platform --ruby`. Now that the Ruby version is detected directly from the  `Gemfile.lock`, the
+  order of installation can be changed such that Ruby is installed before Bundler.
+
+  This change should be a refactor (no observed change in build behavior), but involved substantial
+  internal changes. If your app can build with `https://github.com/heroku/heroku-buildpack-ruby#v335`
+  but not with this version, please open a support ticket https://help.heroku.com/. (https://github.com/heroku/heroku-buildpack-ruby/pull/1684)
+- The `PATH` order on Heroku CI relying on `bin/test` interface has changed for applications using the `heroku/ruby`
+  buildpack. It now starts with: `/app/bin:/app/vendor/bundle/bin:/app/vendor/bundle/ruby/3.3.0/bin` which matches
+  the behavior of regular `git push heroku` and customers who specify tests via `app.json`.
+  (https://github.com/heroku/heroku-buildpack-ruby/pull/1684)
+
 
 ## [v338] - 2025-12-25
 
@@ -24,7 +36,7 @@
 
 ## [v334] - 2025-12-12
 
-- Rolled back
+- Rolled back due to https://github.com/heroku/heroku-buildpack-ruby/issues/1681
 
 ## [v333] - 2025-12-03
 
@@ -1845,6 +1857,7 @@ Bugfixes:
 [v337]: https://github.com/heroku/heroku-buildpack-ruby/compare/v336...v337
 [v336]: https://github.com/heroku/heroku-buildpack-ruby/compare/v335...v336
 [v335]: https://github.com/heroku/heroku-buildpack-ruby/compare/v334...v335
+[v334]: https://github.com/heroku/heroku-buildpack-ruby/compare/v333...v334
 [v333]: https://github.com/heroku/heroku-buildpack-ruby/compare/v332...v333
 [v332]: https://github.com/heroku/heroku-buildpack-ruby/compare/v331...v332
 [v331]: https://github.com/heroku/heroku-buildpack-ruby/compare/v330...v331

bin/compile

@@ -27,9 +27,6 @@ else
 fi
 trap 'rm -rf "$bootstrap_ruby_dir"' EXIT
 
-export PATH="$bootstrap_ruby_dir/bin/:$PATH"
-unset GEM_PATH
-
 if detect_needs_java "$BUILD_DIR"; then
   cat <<EOM
 

bin/support/ruby_compile.rb

@@ -21,14 +21,12 @@
   Dir.chdir(app_path)
 
   LanguagePack::ShellHelpers.initialize_env(ARGV[2])
-  if pack = LanguagePack.detect(
+  LanguagePack.call(
     app_path: app_path,
     cache_path: cache_path,
-    gemfile_lock: gemfile_lock
+    gemfile_lock: gemfile_lock,
+    bundle_default_without: "development:test",
   )
-    pack.topic("Compiling #{pack.name}")
-    pack.compile
-  end
 rescue Exception => e
   LanguagePack::ShellHelpers.display_error_and_exit(e)
 end

bin/support/ruby_test-compile.rb

@@ -24,15 +24,14 @@
   gemfile_lock = LanguagePack.gemfile_lock(app_path: app_path)
   Dir.chdir(app_path)
 
-  if pack = LanguagePack.detect(
-      app_path: app_path,
-      cache_path: cache_path,
-      gemfile_lock: gemfile_lock
-    )
-    LanguagePack::ShellHelpers.initialize_env(ARGV[2])
-    pack.topic("Setting up Test for #{pack.name}")
-    pack.compile
-  end
+  LanguagePack::ShellHelpers.initialize_env(ARGV[2])
+  LanguagePack.call(
+    app_path: app_path,
+    cache_path: cache_path,
+    gemfile_lock: gemfile_lock,
+    bundle_default_without: "development",
+    environment_name: "test",
+  )
 rescue Exception => e
   LanguagePack::ShellHelpers.display_error_and_exit(e)
 end

bin/support/ruby_test.rb

@@ -29,44 +29,23 @@ def execute_command(command)
   pipe(command, :user_env => true, :output_object => Kernel)
 end
 
-def user_env_hash
-  LanguagePack::ShellHelpers.user_env_hash
-end
-
-# $ bin/test BUILD_DIR ENV_DIR ARTIFACT_DIR
-build_dir, env_dir, _ = ARGV
+# $ bin/test app_path ENV_DIR ARTIFACT_DIR
+app_path, env_dir, _ = ARGV.map { |arg| Pathname(arg).expand_path }
 LanguagePack::ShellHelpers.initialize_env(env_dir)
-Dir.chdir(build_dir)
-
-# The `ruby_test-compile` program installs a version of Ruby for the
-# user's application. It needs the propper `PATH`, where ever Ruby is installed
-# otherwise we end up using the buildpack's version of Ruby
-#
-# This is needed here because LanguagePack::Ruby.slug_vendor_base shells out to the user's ruby binary
-user_env_hash["PATH"] = "#{build_dir}/bin:#{ENV["PATH"]}"
-
-bundler = LanguagePack::Helpers::BundlerWrapper.new(
-  gemfile_path: "#{build_dir}/Gemfile",
-  bundler_path: LanguagePack::Ruby.slug_vendor_base # This was previously installed by bin/support/ruby_test-compile
-)
-
-# - Add bundler's bin directory to the PATH
-# - Always make sure `$HOME/bin` is first on the path
-user_env_hash["PATH"] = "#{build_dir}/bin:#{bundler.bundler_path}/bin:#{user_env_hash["PATH"]}"
-user_env_hash["GEM_PATH"] = LanguagePack::Ruby.slug_vendor_base
+Dir.chdir(app_path)
 
-# - Sets BUNDLE_GEMFILE
-# - Loads bundler's internal Gemfile.lock parser so we can use `bundler.has_gem?`
-bundler.install
+gems_list = LanguagePack::Helpers::BundleList::HumanCommand.new(
+  stream_to_user: false,
+).call
 
 execute_test(
-  if bundler.has_gem?("rspec-core")
+  if gems_list.has_gem?("rspec-core")
     if File.exist?("bin/rspec")
       "bin/rspec"
     else
       "bundle exec rspec"
     end
-  elsif File.exist?("bin/rails") && bundler.has_gem?("railties") && bundler.gem_version("railties") >= Gem::Version.new("5.x")
+  elsif File.exist?("bin/rails") && gems_list.has_gem?("railties") && gems_list.gem_version("railties") >= Gem::Version.new("5.x")
     "bin/rails test"
   elsif File.exist?("bin/rake")
     "bin/rake test"

bin/test

@@ -20,7 +20,4 @@ bootstrap_ruby_dir=$(mktemp -d)
 "$BIN_DIR"/support/download_ruby "$BIN_DIR" "$bootstrap_ruby_dir"
 trap 'rm -rf "$bootstrap_ruby_dir"' EXIT
 
-export PATH="$bootstrap_ruby_dir/bin/:$PATH"
-unset GEM_PATH
-
 "$bootstrap_ruby_dir"/bin/ruby "$BIN_DIR/support/ruby_test.rb" "$@"

bin/test-compile

@@ -23,9 +23,6 @@ bootstrap_ruby_dir=$(mktemp -d)
 "$BIN_DIR"/support/download_ruby "$BIN_DIR" "$bootstrap_ruby_dir"
 trap 'rm -rf "$bootstrap_ruby_dir"' EXIT
 
-export PATH="$bootstrap_ruby_dir/bin/:$PATH"
-unset GEM_PATH
-
 if detect_needs_java "$BUILD_DIR"; then
   cat <<EOM
 

changelogs/unreleased/ci-path-order.md

@@ -0,0 +1,81 @@
+## Ruby applications using Heroku CI have a different PATH load order
+
+The `PATH` order on Heroku CI relying on `bin/test` interface has changed for applications using the `heroku/ruby` buildpack.
+
+It now starts with:
+
+- `/app/bin:/app/vendor/bundle/bin:/app/vendor/bundle/ruby/<major>.<minor>.0/bin`
+
+> Note `<major>.<minor>` is for the Ruby version so Ruby 3.3.10 would show `/app/vendor/bundle/ruby/3.3.0/bin` on the path .
+
+This matches the behavior of regular `$ git push heroku` deploys and applications specifying a test command via `app.json`.
+
+Previously it started with:
+
+- `/app/bin:vendor/bundle/ruby/<major>.<minor>.0/bin:<bootstrap ruby>/bin:/app/vendor/bundle/ruby/<major>.<minor>.0/bin:/app/vendor/bundle/bin`
+
+This discrepancy between has resulted in zero reported issues or tickets, so the fix is not expected to be disruptive. However, it's still a change, and if your application is affected it helps to understand each of the parts of those path to help with debugging.
+
+## Heroku CI `bin/test`
+
+Only applications that do not specify a test command in their `app.json` will trigger calling `bin/test` of the
+buildpack. This `bin/test` runs a Ruby script to determine what test command should be called (such as `bin/rake test`).
+Applications relying on this behavior will now get a different `PATH` order.
+
+## What is the `PATH`?
+
+When you type in `$ rspec` the operating system will look for the executable `rspec` by breaking the `PATH` environment variable into parts with a colon (`:`) separator in order from back to front. That means that it will now look for the `rspec` executable in this order:
+
+- `/app/bin/rspec`
+- `/app/vendor/bundle/bin/rspec`
+- `/app/vendor/bundle/ruby/<major>.<minor>.0/bin/rspec`
+
+By changing the contents or the ordering of the `PATH` you'll possibly change which executable is run. You can see the executable order by using the `which` tool.
+
+```
+$ heroku run bash
+~ $ which -a rake
+/app/bin/rake
+/app/vendor/bundle/bin/rake
+/app/vendor/bundle/ruby/3.3.0/bin/rake
+```
+
+The `-a` flag tells `which` to list all found executables, not just the first. But when you run `$ rake` it will effectively be the same as calling the full path `$ /app/bin/rake` directly.
+
+## Path parts
+
+The following describes the parts that `heroku/ruby` places on the `PATH` both before and after the change.
+
+### App binstubs `/app/bin`
+
+This is the local `./bin` "binstubs" directory that all recent Rails applications have.
+In addition, the Ruby buildpack also places a symlink to the `ruby` executable we install there, as
+well as other default gems.
+
+This path is first for the current and prior `PATH`.
+
+### Bundler binstubs `/app/vendor/bundle/bin`
+
+The location of binstubs installed by `bundle install`. So if you have `rake` in your `Gemfile` you would get a `/app/vendor/bundle/bin/rake` executable file. Notably, these executables load `bundler/setup`, so if you call `$ /app/vendor/bundle/bin/rake` it's similar to calling `$ bundle exec /app/vendor/bundle/bin/rake`.
+
+Unlike on a local machine, the difference between activating `$ rspec` and `$ bundle exec rspec` is very small, because Heroku cleans unused gem versions. The only time there are multiple versions of a gem on the system is due to default gems or multiple Ruby installations (due to conflicting "bootstrap" Ruby).
+
+This is now second on the `PATH`, previously it was last (as installed by `heroku/ruby`).
+
+> Note that this is bundler version dependent Bundler 2.6 places files here Bundler 2.7+ does not
+
+### RubyGems binstubs`/app/vendor/bundle/ruby/<major>.<minor>.0/bin`
+
+The location of binstubs installed by RubyGems (`gem`). When you `bundle install`, it also installs "binstubs" to this directory. These executables do NOT load bundler, so on Ruby 3.3.10 `$ bundle exec /app/vendor/bundle/ruby/3.3.0/bin/rake` and `$ /app/vendor/bundle/ruby/3.3.0/bin` would possibly produce different results on a system where there are many versions of a default gem installed.
+
+This is now third on the `PATH`, previously it was second as a relative path and again later as an absolute path.
+
+When a relative path is on the `PATH` as the application changes working directories it changes the effective value of the path. For example, `Dir.chdir("tmp")` would trigger path lookups in `tmp/vendor/bundle/ruby/3.3.0/bin` (for Ruby 3.3.10). It's unlikely this affected many people, but the difference is worth noting.
+
+### Bootstrap Ruby `<bootstrap ruby>/bin`
+
+The Ruby buildpack uses a "bootstrap" version of Ruby to execute itself.
+
+Because `/app/bin` is on the path first, the correct version of Ruby will always be used (since that is where we symlink Ruby). However, if you were trying to call a default gem binstub, it's possible that prior to this change, you could have activated the "bootstrap" Ruby's copy instead of the Ruby version you requested.
+
+This is no longer on the path as the implementation was refactored, so it's no longer needed. Previously, it was on the path by necessity of the implementation of `bin/test`.

hatchet.lock

@@ -8,7 +8,7 @@
 - - "./repos/ci/heroku-ci-json-example"
   - 728cc99c8e80290cc07441d61a8bcd4596e696fb
 - - "./repos/ci/ruby_no_rails_test"
-  - c5925ab061f65433ec5dcbc890975f580e74c5ce
+  - 8f6b08138db00ef7f3b5a21b1eb42611b83e363b
 - - "./repos/heroku/ruby-getting-started"
   - main
 - - "./repos/node/minimal_webpacker"

lib/language_pack.rb

@@ -20,17 +20,106 @@ def self.gemfile_lock(app_path: )
     end
   end
 
+  def self.call(app_path:, cache_path:, gemfile_lock:, bundle_default_without:, environment_name: "production")
+    arch = LanguagePack::Base.get_arch
+    stack = ENV.fetch("STACK")
+    cache = LanguagePack::Cache.new(cache_path)
+    warn_io = LanguagePack::ShellHelpers::WarnIO.new
+    user_env_hash = LanguagePack::ShellHelpers.user_env_hash
+    bundler_cache = LanguagePack::BundlerCache.new(cache, stack)
+    bundler_version = LanguagePack::Helpers::BundlerWrapper.detect_bundler_version(contents: gemfile_lock.contents)
+
+    metadata = LanguagePack::Metadata.new(cache_path: cache_path)
+    new_app = metadata.empty?
+
+    ruby_version = Ruby.get_ruby_version(
+      report: HerokuBuildReport::GLOBAL,
+      metadata: metadata,
+      gemfile_lock: gemfile_lock
+    )
+
+    Ruby.remove_vendor_bundle(app_path: app_path)
+    Ruby.warn_bundler_upgrade(metadata: metadata, bundler_version: bundler_version)
+    Ruby.warn_bad_binstubs(app_path: app_path, warn_object: warn_io)
+    Ruby.install_ruby(
+      app_path: app_path,
+      ruby_version: ruby_version,
+      stack: stack,
+      arch: arch,
+      metadata: metadata,
+      io: warn_io
+    )
+
+    bundler = Helpers::BundlerWrapper.new.install
+    default_config_vars = Ruby.default_config_vars(metadata: metadata, ruby_version: ruby_version, bundler: bundler, environment_name: environment_name)
+    Ruby.setup_language_pack_environment(
+      app_path: app_path.expand_path,
+      ruby_version: ruby_version,
+      user_env_hash: user_env_hash,
+      bundle_default_without: bundle_default_without,
+      default_config_vars: default_config_vars
+    )
+    Ruby.install_bundler_in_app(bundler_src_dir: bundler.bundler_path, app_bundler_dir: ruby_version.bundler_directory)
+    Ruby.load_bundler_cache(
+      ruby_version: ruby_version,
+      new_app: new_app,
+      cache: cache,
+      metadata: metadata,
+      stack: stack,
+      bundler_cache: bundler_cache,
+      bundler_version: bundler_version,
+      bundler: bundler,
+      io: warn_io
+    )
+
+    bundler_output = String.new # buffer
+    Ruby.build_bundler(
+      ruby_version: ruby_version,
+      app_path: app_path,
+      io: warn_io,
+      bundler_cache: bundler_cache,
+      bundler_version: bundler_version,
+      bundler_output: bundler_output,
+    )
+
+    gems = Ruby.bundle_list(
+        io: warn_io,
+        stream_to_user: !bundler_output.match?(/Installing|Fetching|Using/)
+    )
+
+    if pack = LanguagePack.detect(
+        arch: arch,
+        new_app: new_app,
+        warn_io: warn_io,
+        bundler: bundler,
+        app_path: app_path,
+        cache_path: cache_path,
+        ruby_version: ruby_version,
+        gemfile_lock: gemfile_lock,
+        environment_name: environment_name
+      )
+      pack.topic("Compiling #{pack.name}")
+      pack.compile
+    end
+  end
+
   # detects which language pack to use
-  def self.detect(app_path:, cache_path:, gemfile_lock: )
+  def self.detect(arch:, app_path:, cache_path:, environment_name:, gemfile_lock:, new_app:, ruby_version:, warn_io:, bundler:)
     pack_klass = [ Rails8, Rails7, Rails6, Rails5, Rails4, Rails3, Rails2, Rack, Ruby ].detect do |klass|
-      klass.use?
+      klass.use?(bundler: bundler)
     end
 
     if pack_klass
       pack_klass.new(
+        arch: arch,
+        bundler: bundler,
+        new_app: new_app,
+        warn_io: warn_io,
         app_path: app_path,
         cache_path: cache_path,
-        gemfile_lock: gemfile_lock
+        environment_name: environment_name,
+        gemfile_lock: gemfile_lock,
+        ruby_version: ruby_version,
       )
     else
       nil