Refactor RubyVersion class (heroku#1601)

* Refactor RubyVersion args

Prefer kwargs, remove open-ended options hash in favor of explicit kwarg.

* Inline initialize logic

* Remove non-public instance variables

These values do not need to be persisted as they're not used after initialization

* Remove unused variable

* Rename ivar and remove pub, method already exposed

* Refactor version increment logic

* Rename ivar to match method

* Remove unused ivar

* Derive version_for_download

* RubyVersion is now a simple store

The bundle parsing logic feeds into the RubyVersion class instead of being tightly coupled

* Use new interface

* Update method

The other method was removed, this is the new name

* Add test, passes on main, fails here

* Fix test, capture "pre" release version information

* Support pre-release versions without numbers

Convention says they have numbers, but it's not strictly required.

* Remove shell helper include

* Extract RubyVersion.default into a method

* Capture when Ruby version is the default

Author: schneems

lib/language_pack/helpers/outdated_ruby_version.rb

@@ -4,7 +4,7 @@
 #
 # Example:
 #
-#   ruby_version = LanguagePack::RubyVersion.new("ruby-2.2.5")
+#   ruby_version = LanguagePack::RubyVersion.bundle_platform_ruby(bundler_output: "ruby-2.2.5")
 #   outdated = LanguagePack::Helpers::OutdatedRubyVersion.new(
 #     current_ruby_version: ruby_version,
 #     fetcher: LanguagePack::Fetcher.new(LanguagePack::Base::VENDOR_URL, stack: "heroku-22")
@@ -175,7 +175,7 @@ def suggest_ruby_eol_version
       next if !@fetcher.exists?("#{version}.tgz")
 
       check_eol_versions_minor(
-        base_version: LanguagePack::RubyVersion.new(version)
+        base_version: LanguagePack::RubyVersion.bundle_platform_ruby(bundler_output: version)
       )
 
       version

lib/language_pack/installers/heroku_ruby_installer.rb

@@ -27,6 +27,7 @@ def install(ruby_version, install_dir)
       "ruby.major" => ruby_version.major,
       "ruby.minor" => ruby_version.minor,
       "ruby.patch" => ruby_version.patch,
+      "ruby.default" => ruby_version.default?,
     )
     fetch_unpack(ruby_version, install_dir)
     setup_binstubs(install_dir)

lib/language_pack/ruby.rb

@@ -171,7 +171,7 @@ def slug_vendor_base
   # the relative path to the vendored ruby directory
   # @return [String] resulting path
   def slug_vendor_ruby
-    "vendor/#{ruby_version.version_without_patchlevel}"
+    "vendor/#{ruby_version.version_for_download}"
   end
 
   # fetch the ruby version from bundler
@@ -182,9 +182,10 @@ def ruby_version
     last_version      = nil
     last_version      = @metadata.read(last_version_file).strip if @metadata.exists?(last_version_file)
 
-    @ruby_version = LanguagePack::RubyVersion.new(bundler.ruby_version,
-      is_new:       new_app?,
-      last_version: last_version)
+    @ruby_version = LanguagePack::RubyVersion.bundle_platform_ruby(
+      bundler_output: bundler.ruby_version,
+      last_version: last_version
+    )
     return @ruby_version
   end
 
@@ -470,7 +471,7 @@ def install_ruby(install_path)
     @metadata.write("buildpack_ruby_version", ruby_version.version_for_download)
 
     topic "Using Ruby version: #{ruby_version.version_for_download}"
-    if !ruby_version.set
+    if ruby_version.default?
       warn(<<~WARNING)
         You have not declared a Ruby version in your Gemfile.
 

lib/language_pack/ruby_version.rb

@@ -1,4 +1,4 @@
-require "language_pack/shell_helpers"
+require "language_pack/shell_helpers" # Holds BuildpackError
 
 module LanguagePack
   class RubyVersion
@@ -21,51 +21,76 @@ def initialize(output = "")
         (?<engine>\w+){0}
         (?<engine_version>.+){0}
 
-        ruby-\g<ruby_version>(-\g<patchlevel>)?(-\g<engine>-\g<engine_version>)?
+        ruby-\g<ruby_version>(-\g<patchlevel>)?(\.(?<pre>\S*))?(-\g<engine>-\g<engine_version>)?
       }x
 
-
-    # `version` is the bundler output like `ruby-3.4.2`
-    attr_reader :version,
-      # `set` is either `:gemfile` when the app specified a version or `nil` when using
-      # the default version
-      :set,
-      # `version_without_patchlevel` removes any `-p<number>` as they're not significant
-      # effectively this is `version_for_download`
-      :version_without_patchlevel,
-      # `patchlevel` is the `-p<number>` or is empty
-      :patchlevel,
+    # String formatted `<major>.<minor>.<patch>` for Ruby and JRuby
+    attr_reader :ruby_version,
       # `engine` is `:ruby` or `:jruby`
       :engine,
-      # `ruby_version` is `<major>.<minor>.<patch>` extracted from `version`
-      :ruby_version,
       # `engine_version` is the Jruby version or for MRI it is the same as `ruby_version`
       # i.e. `<major>.<minor>.<patch>`
       :engine_version
 
-    include LanguagePack::ShellHelpers
+    def self.bundle_platform_ruby(bundler_output:, last_version: nil)
+      default = bundler_output.empty?
+      if default
+        default(last_version: last_version)
+      elsif md = RUBY_VERSION_REGEX.match(bundler_output)
+        new(
+          pre: md[:pre],
+          engine: md[:engine]&.to_sym || :ruby,
+          default: default,
+          ruby_version: md[:ruby_version],
+          engine_version: md[:engine_version] || md[:ruby_version],
+        )
+      else
+        raise BadVersionError.new("'#{bundler_output}' is not valid") unless md
+      end
+    end
 
-    def initialize(bundler_output, app = {})
-      @set            = nil
-      @bundler_output = bundler_output
-      @app            = app
-      set_version
-      parse_version
+    def self.default(last_version: )
+      ruby_version = last_version&.split("-")&.last || DEFAULT_VERSION_NUMBER
+      new(
+        pre: nil,
+        engine: :ruby,
+        default: true,
+        ruby_version: ruby_version,
+        engine_version: ruby_version,
+      )
+    end
 
-      @version_without_patchlevel = @version.sub(/-p-?\d+/, '')
+    def initialize(
+        pre:,
+        engine:,
+        default:,
+        ruby_version:,
+        engine_version:
+      )
+        @pre = pre
+        @engine = engine
+        @default = default
+        @ruby_version = ruby_version
+        @engine_version = engine_version
     end
 
-    # https://github.com/bundler/bundler/issues/4621
+    # i.e. `ruby-3.4.2`
     def version_for_download
-      version_without_patchlevel
+      if @engine == :jruby
+        "ruby-#{ruby_version}-jruby-#{engine_version}"
+      elsif @pre
+        "ruby-#{ruby_version}.#{@pre}"
+      else
+        "ruby-#{ruby_version}"
+      end
     end
 
     def file_name
       "#{version_for_download}.tgz"
     end
 
     def default?
-      !set
+      @default
     end
 
     # determine if we're using jruby
@@ -101,45 +126,15 @@ def patch
     # `ruby-2.3.1` then then `next_logical_version(1)`
     # will produce `ruby-2.3.2`.
     def next_logical_version(increment = 1)
-      split_version = @version_without_patchlevel.split(".")
-      teeny = split_version.pop
-      split_version << teeny.to_i + increment
-      split_version.join(".")
+      "ruby-#{major}.#{minor}.#{patch + increment}"
     end
 
     def next_minor_version(increment = 1)
-      split_version = @version_without_patchlevel.split(".")
-      split_version[1] = split_version[1].to_i + increment
-      split_version[2] = 0
-      split_version.join(".")
+      "ruby-#{major}.#{minor + increment}.0"
     end
 
     def next_major_version(increment = 1)
-      split_version = @version_without_patchlevel.split("-").last.split(".")
-      split_version[0] = Integer(split_version[0]) + increment
-      split_version[1] = 0
-      split_version[2] = 0
-      return "ruby-#{split_version.join(".")}"
-    end
-
-    private
-    def set_version
-      if @bundler_output.empty?
-        @set     = false
-        @version = @app[:last_version] || DEFAULT_VERSION
-      else
-        @set     = :gemfile
-        @version = @bundler_output
-      end
-    end
-
-    def parse_version
-      md = RUBY_VERSION_REGEX.match(version)
-      raise BadVersionError.new("'#{version}' is not valid") unless md
-      @ruby_version   = md[:ruby_version]
-      @patchlevel     = md[:patchlevel]
-      @engine_version = md[:engine_version] || @ruby_version
-      @engine         = (md[:engine]        || :ruby).to_sym
+      "ruby-#{major + increment}.0.0"
     end
   end
 end

spec/helpers/heroku_ruby_installer_spec.rb

@@ -11,7 +11,7 @@ def installer(report: HerokuBuildReport::GLOBAL)
   end
 
   def ruby_version
-    LanguagePack::RubyVersion.new("ruby-3.1.7")
+    LanguagePack::RubyVersion.bundle_platform_ruby(bundler_output: "ruby-3.1.7")
   end
 
   describe "#fetch_unpack" do
@@ -58,7 +58,7 @@ def ruby_version
             arch: "arm64",
             report: report
           ).install(
-            LanguagePack::RubyVersion.new("ruby-3.1.4-p0-jruby-9.4.9.0"),
+            LanguagePack::RubyVersion.bundle_platform_ruby(bundler_output: "ruby-3.1.4-p0-jruby-9.4.9.0"),
             "#{dir}/vendor/ruby"
           )
 

spec/helpers/outdated_ruby_version_spec.rb

@@ -7,7 +7,7 @@
   }
 
   it "handles amd ↗️ architecture on heroku-24" do
-    ruby_version = LanguagePack::RubyVersion.new("ruby-3.1.0")
+    ruby_version = LanguagePack::RubyVersion.bundle_platform_ruby(bundler_output: "ruby-3.1.0")
     fetcher = LanguagePack::Fetcher.new(
       LanguagePack::Base::VENDOR_URL,
       stack: "heroku-24",
@@ -23,7 +23,7 @@
   end
 
   it "handles arm 💪 architecture on heroku-24" do
-    ruby_version = LanguagePack::RubyVersion.new("ruby-3.1.0")
+    ruby_version = LanguagePack::RubyVersion::bundle_platform_ruby(bundler_output: "ruby-3.1.0")
     fetcher = LanguagePack::Fetcher.new(
       LanguagePack::Base::VENDOR_URL,
       stack: "heroku-24",
@@ -39,7 +39,7 @@
   end
 
   it "finds the latest version on a stack" do
-    ruby_version = LanguagePack::RubyVersion.new("ruby-2.2.5")
+    ruby_version = LanguagePack::RubyVersion::bundle_platform_ruby(bundler_output: "ruby-2.2.5")
     outdated = LanguagePack::Helpers::OutdatedRubyVersion.new(
       current_ruby_version: ruby_version,
       fetcher: fetcher
@@ -52,7 +52,7 @@
   end
 
   it "detects returns original ruby version when using the latest" do
-    ruby_version = LanguagePack::RubyVersion.new("ruby-2.2.10")
+    ruby_version = LanguagePack::RubyVersion::bundle_platform_ruby(bundler_output: "ruby-2.2.10")
     outdated = LanguagePack::Helpers::OutdatedRubyVersion.new(
       current_ruby_version: ruby_version,
       fetcher: fetcher
@@ -64,8 +64,8 @@
   end
 
   it "recommends a non EOL version of Ruby" do
-    ruby_version_one = LanguagePack::RubyVersion.new("ruby-2.1.10")
-    ruby_version_two = LanguagePack::RubyVersion.new("ruby-2.2.10")
+    ruby_version_one = LanguagePack::RubyVersion::bundle_platform_ruby(bundler_output: "ruby-2.1.10")
+    ruby_version_two = LanguagePack::RubyVersion::bundle_platform_ruby(bundler_output: "ruby-2.2.10")
 
     outdated_one = LanguagePack::Helpers::OutdatedRubyVersion.new(
       current_ruby_version: ruby_version_one,
@@ -94,7 +94,7 @@
   end
 
   it "does not recommend EOL for recent ruby version" do
-    ruby_version = LanguagePack::RubyVersion.new("ruby-2.2.10")
+    ruby_version = LanguagePack::RubyVersion::bundle_platform_ruby(bundler_output: "ruby-2.2.10")
 
     outdated = LanguagePack::Helpers::OutdatedRubyVersion.new(
       current_ruby_version: ruby_version,
@@ -104,7 +104,7 @@
     outdated.call
 
     good_version = outdated.suggest_ruby_eol_version.sub("x", "0")
-    ruby_version = LanguagePack::RubyVersion.new("ruby-#{good_version}")
+    ruby_version = LanguagePack::RubyVersion::bundle_platform_ruby(bundler_output: "ruby-#{good_version}")
 
     outdated = LanguagePack::Helpers::OutdatedRubyVersion.new(
       current_ruby_version: ruby_version,
@@ -117,7 +117,7 @@
   end
 
   it "can call eol? on the latest Ruby version" do
-    ruby_version = LanguagePack::RubyVersion.new("ruby-2.6.0")
+    ruby_version = LanguagePack::RubyVersion::bundle_platform_ruby(bundler_output: "bundler_output: ruby-2.6.0")
 
     new_fetcher = fetcher.dup
     def new_fetcher.exists?(value); false; end