Clearing off (unreleased) main (#1653)

* Revert "Remove Cache dependency from Metadata (#1649)"

This reverts commit 6c15f18.

* Revert "Improve message on `bin/detect` failure (#1647)"

This reverts commit 79ad8d7.

Author: schneems

CHANGELOG.md

@@ -2,8 +2,6 @@
 
 ## [Unreleased]
 
-- Internal refactor: Remove Cache class dependency from Metadata class (https://github.com/heroku/heroku-buildpack-ruby/pull/1649)
-- Improve message on `bin/detect` failure to include the list of files in the root directory (https://github.com/heroku/heroku-buildpack-ruby/pull/1647)
 
 ## [v322] - 2025-09-29
 

bin/detect

@@ -7,33 +7,6 @@ APP_DIR=$1
 if [ -f "$APP_DIR/Gemfile" ]; then
   echo "Ruby"
   exit 0
+else
+  exit 1
 fi
-
-output::error <<EOF
-Error: Your app is configured to use the Ruby buildpack,
-but we couldn't find any supported Ruby project files ('Gemfile.lock').
-
-A Ruby app on Heroku must have a 'Gemfile.lock' in the root directory of its source code.
-
-Currently the root directory of your app contains:
-
-$(ls -1A --indicator-style=slash "${BUILD_DIR}" || true)
-
-If your app already has a package manager file, check that it:
-
-1. Is in the top level directory (not a subdirectory).
-2. Has the correct spelling (the filenames are case-sensitive).
-3. Isn't listed in '.gitignore' or '.slugignore'.
-4. Has been added to the Git repository using 'git add --all'
-   and then committed using 'git commit'.
-
-Otherwise, add a package manager file to your app. If your app has
-no dependencies, then create an empty 'Gemfile', run 'bundle install' and
-commit the results to git.
-
-For help with using Ruby on Heroku, see:
-https://devcenter.heroku.com/articles/getting-started-with-ruby
-https://devcenter.heroku.com/articles/ruby-support
-EOF
-
-exit 1

lib/language_pack/base.rb

@@ -26,8 +26,7 @@ def initialize(app_path: , cache_path: , gemfile_lock: )
     @app_path = app_path
     @stack         = ENV.fetch("STACK")
     @cache         = LanguagePack::Cache.new(cache_path)
-    @metadata      = LanguagePack::Metadata.new(cache_path: cache_path)
-    @new_app       = @metadata.empty?
+    @metadata      = LanguagePack::Metadata.new(@cache)
     @bundler_cache = LanguagePack::BundlerCache.new(@cache, @stack)
     @fetchers      = {:buildpack => LanguagePack::Fetcher.new(VENDOR_URL) }
     @arch = get_arch
@@ -48,10 +47,6 @@ def get_arch
     arch
   end
 
-  def new_app?
-    @new_app
-  end
-
   def self.===(app_path)
     raise "must subclass"
   end

lib/language_pack/metadata.rb

@@ -1,43 +1,59 @@
 require "language_pack"
 require "language_pack/base"
 
-# Store data about the build in the cache
-#
-# Uses `<cache_path>/vendor/heroku` as the metadata directory. Which
-# is special cased in cache clearing code to be durable. This allows
-# for persistant generated data such as SECRET_KEY_BASE that would otherwise
-# cause session invalidation if it changed unexpectedly between deploys.
 class LanguagePack::Metadata
-  def initialize(cache_path: )
-    @dir = Pathname(cache_path)
-      .join("vendor")
-      .join("heroku")
-      .tap(&:mkpath)
+  FOLDER = "vendor/heroku"
+
+  def initialize(cache)
+    if cache
+      @cache = cache
+      @cache.load FOLDER
+    end
+  end
+
+  def [](key)
+    read(key)
   end
 
-  def empty?
-    @dir.children.empty?
+  def []=(key, value)
+    write(key, value)
   end
 
   def read(key)
-    @dir.join(key).read&.strip
+    full_key = "#{FOLDER}/#{key}"
+    File.read(full_key).strip if exists?(key)
   end
 
   def exists?(key)
-    @dir.join(key).file?
+    full_key = "#{FOLDER}/#{key}"
+    File.exist?(full_key) && !Dir.exist?(full_key)
   end
+  alias_method :include?, :exists?
 
-  def write(key, value)
-    @dir.join(key).write(value)
+  def write(key, value, isave = true)
+    FileUtils.mkdir_p(FOLDER)
+
+    full_key = "#{FOLDER}/#{key}"
+    File.open(full_key, 'w') {|f| f.puts value }
+    save if isave
+
+    return true
+  end
+
+  def touch(key)
+    write(key, "true")
   end
 
   def fetch(key)
-    if exists?(key)
-      read(key)
-    else
-      value = yield
-      write(key, value.to_s)
-      value
-    end
+    return read(key) if exists?(key)
+
+    value = yield
+
+    write(key, value.to_s)
+    return value
+  end
+
+  def save(file = FOLDER)
+    @cache ? @cache.add(file) : false
   end
 end

lib/language_pack/ruby.rb

@@ -192,7 +192,7 @@ def warn_bad_binstubs
 
   def default_malloc_arena_max?
     return true if @metadata.exists?("default_malloc_arena_max")
-    return @metadata.write("default_malloc_arena_max", "true") if new_app?
+    return @metadata.touch("default_malloc_arena_max") if new_app?
 
     return false
   end
@@ -613,6 +613,10 @@ def install_ruby(install_path: )
     error message
   end
 
+  def new_app?
+    @new_app ||= !app_path.join("vendor").join("heroku").exist?
+  end
+
   # find the ruby install path for its binstubs during build
   # @return [String] resulting path or empty string if ruby is not vendored
   def ruby_install_binstub_path(ruby_layer_path = ".")
@@ -1082,6 +1086,7 @@ def load_bundler_cache
 
     full_ruby_version       = run_stdout(%q(ruby -v)).strip
     rubygems_version        = run_stdout(%q(gem -v)).strip
+    heroku_metadata         = "vendor/heroku"
     old_rubygems_version    = nil
     ruby_version_cache      = "ruby_version"
     buildpack_version_cache = "buildpack_version"
@@ -1114,11 +1119,13 @@ def load_bundler_cache
       purge_bundler_cache
     end
 
-    @metadata.write(ruby_version_cache, full_ruby_version)
-    @metadata.write(buildpack_version_cache, BUILDPACK_VERSION)
-    @metadata.write(bundler_version_cache, bundler.version)
-    @metadata.write(rubygems_version_cache, rubygems_version)
-    @metadata.write(stack_cache, @stack)
+    FileUtils.mkdir_p(heroku_metadata)
+    @metadata.write(ruby_version_cache, full_ruby_version, false)
+    @metadata.write(buildpack_version_cache, BUILDPACK_VERSION, false)
+    @metadata.write(bundler_version_cache, bundler.version, false)
+    @metadata.write(rubygems_version_cache, rubygems_version, false)
+    @metadata.write(stack_cache, @stack, false)
+    @metadata.save
   end
 
   def purge_bundler_cache(stack = nil)

spec/hatchet/getting_started_spec.rb

@@ -4,26 +4,18 @@
   it "works on Heroku-24" do
     Hatchet::Runner.new("ruby-getting-started", stack: "heroku-24").deploy do |app|
       expect(app.output).to_not include("Purging Cache")
-      expect(app.output).to include("Fetching puma")
-
-      secret_key_base = app.run("echo $SECRET_KEY_BASE")
 
       # Re-deploy with cache
       run!("git commit --allow-empty -m empty")
       app.push!
 
-      # Assert used cached gems
-      expect(app.output).to_not include("Fetching puma")
-
       # Assert no warnings from `cp`
       # https://github.com/heroku/heroku-buildpack-ruby/pull/1586/files#r2064284286
       expect(app.output).to_not include("cp --help")
       expect(app.run("which ruby").strip).to eq("/app/bin/ruby")
 
       environment_variables = app.run("env")
       expect(environment_variables).to match("PUMA_PERSISTENT_TIMEOUT")
-      # Assert cached value persisted
-      expect(environment_variables).to match("SECRET_KEY_BASE=#{secret_key_base}")
 
       profile_d = app.run("cat .profile.d/ruby.sh")
         .strip