Update CRuby releases on Windows

Add ruby-3.3.11
Mention all maintainers in check-new-windows-versions for consistency
2026-09-13 22:44:20 +02:00 · 2026-03-26 14:59:51 +01:00 · 2026-03-26 05:00:29 +00:00 · 2026-03-17 20:33:23 +01:00 · 2026-03-17 19:30:13 +00:00 · 2026-03-17 00:01:45 +00:00
41 changed files with 94049 additions and 7735 deletions
@@ -1,18 +0,0 @@
 {
    "env": {
        "commonjs": true,
        "es6": true,
        "node": true
    },
    "extends": "eslint:recommended",
    "globals": {
        "Atomics": "readonly",
        "SharedArrayBuffer": "readonly"
    },
    "parserOptions": {
        "ecmaVersion": 2018,
        "sourceType": "module"
    },
    "rules": {
    }
 }
@@ -0,0 +1 @@
 github: [eregon]
@@ -0,0 +1,43 @@
 name: Bug report
 description: Create a report to help us improve
 body:
 - type: markdown
  attributes:
    value: |
      First, take some time to think whether this is really an issue of ruby/setup-ruby and whether it is fixable in this action.
      This action basically just downloads a prebuilt Ruby and adds it to `PATH`, so it is unlikely the bug is in this action.
      Give some thoughts whether it could be an issue in your workflow, in the gems you use, in GitHub Actions, in Ruby, RubyGems, Bundler, etc.
      This is NOT the place to ask help about your workflow failing (ask that on [GitHub Community](https://github.com/orgs/community/discussions/categories/actions) or [Discussions](https://github.com/ruby/setup-ruby/discussions) instead), it is only to report issues about ruby/setup-ruby.
      Please note we will close your issue without comment if you do not fill out the requested information.
 - type: checkboxes
  attributes:
    label: Ensure the following before filing this issue
    options:
    - label: |
        I verified it reproduces with the latest version with `- uses: ruby/setup-ruby@v1` (see [Versioning policy](https://github.com/ruby/setup-ruby/blob/master/README.md#versioning))
      required: true
    - label: |
        I tried to reproduce the issue locally by following the workflow steps (including all commands done by `ruby/setup-ruby`, except for `Downloading Ruby` & `Extracting Ruby`),
        and it did not reproduce locally (if it does reproduce locally, it's not a ruby/setup-ruby issue)
      required: true
    # - label: |
    #     If the issue happens on JRuby or TruffleRuby, and does not happen on CRuby (please check), file an issue there instead. It's very unlikely ruby/setup-ruby is the cause.
    #   required: true
 - type: dropdown
  attributes:
    label: Are you running on a GitHub-hosted runner or a self-hosted runner?
    options:
      - GitHub-hosted runner
      - self-hosted runner
  validations:
    required: true
 - type: input
  attributes:
    label: Link to the failed workflow job (must be a public workflow job, so the necessary information is available)
  validations:
    required: true
 - type: textarea
  attributes:
    label: Any other notes?
  validations:
    required: false
@@ -0,0 +1 @@
 blank_issues_enabled: false
@@ -0,0 +1,10 @@
 ---
 name: Other issue (not a bug)
 about: Feature requests, etc
 title: ''
 labels: ''
 assignees: ''
 ---
@@ -0,0 +1,6 @@
 version: 2
 updates:
  - package-ecosystem: 'github-actions'
    directory: '/'
    schedule:
      interval: 'weekly'
@@ -0,0 +1,47 @@
 name: Check new RubyInstaller releases
 on:
  schedule:
  - cron: '0 7,19 * * *'
  workflow_dispatch:
 jobs:
  check_windows_versions:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v6
      with:
        fetch-depth: 0
    - run: ruby generate-windows-versions.rb
    - id: diff
      run: git diff --exit-code
      continue-on-error: true
    - if: ${{ steps.diff.outcome == 'failure' }} # changed
      run: ./pre-commit
      shell: bash
    # See https://github.com/peter-evans/create-pull-request/blob/main/docs/concepts-guidelines.md#push-pull-request-branches-to-a-fork
    - if: ${{ steps.diff.outcome == 'failure' }} # changed
      uses: peter-evans/create-pull-request@v8
      id: pr
      with:
        push-to-fork: ruby-builder-bot/setup-ruby
        author: ruby-builder-bot <98265520+ruby-builder-bot@users.noreply.github.com>
        committer: ruby-builder-bot <98265520+ruby-builder-bot@users.noreply.github.com>
        title: Update CRuby releases on Windows
        commit-message: Update CRuby releases on Windows
        body: |
          Automated PR from the check-new-windows-versions.yml workflow.
          @eregon @MSP-Greg @ntkme @flavorjones @larskanis @headius Please merge this PR if the diff is correct.
          And then release setup-ruby by [running the release workflow](https://github.com/ruby/setup-ruby/actions/workflows/release.yml).
        branch: windows
        delete-branch: true
        token: ${{ secrets.PR_FROM_RUBY_BUILDER_TOKEN }}
    - if: ${{ steps.diff.outcome == 'failure' }} # changed
      name: PR URL
      run: echo "${{ steps.pr.outputs.pull-request-url }}"
      shell: bash
@@ -0,0 +1,24 @@
 name: Create a Release
 on:
  workflow_dispatch:
 permissions:
  contents: write # for creating release
 jobs:
  release:
    runs-on: ubuntu-latest
    env:
      GH_TOKEN: ${{ github.token }}
      GH_REPO: ${{ github.repository }}
    steps:
    - uses: actions/checkout@v6
      with:
        fetch-depth: 0
    - uses: ./
      with:
        ruby-version: '3.3'
    - run: ruby release.rb
    # The same as the update-v1-branch.yml workflow.
    # That workflow is not triggered by the release created above because of
    # https://docs.github.com/en/actions/security-guides/automatic-token-authentication#using-the-github_token-in-a-workflow
    - run: git push origin HEAD:v1
@@ -1,41 +1,392 @@
 name: Test this action
-on: [push]
+on:
  pull_request:
  push:
    branches-ignore:
    - v1
    tags-ignore:
    - '*'
    paths-ignore:
    - README.md
  workflow_dispatch:
 permissions:
  contents: read
 jobs:
  test-matrix:
    runs-on: ubuntu-latest
    outputs:
      matrix: ${{ steps.matrix.outputs.matrix }}
    steps:
    - uses: actions/checkout@v6
    - uses: ./
      with:
        ruby-version: ruby
    - id: matrix
      run: echo "matrix=$(ruby generate-test-matrix.rb)" | tee -a "$GITHUB_OUTPUT"
    - run: echo "$MATRIX" | yq -P
      env:
        MATRIX: ${{ steps.matrix.outputs.matrix }}
  test:
    needs: [test-matrix]
    strategy:
      fail-fast: false
      matrix:
-        os: [ ubuntu-16.04, ubuntu-18.04, macos-latest, windows-latest ]
+        include: ${{ fromJSON(needs.test-matrix.outputs.matrix) }}
-        # Use various version syntaxes here for testing
+    name: ${{ matrix.os }} ${{ matrix.ruby }}
        ruby: [ .ruby-version, 2.3, ruby-2.4, 2.5, ruby-2.6.5, 2.7.0, jruby, truffleruby ]
        exclude:
        - os: windows-latest
          ruby: 2.3
        - os: windows-latest
          ruby: jruby
        - os: windows-latest
          ruby: truffleruby
    runs-on: ${{ matrix.os }}
    steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v6
    - uses: ./
      with:
        ruby-version: ${{ matrix.ruby }}
-    - run: ruby --version
+        bundler-cache: true
-    - run: ridk version
+    - run: ruby -v
-      if: matrix.os == 'windows-latest'
+    - name: PATH
-    - name: OpenSSL test
+      shell: pwsh
-      run: ruby -ropen-uri -e 'puts open(%{https://rubygems.org/}) { |f| f.read(2014) }'
+      run: |
-    - name: C extension test
+        # Show PATH with Powershell
-      run: gem install json --no-document
+        $f, $r = $env:PATH.split([IO.Path]::PathSeparator); $r
    - name: Check that Bundler is installed
      run: bundle --version
    - name: Check that Bundler works
      run: bundle install
-  lint:
+    - name: build compiler
      run: |
        ruby -e "puts 'build compiler: ' + RbConfig::CONFIG.fetch('CC_VERSION_MESSAGE', 'unknown').lines.first"
    - name: gcc and ridk version (mingw)
      if: runner.os == 'Windows'
      run: |
        $abi, $plat = $(ruby -e "STDOUT.write RbConfig::CONFIG['ruby_version'] + ' ' + RUBY_PLATFORM").split(' ')
        if ($plat.Contains('mingw')) {
          gcc --version
          if ($abi -ge '2.4') {
            ridk version
          } else {
            echo 'ridk is unavailable'
          }
        } elseif ($plat.Contains('mswin')) {
          Get-ChildItem "$env:VCPKG_INSTALLATION_ROOT\installed\vcpkg\info"
        }
    - name: RbConfig::CONFIG
      run: ruby -rrbconfig -rpp -e 'pp RbConfig::CONFIG'
    - name: RbConfig::MAKEFILE_CONFIG
      run: ruby -rrbconfig -rpp -e 'pp RbConfig::MAKEFILE_CONFIG'
    - name: Subprocess test
      run: ruby test_subprocess.rb
    - name: OpenSSL compiled version
      run: ruby -ropenssl -e 'puts OpenSSL::OPENSSL_VERSION'
    - name: OpenSSL loaded version
      run: ruby -ropenssl -e 'puts OpenSSL::OPENSSL_LIBRARY_VERSION'
      if: matrix.ruby != '1.9'
    - name: OpenSSL test
      run: ruby -ropen-uri -e 'puts URI.send(:open, %{https://rubygems.org/}) { |f| f.read(1024) }'
    - run: gem env
    - name: C extension test
      run: gem install json -v 2.2.0
    - run: bundle --version
    # This step is redundant with `bundler-cache: true` but is there to check a redundant `bundle install` still works
    - run: bundle install
    - run: bundle exec rake --version
    - run: bundle exec rake
    # Ensure the same bundle commands work in bash on Windows
    - name: bundle install (bash)
      run: bundle install
      shell: bash
      if: runner.os == 'Windows'
    - name: bundle exec rake --version (bash)
      run: bundle exec rake --version
      shell: bash
      if: runner.os == 'Windows'
    - name: bundle exec rake (bash)
      run: bundle exec rake
      shell: bash
      if: runner.os == 'Windows'
    - name: Test `gem github:` in a Gemfile
      run: bundle install
      env:
        BUNDLE_GEMFILE: ${{ github.workspace }}/gemfiles/gem_from_github.gemfile
    - name: which ruby
      shell: bash
      run: which -a ruby
    - name: which bundle
      shell: bash
      run: which -a bundle
      # https://github.com/ruby/setup-ruby/issues/658
      if: "matrix.ruby != 'mingw' && matrix.ruby != 'mswin' && matrix.ruby != 'ucrt'"
    - name: which rake
      run: which -a rake
      if: runner.os != 'Windows'
    - name: where ruby, rake, bundle
      if: runner.os == 'Windows'
      run: |
        $ErrorActionPreference = 'Continue'
        $where = 'ruby', 'rake', 'bundle'
        foreach ($e in $where) {
          $rslt = where.exe $e 2>&1 | Out-String
          if ($rslt.contains($e)) { echo $rslt.Trim() }
          else { echo "Can't find $e" }
          echo ''
        }
    - name: bash test
      shell: bash
      run: echo ~ && bundle install
    - name: Windows JRuby
      if: runner.os == 'Windows' && startsWith(matrix.ruby, 'jruby')
      run: gem install sassc
  testDotRubyVersion:
    name: "Test .ruby-version"
    runs-on: ubuntu-latest
    steps:
-    - uses: actions/checkout@v2
+      - uses: actions/checkout@v6
      - run: echo "ruby-3.4.0" > .ruby-version
      - uses: ./
      - run: ruby -v | grep -F "ruby 3.4.0"
  testToolVersions:
    name: "Test .tool-versions"
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v6
      - run: echo -e "nodejs 16.0.0\nruby   3.4.0" > .tool-versions
      - uses: ./
      - run: ruby -v | grep -F "ruby 3.4.0"
  testMise:
    name: "Test mise.toml"
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v6
      - run: echo -e "[tools]\nnode = '18'\nruby = '3.4.0'" > mise.toml
      - uses: ./
      - run: ruby -v | grep -F "ruby 3.4.0"
  testNoGemfile:
    name: "Test with no Gemfile"
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v6
      - run: rm Gemfile
      - uses: ./
        with:
          ruby-version: '2.6'
      - run: ruby -v
  testNoGemfileWithBundlerCache:
    name: "Test with no Gemfile but with bundler-cache"
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v6
      - run: rm Gemfile
      - uses: ./
        with:
          ruby-version: '2.6'
          bundler-cache: true
      - run: ruby -v
  testLatestRubygemsVersion:
    name: "Test rubygems: latest on ${{ matrix.ruby }}"
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        include:
        - { ruby: '3.2', expected_rubygems_version: '3.6.1'  }
        - { ruby: '3.0', expected_rubygems_version: '3.5.23' }
        - { ruby: '2.7', expected_rubygems_version: '3.4.22' }
        - { ruby: '2.6', expected_rubygems_version: '3.4.22' }
        - { ruby: '2.5', expected_rubygems_version: '3.3.27' }
        - { ruby: '2.3', expected_rubygems_version: '3.3.27' }
        - { ruby: '2.0', expected_rubygems_version: '2.7.11' }
    steps:
    - uses: actions/checkout@v6
    - uses: ./
      with:
        ruby-version: ${{ matrix.ruby }}
        rubygems: latest
    - run: ruby -e 'puts Gem::VERSION; exit(Gem.rubygems_version >= Gem::Version.new("${{ matrix.expected_rubygems_version }}"))'
  testFixedRubygemsVersionUpgrades:
    name: "Test rubygems: version upgrades RubyGems to that version if the default is older"
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v6
    - uses: ./
      with:
        ruby-version: '2.6'
        rubygems: 3.2.3
    - run: gem --version | grep -F "3.2.3"
  testFixedRubygemsVersionNoop:
    name: "Test rubygems: version noops if the default is newer"
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v6
    - uses: ./
      with:
        ruby-version: '3.1.0'
        rubygems: 3.2.3
    - run: gem --version | grep -F "3.3.3"
  testUseBundlerFromRubyGemsUpdate:
    name: "Test rubygems: version uses the Bundler installed by the rubygems update"
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v6
      - uses: ./
        with:
          ruby-version: '3.1.0'
          rubygems: 3.4.0
      - run: gem --version | grep -F "3.4.0"
      - run: bundle --version | grep -F "2.4.0"
  testFixedBundlerVersionForOldRuby:
    name: "Test bundler: 1.x for old Ruby"
    runs-on: ubuntu-22.04
    steps:
      - uses: actions/checkout@v6
      - uses: ./
        with:
          ruby-version: '2.3'
          bundler: 1.16.6
      - run: bundle --version | grep -F "1.16.6" # And not 1.17.x from ~> 1
  testMajorBundlerVersion:
    name: "Test with a major Bundler version"
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v6
    - uses: ./
      with:
        ruby-version: '2.6'
        bundler: 2
    - run: bundle --version | grep -P "Bundler version 2\.\d+\.\d+"
  testMinorBundlerVersion:
    name: "Test with a minor Bundler version"
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v6
    - uses: ./
      with:
        ruby-version: '2.6'
        bundler: 2.2
    - run: bundle --version | grep -P "Bundler version 2\.2\.\d+"
  testExactBundlerVersion:
    name: "Test with an exact Bundler version"
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v6
    - uses: ./
      with:
        ruby-version: '2.6'
        bundler: 2.2.3
    - run: bundle --version | grep -F "Bundler version 2.2.3"
  # https://github.com/ruby/setup-ruby/issues/845
  testOlderBundlerVersion:
    name: "Test with an older Bundler version than the one of the default gem"
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v6
    - uses: ./
      with:
        ruby-version: '4.0'
        bundler: 2.7.2
        bundler-cache: true
    - run: bundle --version | grep -F "Bundler version 2.7.2"
  testBundlerPre:
    name: "Test with a Bundler pre/rc version"
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v6
      - uses: ./
        with:
          ruby-version: '2.6'
          bundler: 2.2.0.rc.2
      - run: bundle --version | grep -F "Bundler version 2.2.0.rc.2"
  testBundlerDev:
    name: "Test BUNDLED WITH Bundler dev"
    runs-on: ubuntu-latest
    env:
      BUNDLE_GEMFILE: ${{ github.workspace }}/gemfiles/bundler-dev.gemfile
    steps:
      - uses: actions/checkout@v6
      - uses: ./
        with:
          ruby-version: ruby-head
          bundler-cache: true
  testDependencyOnBundler1:
    name: "Test gemfile depending on Bundler 1"
    runs-on: ubuntu-latest
    env:
      BUNDLE_GEMFILE: ${{ github.workspace }}/gemfiles/bundler1.gemfile
    steps:
      - uses: actions/checkout@v6
      - uses: ./
        with:
          ruby-version: '2.7'
          bundler: 1
          bundler-cache: true
      - run: bundle --version | grep -F "Bundler version 1."
  testGemfileMatrix:
    strategy:
      fail-fast: false
      matrix:
        gemfile: [ rails7, rails8 ]
    name: "Test with ${{ matrix.gemfile }} gemfile"
    runs-on: ubuntu-latest
    env:
      BUNDLE_GEMFILE: ${{ github.workspace }}/gemfiles/${{ matrix.gemfile }}.gemfile
    steps:
      - uses: actions/checkout@v6
      - uses: ./
        with:
          ruby-version: '3.2'
          bundler-cache: true
      - run: bundle exec rails --version
  testWindowsToolchain:
    name: "Test windows-toolchain: none"
    runs-on: windows-latest
    steps:
      - uses: actions/checkout@v6
      - uses: ./
        with:
          ruby-version: '2.7'
          windows-toolchain: none
          bundler: none
      - name: C:/msys64/mingw64/bin/gcc.exe not installed
        run: ruby -e "abort if File.exist?('C:/msys64/mingw64/bin/gcc.exe')"
  validate-windows-versions:
    name: "Check windows*versions.json are up-to-date"
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v6
    - uses: ./
      with:
        ruby-version: ruby
    - run: ruby generate-windows-versions.rb
    - name: Check generated files are up to date
      run: git diff --exit-code
  check-dist-index:
    name: "Check dist/index.js is up-to-date"
    runs-on: ubuntu-22.04
    steps:
    - uses: actions/checkout@v6
    - run: yarn install
-    - run: yarn run lint
+    - run: yarn run package
    - name: Check generated files are up to date
      run: git diff --exit-code
@@ -0,0 +1,15 @@
 name: Update the v1 branch when a release is published manually
 on:
  release:
    types: [published]
 permissions:
  contents: write # for git push
 jobs:
  update_branch:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v6
      with:
        fetch-depth: 0
    - run: git push origin HEAD:v1
@@ -1 +0,0 @@
 ruby-2.6.5
@@ -0,0 +1,48 @@
 # Contributing
 ## Installing dependencies
 ```bash
 $ yarn install
 ```
 `npm` doesn't install the correct dependencies for `eslint` so we use `yarn`.
 ## Regenerating dist/index.js
 ```bash
 $ yarn run package
 ```
 It is recommended to add this as a `git` `pre-commit` hook:
 ```bash
 $ cp pre-commit .git/hooks/pre-commit
 ```
 ## Adding a new Ruby version
 This is entirely automated now since [this issue](https://github.com/ruby/setup-ruby/issues/254).
 If you do not see a new version more than 24 hours after it was released feel free to file an issue.
 ## Release team
 The current release team is @eregon @MSP-Greg @ntkme @flavorjones @larskanis @headius.
 They all have write access to the `setup-ruby` repository, to be able to merge and release `ruby-builder-bot` PRs adding new versions.
 The `ruby-builder-bot` PRs are created by [this workflow](https://github.com/ruby/ruby-builder/actions/workflows/check-new-releases.yml) which runs every hour.
 The release team can create releases by running [this workflow](https://github.com/ruby/setup-ruby/actions/workflows/release.yml).
 The release team and more specifically @larskanis can run [the workflow to check for new RubyInstaller releases](https://github.com/ruby/setup-ruby/actions/workflows/check-new-windows-versions.yml) to speed things up (otherwise it's run twice a day).
 The release team must not merge other PRs than the ones from `ruby-builder-bot` (unless they are also setup-ruby maintainers).
 ## Maintainers
@eregon is the lead maintainer and creator of this action.
 Any design change (e.g. new input, different way to do things) must have his approval.
@MSP-Greg @ntkme are maintainers of setup-ruby and should feel free to merge bug fixes, etc.
 They should request a review on their PR from another maintainer but they don't have to wait for the review if the fix is urgent (e.g. `setup-ruby` broke in some cases and the fix is obvious).
 Naturally maintainers can also [release setup-ruby](https://github.com/ruby/setup-ruby/actions/workflows/release.yml) so the changes from their PR get published.
@@ -1,5 +1,6 @@
 # Used for testing
 source 'https://rubygems.org'
 gem "rake"
 gem "path"
-gem "json"
+gem "json", "2.2.0"
@@ -1,39 +1,69 @@
-# use-ruby
+# setup-ruby
-This action downloads a prebuilt ruby and adds it to `$PATH`.
+This action downloads a prebuilt ruby and adds it to the `PATH`.
-It is very efficient and takes about 5 seconds to download, extract and add the given Ruby to `$PATH`.
+It is very efficient and takes about 5 seconds to download, extract and add the given Ruby to the `PATH`.
 No extra packages need to be installed.
 **Important:** Prefer `ruby/setup-ruby@v1`.
 If you pin to a commit or release, only the Ruby versions available at the time of the commit
 will be available, and you will need to update it to use newer Ruby versions, see [Versioning](#versioning).
 ### Supported Versions
 This action currently supports these versions of MRI, JRuby and TruffleRuby:
 | Interpreter | Versions |
 | ----------- | -------- |
-| Ruby | 2.3.8, 2.4.9, 2.5.7, 2.6.5, 2.7.0 |
+| `ruby` | 1.9.3, 2.0.0, 2.1.9, 2.2, all versions from 2.3.0 until 4.0.2, head, debug, mingw, mswin, ucrt |
-| JRuby | 9.2.9.0 |
+| `jruby` | 9.1.17.0 - 10.0.4.0, head |
-| TruffleRuby  | 19.3.0 |
+| `truffleruby` | 19.3.0 - 33.0.1, head |
 | `truffleruby+graalvm` | 21.2.0 - 33.0.1, head |
-The recommended way to refer to these versions is:
+`ruby-debug` is the same as `ruby-head` but with assertions enabled (`-DRUBY_DEBUG=1`).
 `2.3`, `2.4`, `2.5`, `2.6`, `2.7`, `jruby`, `truffleruby`.  
 That way, the latest compatible release is used, which contains the most bug fixes.
-See https://github.com/eregon/ruby-install-builder/blob/metadata/versions.json
+`ruby-asan` is the same as `ruby-head` but with AddressSanitizer (ASan) enabled, helpful for finding memory issues in native extensions.
-for the always up-to-date list of available Ruby versions.
+Native extensions are automatically compiled with AddressSanitizer when using `ruby-asan`.
 `ruby-asan` is currently only available on `ubuntu-24.04`.
-Note that Ruby 2.3 and the OpenSSL version it needs (1.0.2) are both end-of-life,
+`asan-release` is similar to `ruby-asan` but built from the latest stable release tag.
-which means Ruby 2.3 is unmaintained and considered insecure.
+Like `ruby-asan`, it's currently only available on `ubuntu-24.04`.
 Regarding Windows ruby master builds, `mingw` is a MSYS2/MinGW build, `head` & `ucrt` are MSYS2/UCRT64
 builds, and `mswin` is a MSVC/VS 2022 build.
 Preview and RC versions of Ruby might be available too on Ubuntu and macOS (not on Windows).
 However, it is recommended to test against `ruby-head` rather than previews,
 as it provides more useful feedback for the Ruby core team and for upcoming changes.
 Only release versions published by [RubyInstaller](https://rubyinstaller.org/downloads/archives/)
 are available on Windows.  Due to that, Ruby 2.2 resolves to 2.2.6 on Windows and 2.2.10
 on other platforms. Ruby 2.3 on Windows only has builds for 2.3.0, 2.3.1 and 2.3.3.
 Note that Ruby ≤ 2.4 and the OpenSSL version it needs (1.0.2) are both end-of-life,
 which means Ruby ≤ 2.4 is unmaintained and considered insecure.
 ### Supported Platforms
-The action works for all GitHub-hosted runners:
+The action works on these [GitHub-hosted runners](https://docs.github.com/en/actions/reference/runners/github-hosted-runners) images. Runner images not listed below are not supported yet. `$OS-latest` just alias to one of these images.
 `ubuntu-16.04`, `ubuntu-18.04`, `macos-latest` and `windows-latest`.
-Ruby 2.3, JRuby and TruffleRuby are not yet supported on `windows-latest`.
+| Operating System | Supported |
 | ---------------- | --------- |
 | Ubuntu  | `ubuntu-22.04`, `ubuntu-24.04`, `ubuntu-22.04-arm`, `ubuntu-24.04-arm` |
 | macOS   | `macos-14` and newer versions |
 | Windows | `windows-2022`, `windows-2025`, `windows-11-arm` |
-The prebuilt rubies are generated by https://github.com/eregon/ruby-install-builder
+Not all combinations of runner images and versions are supported.
-and on Windows by https://github.com/oneclick/rubyinstaller2.
+The list of available Ruby versions can be seen in [ruby-builder-versions.json](ruby-builder-versions.json) for Ubuntu and macOS
 (although some combinations are not available, see [the full list](https://github.com/ruby/ruby-builder/releases/tag/toolcache))
 and in [windows-versions.json](windows-versions.json) for Windows.
 The prebuilt releases are generated by [ruby-builder](https://github.com/ruby/ruby-builder)
 and on Windows by [RubyInstaller2](https://github.com/oneclick/rubyinstaller2).
 The `mingw`, `ucrt` and `mswin` builds are generated by [ruby-loco](https://github.com/MSP-Greg/ruby-loco).
 `ruby-head` is generated by [ruby-dev-builder](https://github.com/ruby/ruby-dev-builder),
 `jruby-head` is generated by [jruby-dev-builder](https://github.com/ruby/jruby-dev-builder),
 `truffleruby-head` and `truffleruby+graalvm-head` are generated by [truffleruby-dev-builder](https://github.com/ruby/truffleruby-dev-builder).
 ## Usage
@@ -41,59 +71,234 @@ and on Windows by https://github.com/oneclick/rubyinstaller2.
 ```yaml
 name: My workflow
-on: [push]
+on: [push, pull_request]
 jobs:
  test:
    runs-on: ubuntu-latest
    steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v6
-    - uses: eregon/use-ruby-action@master
+    - uses: ruby/setup-ruby@v1
      with:
-        ruby-version: 2.6
+        ruby-version: '3.4' # Not needed with a .ruby-version, .tool-versions or mise.toml
-    - run: ruby -v
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
    - run: bundle exec rake
 ```
-### Matrix
+### Matrix of Ruby Versions
-This matrix tests all stable releases of MRI, JRuby and TruffleRuby on Ubuntu and macOS.
+This matrix tests all stable releases and `head` versions of MRI, JRuby and TruffleRuby on Ubuntu and macOS.
 ```yaml
 name: My workflow
-on: [push]
+on: [push, pull_request]
 jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
-        os: [ ubuntu-latest, macos-latest ]
+        os: [ubuntu-latest, macos-latest]
-        ruby: [ 2.4, 2.5, 2.6, 2.7, jruby, truffleruby ]
+        # Due to https://github.com/actions/runner/issues/849, we have to use quotes for '3.0'
        ruby: ['2.7', '3.0', '3.1', '3.2', '3.3', '3.4', head, jruby, jruby-head, truffleruby, truffleruby-head]
    runs-on: ${{ matrix.os }}
    steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v6
-    - uses: eregon/use-ruby-action@master
+    - uses: ruby/setup-ruby@v1
      with:
        ruby-version: ${{ matrix.ruby }}
-    - run: ruby -v
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
    - run: bundle exec rake
 ```
 ### Matrix of Gemfiles
 ```yaml
 name: My workflow
 on: [push, pull_request]
 jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        gemfile: [ rails7, rails8 ]
    runs-on: ubuntu-latest
    env: # $BUNDLE_GEMFILE must be set at the job level, so it is set for all steps
      BUNDLE_GEMFILE: ${{ github.workspace }}/gemfiles/${{ matrix.gemfile }}.gemfile
    steps:
      - uses: actions/checkout@v6
      - uses: ruby/setup-ruby@v1
        with:
          ruby-version: '3.4'
          bundler-cache: true # runs 'bundle install' and caches installed gems automatically
      - run: bundle exec rake
 ```
 See the GitHub Actions documentation for more details about the
 [workflow syntax](https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions)
 and the [condition and expression syntax](https://help.github.com/en/actions/reference/context-and-expression-syntax-for-github-actions).
 ### Supported Version Syntax
 * engine-version like `ruby-2.6.5` and `truffleruby-19.3.0`
-* short version like `2.6`, automatically using the latest release matching that version (`2.6.5`)
+* short version like `'2.6'`, automatically using the latest release matching that version (`2.6.10`)
-* version only like `2.6.5`, assumes MRI for the engine
+* version only like `'2.6.5'`, assumes MRI for the engine
-* engine only like `truffleruby`, uses the latest stable release of that implementation
+* engine only like `ruby` and `truffleruby`, uses the latest stable release of that implementation
-* `.ruby-version` (also the default value) reads from the project's `.ruby-version` file
+* `.ruby-version` reads from the project's `.ruby-version` file
 * `.tool-versions` reads from the project's `.tool-versions` file
 * `mise.toml` reads from the project's `mise.toml` file
 * If the `ruby-version` input is not specified, `.ruby-version` is tried first, followed by `.tool-versions`, followed by `mise.toml`
 ### Working Directory
 The `working-directory` input can be set to resolve `.ruby-version`, `.tool-versions`, `mise.toml` and `Gemfile.lock`
 if they are not at the root of the repository, see [action.yml](action.yml) for details.
 ### RubyGems
 By default, the default RubyGems version that comes with each Ruby is used.
 However, users can optionally customize the RubyGems version that they want by
 setting the `rubygems` input.
 See [action.yml](action.yml) for more details about the `rubygems` input.
 If you're running into `ArgumentError: wrong number of arguments (given 4,
 expected 1)` errors with a stacktrace including Psych and RubyGems entries, you
 should be able to fix them by setting `rubygems: 3.0.0` or higher.
 ### Bundler
-Currently, Bundler is guaranteed to be installed for all versions.
+By default, Bundler is installed as follows:
 If the Ruby ships with Bundler (Ruby >= 2.6), that version is used.
 Otherwise (Ruby < 2.6), the latest version of Bundler is installed when that Ruby was built.
-## Limitations
+* If there is a `Gemfile.lock` file (or `$BUNDLE_GEMFILE.lock` or `gems.locked`) with a `BUNDLED WITH` section,
  that version of Bundler will be installed and used.
 * If the Ruby ships with Bundler 2.2+ (as a default gem), that version is used.
 * Otherwise, the latest compatible Bundler version is installed (Bundler 2 on Ruby >= 2.3, Bundler 1 on Ruby < 2.3).
-* This action currently only works with GitHub-hosted runners, not private runners.
+This behavior can be customized, see [action.yml](action.yml) for more details about the `bundler` input.
 ### Caching `bundle install` automatically
 This action provides a way to automatically run `bundle install` and cache the result:
 ```yaml
    - uses: ruby/setup-ruby@v1
      with:
        bundler-cache: true
 ```
 Note that any step doing `bundle install` (for the root `Gemfile`) or `gem install bundler` can be removed with `bundler-cache: true`.
 This caching speeds up installing gems significantly and avoids too many requests to RubyGems.org.  
 It needs a `Gemfile` (or `$BUNDLE_GEMFILE` or `gems.rb`) under the [`working-directory`](#working-directory).  
 If there is a `Gemfile.lock` (or `$BUNDLE_GEMFILE.lock` or `gems.locked`), `bundle config --local deployment true` is used.
 To use a `Gemfile` which is not at the root or has a different name, set `BUNDLE_GEMFILE` in the `env` at the job level
 as shown in the [example](#matrix-of-gemfiles).
 #### bundle config
 When using `bundler-cache: true` you might notice there is no good place to run `bundle config ...` commands.
 These can be replaced by `BUNDLE_*` environment variables, which are also faster.
 They should be set in the `env` at the job level as shown in the [example](#matrix-of-gemfiles).
 To find the correct the environment variable name, see the [Bundler docs](https://bundler.io/man/bundle-config.1.html) or look at `.bundle/config` after running `bundle config --local KEY VALUE` locally.
 You might need to `"`-quote the environment variable name in YAML if it has unusual characters like `/`.
 To perform caching, this action will use `bundle config --local path $PWD/vendor/bundle`.  
 Therefore, the Bundler `path` should not be changed in your workflow for the cache to work (no `bundle config path`).
 #### How it Works
 When there is no lockfile, one is generated with `bundle lock`, which is the same as `bundle install` would do first before actually fetching any gem.
 In other words, it works exactly like `bundle install`.
 The hash of the generated lockfile is then used for caching, which is the only correct approach.
 #### Dealing with a corrupted cache
 In some rare scenarios (like using gems with C extensions whose functionality depends on libraries found on the system
 at the time of the gem's build) it may be necessary to ignore contents of the cache and get and build all the gems anew.
 In order to achieve this, set the `cache-version` option to any value other than `0` (or change it to a new unique value
 if you have already used it before.)
 ```yaml
    - uses: ruby/setup-ruby@v1
      with:
        bundler-cache: true
        cache-version: 1
 ```
 #### Caching `bundle install` manually
 It is also possible to cache gems manually, but this is not recommended because it is verbose and *very difficult* to do correctly.
 There are many concerns which means using `actions/cache` is never enough for caching gems (e.g., incomplete cache key, cleaning old gems when restoring from another key, correctly hashing the lockfile if not checked in, OS versions, ABI compatibility for `ruby-head`, etc).
 So, please use `bundler-cache: true` instead and report any issue.
 ### Authentication Token
 By default, this action uses `${{ github.token }}` to authenticate when downloading Ruby release assets from GitHub.
 This helps avoid rate limiting issues.
 If you're running this action on a GitHub Enterprise Server (GHES) instance, or if you're experiencing rate limiting,
 you can provide a custom token:
 ```yaml
    - uses: ruby/setup-ruby@v1
      with:
        token: ${{ secrets.MY_GITHUB_TOKEN }}
 ```
 In most cases, you don't need to set this input as the default value is sufficient for use on github.com.
 ## Windows
 Note that running CI on Windows can be quite challenging if you are not very familiar with Windows.
 It is recommended to first get your build working on Ubuntu and macOS before trying Windows.
 * Use Bundler 2.2.18+ on Windows (older versions have [bugs](https://github.com/ruby/setup-ruby/issues/209#issuecomment-889064123)) by not setting the `bundler:` input and ensuring there is no `BUNDLED WITH 1.x.y` in a checked-in `Gemfile.lock`.
 * The default shell on Windows is not Bash but [PowerShell](https://help.github.com/en/actions/automating-your-workflow-with-github-actions/workflow-syntax-for-github-actions#using-a-specific-shell).
  This can lead issues such as multi-line scripts [not working as expected](https://github.com/ruby/setup-ruby/issues/13).
 * The `PATH` contains [multiple compiler toolchains](https://github.com/ruby/setup-ruby/issues/19). Use `where.exe` to debug which tool is used.
 * For Ruby ≥ 2.4, MSYS2 is prepended to the `Path`, similar to what RubyInstaller2 does.
 * For Ruby < 2.4, the DevKit MSYS tools are installed and prepended to the `Path`.
 * When compiling extension code, note that the packages required to build Ruby are included when using Windows 2022. Additional packages can be installed with [setup-ruby-pkgs](https://github.com/ruby/setup-ruby-pkgs) or via MSYS2's `pacman`. These packages may be required when installing or updating Ruby stdlib extension gems.
 ## Versioning
 It is highly recommended to use `ruby/setup-ruby@v1` for the version of this action.
 This will provide the best experience by automatically getting bug fixes, new Ruby versions and new features.
 If you instead choose a specific version (v1.2.3) or a commit sha, there will be no automatic bug fixes and
 it will be your responsibility to update every time the action no longer works.
 Make sure to always use the latest release before reporting an issue on GitHub.
 This action follows semantic versioning with a moving `v1` branch.
 This follows the [recommendations](https://github.com/actions/toolkit/blob/master/docs/action-versioning.md) of GitHub Actions.
 ## Using self-hosted runners
 This action might work with [self-hosted runners](https://docs.github.com/en/actions/hosting-your-own-runners/about-self-hosted-runners)
 if the [Runner Image](https://github.com/actions/runner-images) is very similar to the ones used by GitHub runners. Notably:
 * Make sure to use the same operating system and version.
 * Make sure to use the same version of libssl.
 * Make sure that the operating system has `libyaml-0` and [`libgmp`](https://stackoverflow.com/questions/26555902/ruby-v-dyld-library-not-loaded-usr-local-lib-libgmp-10-dylib) installed
 * The default tool cache directory (`/opt/hostedtoolcache` on Linux, `/Users/runner/hostedtoolcache` on macOS,
  `C:/hostedtoolcache/windows` on Windows) must be writable by the `runner` user.
  This is necessary since the Ruby builds embed the install path when built and cannot be moved around.
 * `/home/runner` must be writable by the `runner` user.
 In other cases, you will need to install Ruby in the runner tool cache as shown by the action when it detects that case
 (run it so it will show you where to install Ruby).
 You could of course also not use this action and e.g. use Ruby from a system package or use a Docker image instead.
 See also the [`self-hosted:` input](action.yml).
 You can set it to `true` if you want to use custom-built Rubies in your self-hosted toolcache instead of prebuild Rubies.
 ## History
 This action used to be at `eregon/use-ruby-action` and was moved to the `ruby` organization.
 Please [update](https://github.com/ruby/setup-ruby/releases/tag/v1.13.0) if you are using `eregon/use-ruby-action`.
 ## Credits
-Most of the Windows logic is from https://github.com/MSP-Greg/actions-ruby by MSP-Greg.
+The creator of this action is @eregon.
 The current maintainers are @eregon @MSP-Greg @ntkme.
 Most of the Windows logic is based on work by MSP-Greg.
 Many thanks to MSP-Greg and Lars Kanis for the help with Ruby Installer.
@@ -0,0 +1,3 @@
 task :default do
  puts "Hello World from Rake"
 end
@@ -1,16 +1,59 @@
 name: 'Setup Ruby, JRuby and TruffleRuby'
-description: 'Download a prebuilt Ruby and add it to $PATH in 5 seconds'
+description: 'Download a prebuilt Ruby and add it to the PATH in 5 seconds'
 author: 'Benoit Daloze'
 branding:
  color: red
  icon: download
 inputs:
  ruby-version:
-    description: 'Engine and version to use, see the syntax in the README. Reads from .ruby-version if unset.'
+    description: 'Engine and version to use, see the syntax in the README. Reads from .ruby-version, .tool-versions or mise.toml if unset.'
-    default: '.ruby-version'
+    default: 'default'
  rubygems:
    description: |
      The version of RubyGems to use. Either 'default' (the default), 'latest', or a version number (e.g., 3.3.5).
      For 'default', no action is taken and the version of RubyGems that comes with Ruby by default is used.
      For 'latest', `gem update --system` is run to update to the latest compatible RubyGems version.
      Ruby head/master builds will not be updated.
      Similarly, if a version number is given, `gem update --system <version>` is run to update to that version of RubyGems, as long as that version is newer than the one provided by default.
  bundler:
    description: |
      The version of Bundler to install. Either 'Gemfile.lock' (the default), 'default', 'latest', 'none', or a version number (e.g., 1, 2, 2.1, 2.1.4).
      For 'Gemfile.lock', the version of the BUNDLED WITH section from the Gemfile.lock if it exists. If the file or section does not exist then the same as 'default'.
      For 'default', if the Ruby ships with Bundler 2.2+ as a default gem, that version is used, otherwise the same as 'latest'.
      For 'latest', the latest compatible Bundler version is installed (Bundler 2 on Ruby >= 2.3, Bundler 1 on Ruby < 2.3).
      For 'none', nothing is done.
  bundler-cache:
    description: 'Run "bundle install", and cache the result automatically. Either true or false.'
    default: 'false'
  working-directory:
    description: 'The working directory to use for resolving paths for .ruby-version, .tool-versions, mise.toml and Gemfile.lock.'
  cache-version:
    description: |
      Arbitrary string that will be added to the cache key of the bundler cache. Set or change it if you need
      to invalidate the cache.
  self-hosted:
    description: |
      Consider the runner as a self-hosted runner, which means not using prebuilt Ruby binaries which only work
      on GitHub-hosted runners or self-hosted runners with a very similar image to the ones used by GitHub runners.
      The default is to detect this automatically based on the OS, OS version and architecture.
  windows-toolchain:
    description: |
      This input allows to override the default toolchain setup on Windows.
      The default setting ('default') installs a toolchain based on the selected Ruby.
      Specifically, it installs MSYS2 if not already there and installs mingw/ucrt/mswin build tools and packages.
      It also sets environment variables using 'ridk' or 'vcvars64.bat' based on the selected Ruby.
      At present, the only other setting than 'default' is 'none', which only adds Ruby to PATH.
      No build tools or packages are installed, nor are any ENV setting changed to activate them.
  token:
    description: |
      Used to authenticate with GitHub when downloading Ruby release assets.
      When running this action on github.com, the default value is sufficient.
      When running on GHES, you can pass a personal access token for github.com if you are experiencing rate limiting.
    default: ${{ github.server_url == 'https://github.com' && github.token || '' }}
 outputs:
  ruby-prefix:
    description: 'The prefix of the installed ruby'
 runs:
-  using: 'node12'
+  using: 'node24'
  main: 'dist/index.js'
@@ -0,0 +1,274 @@
 const fs = require('fs')
 const os = require('os')
 const path = require('path')
 const core = require('@actions/core')
 const exec = require('@actions/exec')
 const cache = require('@actions/cache')
 const common = require('./common')
 export const DEFAULT_CACHE_VERSION = '0'
 function isValidBundlerVersion(bundlerVersion) {
  return /^\d+(?:\.\d+){0,2}/.test(bundlerVersion) && !bundlerVersion.endsWith('.dev')
 }
 // The returned gemfile is guaranteed to exist, the lockfile might not exist
 export function detectGemfiles() {
  const gemfilePath = process.env['BUNDLE_GEMFILE'] || 'Gemfile'
  if (fs.existsSync(gemfilePath)) {
    return [gemfilePath, `${gemfilePath}.lock`]
  } else if (process.env['BUNDLE_GEMFILE']) {
    throw new Error(`$BUNDLE_GEMFILE is set to ${gemfilePath} but does not exist`)
  }
  if (fs.existsSync("gems.rb")) {
    return ["gems.rb", "gems.locked"]
  }
  return [null, null]
 }
 function readBundledWithFromGemfileLock(lockFile) {
  if (lockFile !== null && fs.existsSync(lockFile)) {
    const contents = fs.readFileSync(lockFile, 'utf8')
    const lines = contents.split(/\r?\n/)
    const bundledWithLine = lines.findIndex(line => /^BUNDLED WITH$/.test(line.trim()))
    if (bundledWithLine !== -1) {
      const nextLine = lines[bundledWithLine+1]
      if (nextLine) {
        const bundlerVersion = nextLine.trim()
        if (isValidBundlerVersion(bundlerVersion)) {
          console.log(`Using Bundler ${bundlerVersion} from ${lockFile} BUNDLED WITH ${bundlerVersion}`)
          return bundlerVersion
        } else {
          console.log(`Could not parse BUNDLED WITH version as a valid Bundler release, ignoring it: ${bundlerVersion}`)
        }
      }
    }
  }
  return null
 }
 export async function installBundler(bundlerVersionInput, rubygemsInputSet, lockFile, platform, rubyPrefix, engine, rubyVersion) {
  let bundlerVersion = bundlerVersionInput
  if (rubygemsInputSet && (bundlerVersion === 'default' || bundlerVersion === 'Gemfile.lock')) {
    console.log('Using the Bundler installed by updating RubyGems')
    return 'unknown'
  }
  if (bundlerVersion === 'Gemfile.lock') {
    let bundlerVersionFromGemfileLock = readBundledWithFromGemfileLock(lockFile)
    if (bundlerVersionFromGemfileLock) {
      bundlerVersion = bundlerVersionFromGemfileLock
    } else {
      bundlerVersion = 'default'
    }
  }
  if (bundlerVersion === 'default') {
    if (common.isBundler2dot2PlusDefault(engine, rubyVersion)) {
      if (common.windows && engine === 'ruby' && (common.isStableVersion(engine, rubyVersion) || rubyVersion === 'head')) {
        // https://github.com/ruby/setup-ruby/issues/371
        console.log(`Installing latest Bundler for ${engine}-${rubyVersion} on Windows because bin/bundle does not work in bash otherwise`)
        bundlerVersion = 'latest'
      } else {
        console.log(`Using Bundler shipped with ${engine}-${rubyVersion}`)
        return common.isBundler4PlusDefault(engine, rubyVersion) ? '4' : '2'
      }
    } else if (common.hasBundlerDefaultGem(engine, rubyVersion)) {
      // Those Rubies have a old Bundler default gem < 2.2 which does not work well for `gem 'foo', github: 'foo/foo'`:
      // https://github.com/ruby/setup-ruby/issues/358#issuecomment-1195899304
      // Also, Ruby 2.6 would get Bundler 1 yet Ruby 2.3 - 2.5 get latest Bundler 2 which might be unexpected.
      console.log(`Using latest Bundler for ${engine}-${rubyVersion} because the default Bundler gem is too old for that Ruby version`)
      bundlerVersion = 'latest'
    } else {
      bundlerVersion = 'latest'
    }
  }
  const targetRubyVersion = common.targetRubyVersion(engine, rubyVersion)
  if (bundlerVersion === 'latest') {
    // Bundler 4 requires Ruby 3.2+
    if (targetRubyVersion < 3.2) {
      bundlerVersion = '2'
    } else {
      bundlerVersion = '4'
    }
  }
  if (isValidBundlerVersion(bundlerVersion)) {
    // OK - input is a 1, 2, or 3 part version number
  } else {
    throw new Error(`Cannot parse bundler input: ${bundlerVersion}`)
  }
  // Only use Bundler 4 on Ruby 3.2+
  if (common.floatVersion(bundlerVersion) >= 4 && targetRubyVersion < 3.2) {
    console.log('Bundler 4 requires Ruby 3.2+, using Bundler 2 instead on Ruby < 3.2')
    bundlerVersion = '2'
  }
  // Use Bundler 1 when we know Bundler 2+ does not work
  if (common.floatVersion(bundlerVersion) >= 2) {
    if (engine === 'ruby' && targetRubyVersion <= 2.2) {
      console.log(`Bundler 2+ requires Ruby 2.3+, using Bundler 1 on Ruby <= 2.2`)
      bundlerVersion = '1'
    } else if (engine === 'ruby' && /^2\.3\.[01]/.test(rubyVersion)) {
      console.log('Ruby 2.3.0 and 2.3.1 have shipped with an old rubygems that only works with Bundler 1')
      bundlerVersion = '1'
    } else if (engine === 'jruby' && rubyVersion.startsWith('9.1')) { // JRuby 9.1 targets Ruby 2.3, treat it the same
      console.log('JRuby 9.1 has a bug with Bundler 2+ (https://github.com/ruby/setup-ruby/issues/108), using Bundler 1 instead on JRuby 9.1')
      bundlerVersion = '1'
    }
  }
  // Use Bundler 2.3 when we use Ruby 2.3.2 - 2.5
  // Use Bundler 2.4 when we use Ruby 2.6-2.7
  if (bundlerVersion === '2') {
    if (targetRubyVersion <= 2.5) { // < 2.3.2 already handled above
      console.log('Ruby 2.3.2 - 2.5 only works with Bundler 2.3')
      bundlerVersion = '2.3'
    } else if (targetRubyVersion <= 2.7) {
      console.log('Ruby 2.6-2.7 only works with Bundler 2.4')
      bundlerVersion = '2.4'
    }
  }
  const gem = path.join(rubyPrefix, 'bin', 'gem')
  const versionParts = [...bundlerVersion.matchAll(/\d+/g)].length
  const bundlerVersionConstraint = versionParts >= 3 ? bundlerVersion : `~> ${bundlerVersion}.0`
  await exec.exec(gem, ['install', 'bundler', '-v', bundlerVersionConstraint])
  return bundlerVersion
 }
 function bundlerConfigSetArgs(bundlerVersion, key, value) {
  if (bundlerVersion.startsWith('1')) {
    return ['config', '--local', key, value]
  } else {
    return ['config', 'set', '--local', key, value]
  }
 }
 export async function bundleInstall(gemfile, lockFile, platform, engine, rubyVersion, bundlerVersion, cacheVersion) {
  if (gemfile === null) {
    console.log('Could not determine gemfile path, skipping "bundle install" and caching')
    return false
  }
  let envOptions = {}
  if (bundlerVersion.match(/^\d+/)) {
    // If a specific Bundler version is given or determined, we need to specify the version to use explicitly until the lockfile exists.
    // Otherwise, a newer version of Bundler might be used.
    console.log(`Setting BUNDLER_VERSION=${bundlerVersion} for "bundle config|lock" commands below to ensure Bundler ${bundlerVersion} is used`)
    envOptions = { env: { ...process.env, BUNDLER_VERSION: bundlerVersion } }
  }
  // config
  const cachePath = 'vendor/bundle'
  // An absolute path, so it is reliably under $PWD/vendor/bundle, and not relative to the gemfile's directory
  const bundleCachePath = path.join(process.cwd(), cachePath)
  await exec.exec('bundle', bundlerConfigSetArgs(bundlerVersion, 'path', bundleCachePath), envOptions)
  if (fs.existsSync(lockFile)) {
    await exec.exec('bundle', bundlerConfigSetArgs(bundlerVersion, 'deployment', 'true'), envOptions)
  } else {
    // Generate the lockfile so we can use it to compute the cache key.
    // This will also automatically pick up the latest gem versions compatible with the Gemfile.
    await exec.exec('bundle', ['lock'], envOptions)
  }
  await core.group(`Print lockfile`, async () =>
    await exec.exec('cat', [lockFile]))
  // cache key
  const paths = [cachePath]
  const baseKey = await computeBaseKey(engine, rubyVersion, lockFile, cacheVersion)
  const key = `${baseKey}-${await common.hashFile(lockFile)}`
  // If only Gemfile.lock changes we can reuse part of the cache, and clean old gem versions below
  const restoreKeys = [`${baseKey}-`]
  console.log(`Cache key: ${key}`)
  // restore cache & install
  let cachedKey = null
  try {
    // .slice() to workaround https://github.com/actions/toolkit/issues/1377
    cachedKey = await cache.restoreCache(paths.slice(), key, restoreKeys)
  } catch (error) {
    if (error.name === cache.ValidationError.name) {
      throw error;
    } else {
      core.info(`[warning] There was an error restoring the cache ${error.message}`)
    }
  }
  if (cachedKey) {
    console.log(`Found cache for key: ${cachedKey}`)
  }
  // Number of jobs should scale with runner, up to a point
  const jobs = Math.min(os.availableParallelism(), 8)
  // Always run 'bundle install' to list the gems
  await exec.exec('bundle', ['install', '--jobs', `${jobs}`])
  // @actions/cache only allows to save for non-existing keys
  // Also, skip saving cache for merge_group event
  if (!common.isExactCacheKeyMatch(key, cachedKey) && process.env['GITHUB_EVENT_NAME'] !== 'merge_group') {
    if (cachedKey) { // existing cache but Gemfile.lock differs, clean old gems
      await exec.exec('bundle', ['clean'])
    }
    // Error handling from https://github.com/actions/cache/blob/master/src/save.ts
    console.log('Saving cache')
    try {
      await cache.saveCache(paths, key)
    } catch (error) {
      if (error.name === cache.ValidationError.name) {
        throw error;
      } else if (error.name === cache.ReserveCacheError.name) {
        core.info(error.message);
      } else {
        core.info(`[warning]${error.message}`)
      }
    }
  }
  return true
 }
 async function computeBaseKey(engine, version, lockFile, cacheVersion) {
  const cwd = process.cwd()
  const bundleWith = process.env['BUNDLE_WITH'] || ''
  const bundleWithout = process.env['BUNDLE_WITHOUT'] || ''
  const bundleOnly = process.env['BUNDLE_ONLY'] || ''
  let key = `setup-ruby-bundler-cache-v6-${common.getOSNameVersionArch()}-${engine}-${version}-wd-${cwd}-with-${bundleWith}-without-${bundleWithout}-only-${bundleOnly}`
  if (cacheVersion !== DEFAULT_CACHE_VERSION) {
    key += `-v-${cacheVersion}`
  }
  if (common.isHeadVersion(version)) {
    if (engine !== 'jruby') {
      let print_abi = "print RbConfig::CONFIG['ruby_version']"
      let abi = ''
      await exec.exec('ruby', ['-e', print_abi], {
        silent: true,
        listeners: {
          stdout: (data) => {
            abi += data.toString();
          }
        }
      });
      key += `-ABI-${abi}`
    }
  }
  key += `-${lockFile}`
  return key
 }
@@ -0,0 +1,449 @@
 const os = require('os')
 const path = require('path')
 const fs = require('fs')
 const util = require('util')
 const stream = require('stream')
 const crypto = require('crypto')
 const core = require('@actions/core')
 const tc = require('@actions/tool-cache')
 const exec = require('@actions/exec')
 const { performance } = require('perf_hooks')
 const linuxOSInfo = require('linux-os-info')
 export const windows = (os.platform() === 'win32')
 // Extract to SSD on Windows, see https://github.com/ruby/setup-ruby/pull/14
 export const drive = (windows ? (process.env['RUNNER_TEMP'] || 'C')[0] : undefined)
 const PATH_ENV_VAR = windows ? 'Path' : 'PATH'
 export const inputs = {
  selfHosted: undefined,
  token: undefined
 }
 export function partition(string, separator) {
  const i = string.indexOf(separator)
  if (i === -1) {
    throw new Error(`No separator ${separator} in string ${string}`)
  }
  return [string.slice(0, i), string.slice(i + separator.length, string.length)]
 }
 let inGroup = false
 export async function measure(name, block) {
  const body = async () => {
    const start = performance.now()
    try {
      return await block()
    } finally {
      const end = performance.now()
      const duration = (end - start) / 1000.0
      console.log(`Took ${duration.toFixed(2).padStart(6)} seconds`)
    }
  }
  if (inGroup) {
    // Nested groups are not yet supported on GitHub Actions
    console.log(`> ${name}`)
    return await body()
  } else {
    inGroup = true
    try {
      return await core.group(name, body)
    } finally {
      inGroup = false
    }
  }
 }
 // Same as mesaure() but without the group, and no time shown on error
 export async function time(name, block) {
  console.log(`> ${name}`)
  const start = performance.now()
  const value = await block()
  const end = performance.now()
  const duration = (end - start) / 1000.0
  console.log(`Took ${duration.toFixed(2).padStart(6)} seconds`)
  return value
 }
 export function isHeadVersion(rubyVersion) {
  // asan-release counts as "head" because the version cannot be selected -- you can only get whatever's latest
  return ['head', 'debug',  'mingw', 'mswin', 'ucrt', 'asan', 'asan-release'].includes(rubyVersion)
 }
 export function isStableVersion(engine, rubyVersion) {
  if (engine.startsWith('truffleruby')) {
    return /^\d+(\.\d+)*(-preview\d+)?$/.test(rubyVersion)
  } else {
    return /^\d+(\.\d+)*$/.test(rubyVersion)
  }
 }
 export function hasBundlerDefaultGem(engine, rubyVersion) {
  return isBundler1Default(engine, rubyVersion) || isBundler2PlusDefault(engine, rubyVersion)
 }
 export function isBundler1Default(engine, rubyVersion) {
  if (engine === 'ruby') {
    return floatVersion(rubyVersion) >= 2.6 && floatVersion(rubyVersion) < 2.7
  } else if (engine.startsWith('truffleruby')) {
    return floatVersion(rubyVersion) < 21.0
  } else if (engine === 'jruby') {
    return false
  } else {
    return false
  }
 }
 export function isBundler2PlusDefault(engine, rubyVersion) {
  if (engine === 'ruby') {
    return floatVersion(rubyVersion) >= 2.7
  } else if (engine.startsWith('truffleruby')) {
    return floatVersion(rubyVersion) >= 21.0
  } else if (engine === 'jruby') {
    return floatVersion(rubyVersion) >= 9.3
  } else {
    return false
  }
 }
 export function isBundler2dot2PlusDefault(engine, rubyVersion) {
  if (engine === 'ruby') {
    return floatVersion(rubyVersion) >= 3.0
  } else if (engine.startsWith('truffleruby')) {
    return floatVersion(rubyVersion) >= 22.0
  } else if (engine === 'jruby') {
    return floatVersion(rubyVersion) >= 9.3
  } else {
    return false
  }
 }
 const UNKNOWN_TARGET_RUBY_VERSION = 9.9
 export function isBundler4PlusDefault(engine, rubyVersion) {
  const version = targetRubyVersion(engine, rubyVersion)
  return version != UNKNOWN_TARGET_RUBY_VERSION && version >= 4.0
 }
 export function targetRubyVersion(engine, rubyVersion) {
  const version = floatVersion(rubyVersion)
  if (engine === 'ruby') {
    return version
  } else if (engine === 'jruby') {
    if (version === 9.1) {
      return 2.3
    } else if (version === 9.2) {
      return 2.5
    } else if (version === 9.3) {
      return 2.6
    } else if (version === 9.4) {
      return 3.1
    } else if (version === 10.0) {
      return 3.4
    }
  } else if (engine.startsWith('truffleruby')) {
    if (version < 21.0) {
      return 2.6
    } else if (version < 22.0) {
      return 2.7
    } else if (version < 23.0) {
      return 3.0
    } else if (version < 23.1) {
      return 3.1
    } else if (version < 24.2) {
      return 3.2
    }
  }
  return UNKNOWN_TARGET_RUBY_VERSION // unknown, assume recent
 }
 export function floatVersion(rubyVersion) {
  const match = rubyVersion.match(/^\d+(\.\d+|$)/)
  if (match) {
    return parseFloat(match[0])
  } else if (isHeadVersion(rubyVersion)) {
    return 999.999
  } else {
    throw new Error(`Could not convert version ${rubyVersion} to a float`)
  }
 }
 export async function hashFile(file) {
  // See https://github.com/actions/runner/blob/master/src/Misc/expressionFunc/hashFiles/src/hashFiles.ts
  const hash = crypto.createHash('sha256')
  const pipeline = util.promisify(stream.pipeline)
  await pipeline(fs.createReadStream(file), hash)
  return hash.digest('hex')
 }
 // macos is not listed explicitly, see below
 const GitHubHostedPlatforms = [
  'ubuntu-22.04-x64',
  'ubuntu-22.04-arm64',
  'ubuntu-24.04-x64',
  'ubuntu-24.04-arm64',
  'windows-2022-x64',
  'windows-2025-x64',
  'windows-11-arm64'
 ]
 // Precisely: whether we have builds for that platform and there are GitHub-hosted runners to test it
 function isSupportedPlatform() {
  const platform = getOSName()
  switch (platform) {
    case 'ubuntu':
      return GitHubHostedPlatforms.includes(getOSNameVersionArch())
    case 'macos':
      // See https://github.com/ruby/ruby-builder/blob/master/README.md#naming
      // 13 on arm64 because of old macos-arm-oss runners
      return (os.arch() === 'x64' && parseInt(getOSVersion()) >= 13) ||
          (os.arch() === 'arm64' && parseInt(getOSVersion()) >= 13)
    case 'windows':
      return GitHubHostedPlatforms.includes(getOSNameVersionArch())
  }
 }
 // Actually a self-hosted runner for which the OS and OS version does not correspond to a GitHub-hosted runner image,
 export function isSelfHostedRunner() {
  if (inputs.selfHosted === undefined) {
    throw new Error('inputs.selfHosted should have been already set')
  }
  return inputs.selfHosted === 'true' || !isSupportedPlatform()
 }
 export function selfHostedRunnerReason() {
  if (inputs.selfHosted === 'true') {
    return 'the self-hosted input was set'
  } else if (!isSupportedPlatform()) {
    return 'the platform does not match a GitHub-hosted runner image (or that image is deprecated and no longer supported)'
  } else {
    return 'unknown reason'
  }
 }
 let osName = undefined
 let osVersion = undefined
 export function getOSName() {
  if (osName !== undefined) {
    return osName
  }
  const platform = os.platform()
  if (platform === 'linux') {
    const info = linuxOSInfo({mode: 'sync'})
    osName = info.id
  } else if (platform === 'darwin') {
    osName = 'macos'
  } else if (platform === 'win32') {
    osName = 'windows'
  } else {
    throw new Error(`Unknown platform ${platform}`)
  }
  return osName
 }
 export function getOSVersion() {
  if (osVersion !== undefined) {
    return osVersion
  }
  const platform = os.platform()
  if (platform === 'linux') {
    const info = linuxOSInfo({mode: 'sync'})
    osVersion = info.version_id
  } else if (platform === 'darwin') {
    // See https://github.com/sindresorhus/macos-release/blob/main/index.js
    const darwinVersion = parseInt(os.release().match(/^\d+/)[0])
    osVersion = `${darwinVersion - 9}`
  } else if (platform === 'win32') {
    osVersion = findWindowsVersion()
  } else {
    throw new Error(`Unknown platform ${platform}`)
  }
  return osVersion
 }
 export function getOSNameVersion() {
  return `${getOSName()}-${getOSVersion()}`
 }
 export function getOSNameVersionArch() {
  return `${getOSName()}-${getOSVersion()}-${os.arch()}`
 }
 function findWindowsVersion() {
  const version = os.version()
  const match = version.match(/^Windows(?: Server)? (\d+) (?:Standard|Datacenter|Enterprise)/)
  if (match) {
    return match[1]
  } else {
    throw new Error('Could not find Windows version')
  }
 }
 export function shouldUseToolCache(engine, version) {
  return (engine === 'ruby' && !isHeadVersion(version)) || isSelfHostedRunner()
 }
 export function getToolCachePath() {
  if (isSelfHostedRunner()) {
    return getRunnerToolCache()
  } else {
    // Rubies prebuilt by this action embed this path rather than using $RUNNER_TOOL_CACHE
    // so use that path if not isSelfHostedRunner()
    return getDefaultToolCachePath()
  }
 }
 export function getRunnerToolCache() {
  const runnerToolCache = process.env['RUNNER_TOOL_CACHE']
  if (!runnerToolCache) {
    throw new Error('$RUNNER_TOOL_CACHE must be set')
  }
  return runnerToolCache
 }
 // Rubies prebuilt by this action embed this path rather than using $RUNNER_TOOL_CACHE
 function getDefaultToolCachePath() {
  const platform = getOSName()
  switch (platform) {
    case 'ubuntu':
      return '/opt/hostedtoolcache'
    case 'macos':
      return '/Users/runner/hostedtoolcache'
    case 'windows':
      return 'C:\\hostedtoolcache\\windows'
  }
 }
 // tc.find() but using RUNNER_TOOL_CACHE=getToolCachePath()
 export function toolCacheFind(engine, version) {
  const originalToolCache = getToolCachePath()
  process.env['RUNNER_TOOL_CACHE'] = getToolCachePath()
  try {
    return tc.find(engineToToolCacheName(engine), version)
  } finally {
    process.env['RUNNER_TOOL_CACHE'] = originalToolCache
  }
 }
 function engineToToolCacheName(engine) {
  return {
    ruby: 'Ruby',
    jruby: 'JRuby',
    truffleruby: 'TruffleRuby',
    "truffleruby+graalvm": 'TruffleRubyGraalVM'
  }[engine]
 }
 export function getToolCacheRubyPrefix(_platform, engine, version) {
  const toolCache = getToolCachePath()
  return path.join(toolCache, engineToToolCacheName(engine), version, os.arch())
 }
 export function toolCacheCompleteFile(toolCacheRubyPrefix) {
  return `${toolCacheRubyPrefix}.complete`
 }
 export function createToolCacheCompleteFile(toolCacheRubyPrefix) {
  fs.writeFileSync(toolCacheCompleteFile(toolCacheRubyPrefix), '')
 }
 // convert windows path like C:\Users\runneradmin to /c/Users/runneradmin
 export function win2nix(path) {
  if (/^[A-Z]:/i.test(path)) {
    // path starts with drive
    path = `/${path[0].toLowerCase()}${partition(path, ':')[1]}`
  }
  return path.replace(/\\/g, '/').replace(/ /g, '\\ ')
 }
 export function setupPath(newPathEntries) {
  const originalPath = process.env[PATH_ENV_VAR].split(path.delimiter)
  let cleanPath = originalPath.filter(entry => !/\bruby\b/i.test(entry))
  core.group(`Modifying ${PATH_ENV_VAR}`, async () => {
    // First remove the conflicting path entries
    if (cleanPath.length !== originalPath.length) {
      console.log(`Entries removed from ${PATH_ENV_VAR} to avoid conflicts with default Ruby:`)
      for (const entry of originalPath) {
        if (!cleanPath.includes(entry)) {
          console.log(`  ${entry}`)
        }
      }
      core.exportVariable(PATH_ENV_VAR, cleanPath.join(path.delimiter))
    }
    console.log(`Entries added to ${PATH_ENV_VAR} to use selected Ruby:`)
    for (const entry of newPathEntries) {
      console.log(`  ${entry}`)
    }
  })
  core.addPath(newPathEntries.join(path.delimiter))
 }
 export async function setupJavaHome(rubyPrefix) {
  await measure("Modifying JAVA_HOME for JRuby", async () => {
    console.log("attempting to run with existing JAVA_HOME")
    const javaHome = process.env['JAVA_HOME']
    let java = javaHome ? path.join(javaHome, 'bin/java') : 'java'
    let ret = await exec.exec(java, ['-jar', path.join(rubyPrefix, 'lib/jruby.jar'), '--version'], {ignoreReturnCode: true})
    if (ret === 0) {
      console.log("JRuby successfully starts, using existing JAVA_HOME")
    } else {
      console.log("JRuby failed to start, try Java 21 envs")
      let arch = os.arch()
      if (arch === "arm64" && os.platform() === "win32") {
        arch = "AARCH64"
      } else if (arch === "x64" || os.platform() !== "darwin") {
        arch = "X64"
      }
      // JAVA_HOME_21_AARCH64 - https://github.com/actions/partner-runner-images/blob/main/images/arm-windows-11-image.md#java
      // JAVA_HOME_21_arm64 - https://github.com/actions/runner-images/blob/main/images/macos/macos-15-arm64-Readme.md#java
      // JAVA_HOME_21_X64 - https://github.com/actions/runner-images/blob/main/images/ubuntu/Ubuntu2404-Readme.md#java
      let newHomeVar = `JAVA_HOME_21_${arch}`
      let newHome = process.env[newHomeVar]
      let bin = path.join(newHome, 'bin')
      if (newHome === "undefined") {
        throw new Error(`JAVA_HOME is not Java 21+ needed for JRuby and \$${newHomeVar} is not defined`)
      }
      console.log(`Setting JAVA_HOME to ${newHomeVar} path ${newHome}`)
      core.exportVariable("JAVA_HOME", newHome)
      console.log(`Adding ${bin} to ${PATH_ENV_VAR}`)
      core.addPath(bin)
    }
  })
 }
 // Determines if two keys are an exact match for the purposes of cache matching
 // Specifically, this is a case-insensitive match that ignores accents
 // From actions/cache@v3 src/utils/actionUtils.ts (MIT)
 export function isExactCacheKeyMatch(key, cacheKey) {
  return !!(
      cacheKey &&
      cacheKey.localeCompare(key, undefined, {
          sensitivity: 'accent'
      }) === 0
  );
 }
 export async function download(url) {
  const auth = inputs.token ? `token ${inputs.token}` : undefined
  return await tc.downloadTool(url, undefined, auth)
 }
@@ -0,0 +1,3 @@
 source 'https://rubygems.org'
 gem "path"
@@ -0,0 +1,13 @@
 GEM
  remote: https://rubygems.org/
  specs:
    path (2.0.1)
 PLATFORMS
  x86_64-linux
 DEPENDENCIES
  path
 BUNDLED WITH
   2.4.0.dev
@@ -0,0 +1,3 @@
 source 'https://rubygems.org'
 gem "bundler", "~> 1.0"
@@ -0,0 +1,12 @@
 source "https://rubygems.org"
 # Ruby < 2.3 only support Bundler 1, which no longer works with gem github:
 if RUBY_VERSION >= '2.3'
  unless Gem::Version.new(Bundler::VERSION) >= Gem::Version.new("2.2.0")
    raise "Expected Bundler 2.2+ is used on Ruby >= 2.3"
  end
  # From https://github.com/ruby/setup-ruby/issues/358#issuecomment-1195899304
  # Tests using github: and the repository uses a non-master default branch.
  gem 'rack-test', github: 'rack/rack-test'
 end
@@ -0,0 +1,3 @@
 source "https://rubygems.org"
 gem "rails", "~> 7.2.0"
@@ -0,0 +1,3 @@
 source "https://rubygems.org"
 gem "rails", "~> 8.0.0"
@@ -0,0 +1,77 @@
 require 'json'
 # Returns unique semantic versions and symbolic versions
 #
 # segment_count = 1 returns unique major versions
 # segment_count = 2 returns unique minor versions
 # segment_count = 3 returns unique patch versions
 def unique_versions(versions, segment_count, *symbolic)
  versions.filter_map do |version|
    next unless Gem::Version.correct?(version)
    ruby_version = Gem::Version.new(version)
    next if ruby_version.prerelease? && ruby_version.segments[-2] != 'p'
    ruby_version.segments[0, segment_count].join('.')
  end.uniq + versions.intersection(symbolic)
 end
 # Runners
 runners = %w[
  macos-14
  macos-15
  macos-15-intel
  ubuntu-22.04
  ubuntu-24.04
  ubuntu-22.04-arm
  ubuntu-24.04-arm
  windows-2022
  windows-2025
  windows-11-arm
 ].freeze
 macos_runners = runners.select { |runner| runner.start_with?('macos-') }
 ubuntu_runners = runners.select { |runner| runner.start_with?('ubuntu-') }
 windows_runners, non_windows_runners = runners.partition { |runner| runner.start_with?('windows-') }
 macos_arm64_runners, _macos_x64_runners = macos_runners.partition { |runner| !runner.end_with?('-intel')}
 ubuntu_arm64_runners, ubuntu_x64_runners = ubuntu_runners.partition { |runner| runner.end_with?('-arm')}
 windows_arm64_runners, windows_x64_runners = windows_runners.partition { |runner| runner.end_with?('-arm') }
 # Versions
 ruby_builder_versions = JSON.load(File.read('ruby-builder-versions.json'))
 windows_versions = JSON.load(File.read('windows-versions.json'))
 # ruby: each minor release + head
 ruby_versions = unique_versions(ruby_builder_versions['ruby'], 2, 'head')
 windows_ruby_versions = unique_versions(windows_versions.keys, 2, 'head')
 matrix = non_windows_runners.product(ruby_versions) + windows_runners.product(windows_ruby_versions)
 # jruby: each major release + head
 jruby_versions = unique_versions(ruby_builder_versions['jruby'], 1, 'head').map { |version| "jruby-#{version}" }
 matrix += runners.product(jruby_versions)
 # truffleruby: latest release + head
 truffleruby_versions = %w[truffleruby truffleruby-head truffleruby+graalvm truffleruby+graalvm-head]
 matrix += non_windows_runners.product(truffleruby_versions)
 # ruby-loco: head
 ruby_loco_versions = %w[mingw mswin ucrt]
 matrix += windows_x64_runners.product(ruby_loco_versions)
 # asan: latest release + head
 asan_versions = %w[asan-release asan]
 matrix += ubuntu_x64_runners.sort.last(1).product(asan_versions)
 # https://github.com/ruby/setup-ruby/pull/596#discussion_r1606047680
 matrix -= (ubuntu_runners - %w[ubuntu-22.04]).product(%w[1.9])
 # https://github.com/ruby/setup-ruby/issues/496
 matrix -= ubuntu_runners.product(%w[2.2])
 # These old Rubies fail to compile on macOS arm64
 matrix -= macos_arm64_runners.product(%w[1.9 2.0 2.1 2.2 2.3 2.4 2.5])
 # These old Rubies fail to compile or segfault on Linux arm64
 matrix -= ubuntu_arm64_runners.product(%w[1.9 2.0 2.1 2.2])
 # RubyInstaller windows-arm64 builds only exist for Ruby 3.4+
 matrix -= windows_arm64_runners.product(%w[2.0 2.1 2.2 2.3 2.4 2.5 2.6 2.7 3.0 3.1 3.2 3.3])
 puts(JSON.generate(matrix.sort.map { |os, ruby| { os:, ruby: } }))
@@ -0,0 +1,120 @@
 require 'open-uri'
 require 'yaml'
 require 'json'
 # General rules:
 # - All the static parts of the expected URL are checked literally.
 # - Each path component must begin with [\w], or a more restrictive character set.
 # - Percent (`%`) shall not be allowed to avoid any percent encoding.
 WINDOWS_VERSIONS_URLS_REGEXPS = [
  %r{\A#{Regexp.escape 'https://github.com/oneclick/rubyinstaller/releases/download'}/\w[\w.-]*/\w[\w.-]*\z},
  %r{\A#{Regexp.escape 'https://github.com/oneclick/rubyinstaller2/releases/download'}/\w[\w.-]*/\w[\w.-]*\z},
  %r{\A#{Regexp.escape 'https://github.com/MSP-Greg/ruby-loco/releases/download'}/\w[\w.-]*/\w[\w.-]*\z}
 ].freeze
 WINDOWS_TOOLCHAIN_VERSIONS_URLS_REGEXPS = [
  %r{\A#{Regexp.escape 'https://github.com/oneclick/rubyinstaller/releases/download/devkit-4.7.2/DevKit-mingw64-64-4.7.2-20130224-1432-sfx.exe'}\z},
  %r{\A#{Regexp.escape 'https://github.com/ruby/setup-msys2-gcc/releases/download'}/\w[\w.-]*/\w[\w@.-]*\z},
  %r{\A#{Regexp.escape 'https://github.com/ruby/setup-msys2-gcc/releases/latest/download'}/\w[\w@.-]*\z}
 ].freeze
 # Validate all the URLs in the versions json
 def validate(versions, allowed_urls_regexps)
  versions.values.flat_map(&:values).each do |url|
    if allowed_urls_regexps.none? { |regexp| regexp.match? url }
      raise SecurityError, "Unexpected URL: #{url}"
    end
  end
 end
 min_requirements = ['~> 2.0.0', '~> 2.1.9', '>= 2.2.6'].map { |req| Gem::Requirement.new(req) }
 url = 'https://raw.githubusercontent.com/oneclick/rubyinstaller.org-website/master/_data/downloads.yaml'
 entries = YAML.load(URI.open(url, &:read), symbolize_names: true)
 versions = entries.select { |entry|
  entry[:filetype] == 'rubyinstaller7z' and
  entry[:name].include?('(x64)') || entry[:name].include?('(arm)')
 }.group_by { |entry|
  entry[:name][/Ruby (\d+\.\d+\.\d+)/, 1]
 }.map { |version, builds_by_version|
  builds = builds_by_version.group_by { |entry|
    entry[:name][/\((x64|arm)\)/, 1]
  }.map { |arch, builds_by_arch|
    arch = 'arm64' if arch == 'arm'
    unless builds_by_arch.sort_by { |build| build[:name] } == builds_by_arch.reverse
      raise "not sorted as expected for #{version}"
    end
    [arch, builds_by_arch.first[:href]]
  }.sort_by { |arch, builds|
    arch
  }.to_h
  [version, builds]
 }.sort_by { |version, entry|
  Gem::Version.new(version)
 }.select { |version, entry|
  min_requirements.any? { |req| req.satisfied_by?(Gem::Version.new(version)) }
 }.to_h
 latest_version = Gem::Version.new(versions.keys.last)
 head_version = Gem::Version.new("#{latest_version.bump}.0dev")
 versions['head'] = {
  'arm64' => 'https://github.com/oneclick/rubyinstaller2/releases/download/rubyinstaller-head/rubyinstaller-head-arm.7z',
  'x64' => 'https://github.com/oneclick/rubyinstaller2/releases/download/rubyinstaller-head/rubyinstaller-head-x64.7z'
 }
 versions['mingw'] = {
  'x64' => 'https://github.com/MSP-Greg/ruby-loco/releases/download/ruby-master/ruby-mingw.7z'
 }
 versions['mswin'] = {
  'x64' => 'https://github.com/MSP-Greg/ruby-loco/releases/download/ruby-master/ruby-mswin.7z'
 }
 versions['ucrt'] = {
  'x64' => 'https://github.com/MSP-Greg/ruby-loco/releases/download/ruby-master/ruby-ucrt.7z'
 }
 validate(versions, WINDOWS_VERSIONS_URLS_REGEXPS)
 File.binwrite 'windows-versions.json', "#{JSON.pretty_generate(versions)}\n"
 base_url = 'https://github.com/ruby/setup-msys2-gcc/releases/latest/download/windows-toolchain.json'
 windows_toolchain = JSON.parse(URI.open(base_url, &:read), symbolize_names: true)
 versions.each do |raw_version, archs|
  version = Gem::Version.correct?(raw_version) ? Gem::Version.new(raw_version) : head_version
  archs.each_key do |raw_arch|
    arch = raw_arch == 'arm64' ? 'aarch64' : raw_arch
    platform =
      case raw_version
      when 'head', 'ucrt'
        "#{arch}-mingw-ucrt"
      when 'mingw'
        "#{arch}-mingw32"
      when 'mswin'
        "#{arch}-mswin64"
      else
        if version >= Gem::Version.new('3.1.0.dev')
          "#{arch}-mingw-ucrt"
        else
          "#{arch}-mingw32"
        end
      end
    toolchain =
      windows_toolchain.select do |pkg|
        pkg[:platform] == platform && pkg[:required_ruby_version].any? do |requirement|
          Gem::Requirement.new(requirement).satisfied_by?(version)
        end
      end
    unless toolchain.one?
      raise "#{toolchain.empty? ? 'no' : 'multiple'} toolchains found for #{raw_version} #{raw_arch}: #{toolchain}"
    end
    archs[raw_arch] = URI.join(base_url, toolchain.first[:href]).to_s
  end
 end
 validate(versions, WINDOWS_TOOLCHAIN_VERSIONS_URLS_REGEXPS)
 File.binwrite 'windows-toolchain-versions.json', "#{JSON.pretty_generate(versions)}\n"
@@ -1,112 +1,229 @@
 const os = require('os')
 const fs = require('fs')
 const path = require('path')
 const core = require('@actions/core')
-const io = require('@actions/io')
+const exec = require('@actions/exec')
-const tc = require('@actions/tool-cache')
+const common = require('./common')
-const axios = require('axios')
+const rubygems = require('./rubygems')
-const windows = require('./windows')
+const bundler = require('./bundler')
-const releasesURL = 'https://github.com/eregon/ruby-install-builder/releases'
+const windows = common.windows
 const metadataURL = 'https://raw.githubusercontent.com/eregon/ruby-install-builder/metadata'
-async function run() {
+const inputDefaults = {
  'ruby-version': 'default',
  'rubygems': 'default',
  'bundler': 'Gemfile.lock',
  'bundler-cache': 'false',
  'working-directory': '.',
  'cache-version': bundler.DEFAULT_CACHE_VERSION,
  'self-hosted': 'false',
  'windows-toolchain': 'default',
  'token': '',
 }
 // entry point when this action is run on its own
 export async function run() {
  try {
-    const platform = getVirtualEnvironmentName()
+    await setupRuby()
    const ruby = await getRubyEngineAndVersion(core.getInput('ruby-version'))
    let rubyPrefix
    if (platform === 'windows-latest') {
      rubyPrefix = await windows.downloadExtractAndSetPATH(ruby)
    } else {
      rubyPrefix = await downloadAndExtract(platform, ruby)
      core.addPath(`${rubyPrefix}/bin`)
    }
    core.setOutput('ruby-prefix', rubyPrefix)
  } catch (error) {
-    core.setFailed(error.message)
+    if (/\bprocess\b.+\bfailed\b/.test(error.message)) {
      core.setFailed(error.message)
    } else {
      core.setFailed(error.stack)
    }
  }
  // Explicit process.exit() to not wait hanging promises,
  // see https://github.com/ruby/setup-ruby/issues/543
  process.exit()
 }
-async function downloadAndExtract(platform, ruby) {
+// entry point when this action is run from other actions
-  const rubiesDir = `${process.env.HOME}/.rubies`
+export async function setupRuby(options = {}) {
-  await io.mkdirP(rubiesDir)
+  const inputs = { ...options }
  for (const key in inputDefaults) {
    if (!Object.prototype.hasOwnProperty.call(inputs, key)) {
      inputs[key] = core.getInput(key) || inputDefaults[key]
    }
  }
  common.inputs.selfHosted = inputs['self-hosted']
  common.inputs.token = inputs['token']
-  const tag = await getLatestReleaseTag()
+  process.chdir(inputs['working-directory'])
  const url = `${releasesURL}/download/${tag}/${ruby}-${platform}.tar.gz`
  console.log(url)
-  const downloadPath = await tc.downloadTool(url)
+  const platform = common.getOSNameVersion()
-  await tc.extractTar(downloadPath, rubiesDir)
+  const [engine, parsedVersion] = parseRubyEngineAndVersion(inputs['ruby-version'])
-  return `${rubiesDir}/${ruby}`
+  let installer
  if (platform.startsWith('windows-') && engine === 'ruby' && !common.isSelfHostedRunner()) {
    installer = require('./windows')
  } else {
    installer = require('./ruby-builder')
  }
  let version
  if (common.isSelfHostedRunner()) {
    // The list of available Rubies in the hostedtoolcache is unrelated to getAvailableVersions()
    version = parsedVersion
  } else {
    const engineVersions = installer.getAvailableVersions(platform, engine)
    version = validateRubyEngineAndVersion(platform, engineVersions, engine, parsedVersion)
  }
  createGemRC(engine, version)
  envPreInstall()
  const rubyPrefix = await installer.install(platform, engine, version)
  await common.measure('Print Ruby version', async () =>
    await exec.exec('ruby', ['--version']))
  const rubygemsInputSet = inputs['rubygems'] !== 'default'
  if (rubygemsInputSet) {
    await common.measure('Updating RubyGems', async () =>
      rubygems.rubygemsUpdate(inputs['rubygems'], rubyPrefix, platform, engine, version))
  }
  // When setup-ruby is used by other actions, this allows code in them to run
  // before 'bundle install'.  Installed dependencies may require additional
  // libraries & headers, build tools, etc.
  if (inputs['afterSetupPathHook'] instanceof Function) {
    await inputs['afterSetupPathHook']({ platform, rubyPrefix, engine, version })
  }
  const [gemfile, lockFile] = bundler.detectGemfiles()
  let bundlerVersion = 'unknown'
  if (inputs['bundler'] !== 'none') {
    bundlerVersion = await common.measure('Installing Bundler', async () =>
      bundler.installBundler(inputs['bundler'], rubygemsInputSet, lockFile, platform, rubyPrefix, engine, version))
  }
  if (inputs['bundler-cache'] === 'true') {
    await common.time('bundle install', async () =>
      bundler.bundleInstall(gemfile, lockFile, platform, engine, version, bundlerVersion, inputs['cache-version']))
  }
  core.setOutput('ruby-prefix', rubyPrefix)
 }
-async function getLatestReleaseTag() {
+function parseRubyEngineAndVersion(rubyVersion) {
-  const response = await axios.get(`${metadataURL}/latest_release.tag`)
+  if (rubyVersion === 'default') {
-  return response.data.trim()
+    if (fs.existsSync('.ruby-version')) {
-}
+      rubyVersion = '.ruby-version'
    } else if (fs.existsSync('.tool-versions')) {
      rubyVersion = '.tool-versions'
    } else if (fs.existsSync('mise.toml')) {
      rubyVersion = 'mise.toml'
    } else {
      throw new Error('input ruby-version needs to be specified if no .ruby-version or .tool-versions file exists')
    }
  }
 async function getRubyEngineAndVersion(rubyVersion) {
  if (rubyVersion === '.ruby-version') { // Read from .ruby-version
    rubyVersion = fs.readFileSync('.ruby-version', 'utf8').trim()
    console.log(`Using ${rubyVersion} as input from file .ruby-version`)
  } else if (rubyVersion === '.tool-versions') { // Read from .tool-versions
    const toolVersions = fs.readFileSync('.tool-versions', 'utf8').trim()
    const regexp = /^ruby\s+(\S+)/
    const rubyLine = toolVersions.split(/\r?\n/).filter(e => regexp.test(e))[0]
    rubyVersion = rubyLine.match(regexp)[1]
    console.log(`Using ${rubyVersion} as input from file .tool-versions`)
  } else if (rubyVersion === 'mise.toml') { // Read from mise.toml
    const toolVersions = fs.readFileSync('mise.toml', 'utf8').trim()
    const regexp = /^\s*ruby\s*=\s*['"]([^'"]+)['"]\s*(?:#.*)?$/
    const rubyLine = toolVersions.split(/\r?\n/).filter(e => regexp.test(e))[0]
    rubyVersion = rubyLine.match(regexp)[1]
    console.log(`Using ${rubyVersion} as input from file mise.toml`)
  }
  let engine, version
-  if (rubyVersion.match(/^\d+/)) { // X.Y.Z => ruby-X.Y.Z
+  if (/^(\d+)/.test(rubyVersion) || common.isHeadVersion(rubyVersion)) { // X.Y.Z => ruby-X.Y.Z
    engine = 'ruby'
    version = rubyVersion
  } else if (!rubyVersion.includes('-')) { // myruby -> myruby-stableVersion
    engine = rubyVersion
-    version = '' // Let the logic below find the version
+    version = '' // Let the logic in validateRubyEngineAndVersion() find the version
  } else { // engine-X.Y.Z
-    [engine, version] = rubyVersion.split('-', 2)
+    [engine, version] = common.partition(rubyVersion, '-')
  }
-  const response = await axios.get(`${metadataURL}/versions.json`)
+  return [engine, version]
-  const stableVersions = response.data
+}
-  const engineVersions = stableVersions[engine]
+
 function validateRubyEngineAndVersion(platform, engineVersions, engine, parsedVersion) {
  if (!engineVersions) {
-    throw new Error(`Unknown engine ${engine} (input: ${rubyVersion})`)
+    throw new Error(`Unknown engine ${engine} on ${platform}`)
  }
-  if (!engineVersions.includes(version)) {
+  let version = parsedVersion
  if (!engineVersions.includes(parsedVersion)) {
    const latestToFirstVersion = engineVersions.slice().reverse()
-    const found = latestToFirstVersion.find(v => v.startsWith(version))
+    // Try to match stable versions first, so an empty version (engine-only) matches the latest stable version
    let found = latestToFirstVersion.find(v => common.isStableVersion(engine, v) && v.startsWith(parsedVersion))
    if (!found) {
      // Exclude head versions, they must be exact matches
      found = latestToFirstVersion.find(v => !common.isHeadVersion(v) && v.startsWith(parsedVersion))
    }
    if (found) {
      version = found
    } else {
-      throw new Error(`Unknown version ${version} for ${engine}
+      throw new Error(`Unknown version ${parsedVersion} for ${engine} on ${platform}
-        input: ${rubyVersion}
+        Available versions for ${engine} on ${platform}: ${engineVersions.join(', ')}
-        available versions for ${engine}: ${engineVersions.join(', ')}
+        Make sure you use the latest version of the action with - uses: ruby/setup-ruby@v1`)
        File an issue at https://github.com/eregon/ruby-install-builder/issues if would like support for a new version`)
    }
  }
-  return engine + '-' + version
+  // Well known version-platform combinations which do not work:
  if (engine === 'ruby' && platform.startsWith('macos') && os.arch() === 'arm64' && common.floatVersion(version) < 2.6) {
    throw new Error(`CRuby < 2.6 does not support macos-arm64.
        Either use a newer Ruby version or use a macOS image running on amd64, e.g., macos-15-intel.
        Note that GitHub changed the meaning of macos-latest from macos-12 (amd64) to macos-14 (arm64):
        https://github.blog/changelog/2024-04-01-macos-14-sonoma-is-generally-available-and-the-latest-macos-runner-image/
        If you are using a matrix of Ruby versions, a good solution is to run only < 2.6 on amd64, like so:
        matrix:
          ruby: ['2.4', '2.5', '2.6', '2.7', '3.0', '3.1', '3.2', '3.3']
          os: [ ubuntu-latest, macos-latest ]
          # CRuby < 2.6 does not support macos-arm64, so test those on amd64 instead
          exclude:
          - { os: macos-latest, ruby: '2.4' }
          - { os: macos-latest, ruby: '2.5' }
          include:
          - { os: macos-15-intel, ruby: '2.4' }
          - { os: macos-15-intel, ruby: '2.5' }
        But of course you should consider dropping support for these long-EOL Rubies, which cannot even be built on recent macOS machines.`)
  } else if (engine === 'truffleruby' && platform.startsWith('windows')) {
    throw new Error('TruffleRuby does not currently support Windows.')
  }
  return version
 }
-function getVirtualEnvironmentName() {
+function createGemRC(engine, version) {
-  const platform = os.platform()
+  const gemrc = path.join(os.homedir(), '.gemrc')
-  if (platform == 'linux') {
+  if (!fs.existsSync(gemrc)) {
-    return `ubuntu-${findUbuntuVersion()}`
+    if (engine === 'ruby' && common.floatVersion(version) < 2.0) {
-  } else if (platform == 'darwin') {
+      fs.writeFileSync(gemrc, `install: --no-rdoc --no-ri${os.EOL}update: --no-rdoc --no-ri${os.EOL}`)
-    return 'macos-latest'
+    } else {
-  } else if (platform == 'win32') {
+      fs.writeFileSync(gemrc, `gem: --no-document${os.EOL}`)
-    return 'windows-latest'
+    }
  } else {
    throw new Error(`Unknown platform ${platform}`)
  }
 }
-function findUbuntuVersion() {
+// sets up ENV variables
-  const lsb_release = fs.readFileSync('/etc/lsb-release', 'utf8')
+// currently only used on Windows runners
-  const match = lsb_release.match(/^DISTRIB_RELEASE=(\d+\.\d+)$/m)
+function envPreInstall() {
-  if (match) {
+  const ENV = process.env
-    return match[1]
+  if (windows) {
-  } else {
+    // puts normal Ruby temp folder on SSD
-    throw new Error('Could not find Ubuntu version')
+    core.exportVariable('TMPDIR', ENV['RUNNER_TEMP'])
    // bash - sets home to match native windows
    core.exportVariable('HOME', os.homedir())
    // bash - needed to maintain Path from Windows
    core.exportVariable('MSYS2_PATH_TYPE', 'inherit')
  }
 }
-run()
+if (__filename.endsWith('index.js')) { run() }
@@ -0,0 +1,57 @@
 versions = ARGV.fetch(0).split(',').map(&:strip)
 p versions
 versions.each do |engine_version|
  puts engine_version
  engine, version = engine_version.split('-', 2)
  p [engine, version]
  match = case engine
  when 'ruby', 'jruby'
    /^\d+\.\d+\./
  when 'truffleruby', 'truffleruby+graalvm'
    /^\d+\./
  end
  raise engine_version unless version[match]
  # Update ruby-builder-versions.json
  file = "#{__dir__}/ruby-builder-versions.json"
  lines = File.readlines(file, chomp: true)
  from = lines.index { |line| line.include?(%{"#{engine}": [}) }
  raise "Could not find start of #{engine}" unless from
  to = from
  to += 1 until lines[to].include?(']')
  from += 1 # [
  to -= 2 # head, ]
  puts lines[from..to]
  release_line = lines[from..to].find { |line|
    v = line[/"([^"]+)"/, 1] and v[match] == version[match]
  }
  if release_line
    append = " #{version.inspect},"
    release_line << append unless release_line.end_with?(append)
  else
    lines.insert to+1, "    #{version.inspect},"
  end
  File.write(file, lines.join("\n") + "\n")
  # Update README.md
  file = "#{__dir__}/README.md"
  lines = File.readlines(file)
  engine_line = lines.find { |line| line.start_with?("| `#{engine}`") }
  engine_line.sub!(/(.+ (?:-|until)) (\d+(?:\.\d+)+(?:-\w+)?)/) do
    if Gem::Version.new(version) > Gem::Version.new($2)
      "#{$1} #{version}"
    else
      $&
    end
  end
  File.write(file, lines.join)
 end
@@ -1,15 +1,15 @@
 {
-  "name": "use-ruby-action",
+  "name": "setup-ruby",
  "version": "0.1.0",
-  "description": "Download a prebuilt ruby and add it to $PATH",
+  "description": "Download a prebuilt Ruby and add it to the PATH in 5 seconds",
  "main": "index.js",
  "license": "MIT",
  "scripts": {
    "lint": "eslint *.js",
    "package": "ncc build index.js -o dist"
  },
  "repository": {
    "type": "git",
-    "url": "git+https://github.com/eregon/use-ruby-action.git"
+    "url": "git+https://github.com/ruby/setup-ruby.git"
  },
  "keywords": [
    "GitHub",
@@ -17,19 +17,20 @@
    "Ruby"
  ],
  "author": "Benoit Daloze",
  "license": "MIT",
  "bugs": {
-    "url": "https://github.com/eregon/use-ruby-action/issues"
+    "url": "https://github.com/ruby/setup-ruby/issues"
  },
-  "homepage": "https://github.com/eregon/use-ruby-action",
+  "homepage": "https://github.com/ruby/setup-ruby",
  "dependencies": {
-    "@actions/core": "^1.1.1",
+    "@actions/cache": "^5.0.3",
-    "@actions/io": "^1.0.1",
+    "@actions/core": "^2.0.2",
-    "@actions/tool-cache": "^1.1.2",
+    "@actions/exec": "^2.0.0",
-    "axios": "^0.19.0"
+    "@actions/io": "^2.0.0",
    "@actions/tool-cache": "^3.0.0",
    "linux-os-info": "^2.0.0",
    "semver": "^7.7.3"
  },
  "devDependencies": {
-    "@zeit/ncc": "^0.20.5",
+    "@vercel/ncc": "^0.38.3"
    "eslint": "^6.3.0"
  }
 }
@@ -0,0 +1,8 @@
 #!/bin/sh
 set -e
 if [ "$(dirname "$0")" != ".git/hooks" ] || git diff --cached --name-only | grep -E '.(js|json)$|yarn.lock'; then
  yarn install
  yarn run package
  exec git add dist/index.js
 fi
@@ -0,0 +1,17 @@
 require 'json'
 def run(command_line)
  puts "$ #{command_line}"
  output = `#{command_line}`
  puts output
  raise $?.inspect unless $?.success?
  output
 end
 latest_release_tag = run 'gh release view --json tagName'
 latest_release_tag = JSON.load(latest_release_tag).fetch('tagName')
 raise latest_release_tag unless latest_release_tag =~ /\Av(\d+).(\d+).(\d+)\z/
 tag = "v#{$1}.#{Integer($2)+1}.0"
 run "gh release create --generate-notes --latest #{tag}"
@@ -0,0 +1,49 @@
 {
  "ruby": [
    "1.9.3-p551",
    "2.0.0-p648",
    "2.1.9",
    "2.2.10",
    "2.3.0", "2.3.1", "2.3.2", "2.3.3", "2.3.4", "2.3.5", "2.3.6", "2.3.7", "2.3.8",
    "2.4.0", "2.4.1", "2.4.2", "2.4.3", "2.4.4", "2.4.5", "2.4.6", "2.4.7", "2.4.9", "2.4.10",
    "2.5.0", "2.5.1", "2.5.2", "2.5.3", "2.5.4", "2.5.5", "2.5.6", "2.5.7", "2.5.8", "2.5.9",
    "2.6.0", "2.6.1", "2.6.2", "2.6.3", "2.6.4", "2.6.5", "2.6.6", "2.6.7", "2.6.8", "2.6.9", "2.6.10",
    "2.7.0", "2.7.1", "2.7.2", "2.7.3", "2.7.4", "2.7.5", "2.7.6", "2.7.7", "2.7.8",
    "3.0.0-preview1", "3.0.0-preview2", "3.0.0-rc1", "3.0.0", "3.0.1", "3.0.2", "3.0.3", "3.0.4", "3.0.5", "3.0.6", "3.0.7",
    "3.1.0-preview1", "3.1.0", "3.1.1", "3.1.2", "3.1.3", "3.1.4", "3.1.5", "3.1.6", "3.1.7",
    "3.2.0-preview1", "3.2.0-preview2", "3.2.0-preview3", "3.2.0-rc1", "3.2.0", "3.2.1", "3.2.2", "3.2.3", "3.2.4", "3.2.5", "3.2.6", "3.2.7", "3.2.8", "3.2.9", "3.2.10",
    "3.3.0-preview1", "3.3.0-preview2", "3.3.0-preview3", "3.3.0-rc1", "3.3.0", "3.3.1", "3.3.2", "3.3.3", "3.3.4", "3.3.5", "3.3.6", "3.3.7", "3.3.8", "3.3.9", "3.3.10", "3.3.11",
    "3.4.0-preview1", "3.4.0-preview2", "3.4.0-rc1", "3.4.0", "3.4.1", "3.4.2", "3.4.3", "3.4.4", "3.4.5", "3.4.6", "3.4.7", "3.4.8", "3.4.9",
    "3.5.0-preview1",
    "4.0.0-preview2", "4.0.0-preview3", "4.0.0", "4.0.1", "4.0.2",
    "head", "debug", "asan", "asan-release"
  ],
  "jruby": [
    "9.1.17.0",
    "9.2.9.0", "9.2.10.0", "9.2.11.0", "9.2.11.1", "9.2.12.0", "9.2.13.0", "9.2.14.0", "9.2.15.0", "9.2.16.0", "9.2.17.0", "9.2.18.0", "9.2.19.0", "9.2.20.0", "9.2.20.1", "9.2.21.0",
    "9.3.0.0", "9.3.1.0", "9.3.2.0", "9.3.3.0", "9.3.4.0", "9.3.6.0", "9.3.7.0", "9.3.8.0", "9.3.9.0", "9.3.10.0", "9.3.11.0", "9.3.13.0", "9.3.14.0", "9.3.15.0",
    "9.4.0.0", "9.4.1.0", "9.4.2.0", "9.4.3.0", "9.4.4.0", "9.4.5.0", "9.4.6.0", "9.4.7.0", "9.4.8.0", "9.4.9.0", "9.4.10.0", "9.4.11.0", "9.4.12.0", "9.4.12.1", "9.4.13.0", "9.4.14.0",
    "10.0.0.0", "10.0.0.1", "10.0.1.0", "10.0.2.0", "10.0.3.0", "10.0.4.0",
    "head"
  ],
  "truffleruby": [
    "19.3.0", "19.3.1",
    "20.0.0", "20.1.0", "20.2.0", "20.3.0",
    "21.0.0", "21.1.0", "21.2.0", "21.2.0.1", "21.3.0",
    "22.0.0.2", "22.1.0", "22.2.0", "22.3.0", "22.3.1",
    "23.0.0-preview1", "23.0.0", "23.1.0", "23.1.1", "23.1.2",
    "24.0.0", "24.0.1", "24.0.2", "24.1.0", "24.1.1", "24.1.2", "24.2.0", "24.2.1",
    "25.0.0",
    "33.0.0", "33.0.1",
    "head"
  ],
  "truffleruby+graalvm": [
    "21.2.0", "21.3.0",
    "22.0.0.2", "22.1.0", "22.2.0", "22.3.0", "22.3.1",
    "23.0.0-preview1", "23.0.0", "23.1.0", "23.1.1", "23.1.2",
    "24.0.0", "24.0.1", "24.0.2", "24.1.0", "24.1.1", "24.1.2", "24.2.0", "24.2.1",
    "25.0.0",
    "33.0.0", "33.0.1",
    "head"
  ]
 }
@@ -0,0 +1,130 @@
 const os = require('os')
 const fs = require('fs')
 const path = require('path')
 const core = require('@actions/core')
 const exec = require('@actions/exec')
 const io = require('@actions/io')
 const common = require('./common')
 const rubyBuilderVersions = require('./ruby-builder-versions')
 const releasesURL = 'https://github.com/ruby/ruby-builder/releases'
 const windows = common.windows
 export function getAvailableVersions(platform, engine) {
  return rubyBuilderVersions[engine]
 }
 export async function install(platform, engine, version) {
  let rubyPrefix, inToolCache
  if (common.shouldUseToolCache(engine, version)) {
    inToolCache = common.toolCacheFind(engine, version)
    if (inToolCache) {
      rubyPrefix = inToolCache
    } else {
      const toolCacheRubyPrefix = common.getToolCacheRubyPrefix(platform, engine, version)
      if (common.isSelfHostedRunner()) {
        const rubyBuildDefinition = engine === 'ruby' ? version : `${engine}-${version}`
        core.error(
          `The current runner (${common.getOSNameVersionArch()}) was detected as self-hosted because ${common.selfHostedRunnerReason()}.\n` +
          `In such a case, you should install Ruby in the $RUNNER_TOOL_CACHE yourself, for example using https://github.com/rbenv/ruby-build\n` +
          `You can take inspiration from this workflow for more details: https://github.com/ruby/ruby-builder/blob/master/.github/workflows/build.yml\n` +
          `$ ruby-build ${rubyBuildDefinition} ${toolCacheRubyPrefix}\n` +
          `Once that completes successfully, mark it as complete with:\n` +
          `$ touch ${common.toolCacheCompleteFile(toolCacheRubyPrefix)}\n` +
          `It is your responsibility to ensure installing Ruby like that is not done in parallel.\n`)
        process.exit(1)
      } else {
        rubyPrefix = toolCacheRubyPrefix
      }
    }
  } else if (windows) {
    rubyPrefix = path.join(`${common.drive}:`, `${engine}-${version}`)
  } else {
    rubyPrefix = path.join(os.homedir(), '.rubies', `${engine}-${version}`)
  }
  const paths = [path.join(rubyPrefix, 'bin')]
  // JRuby can use compiled extension code via ffi, so make sure gcc exists.
  if (platform.startsWith('windows') && engine === 'jruby') {
    paths.push(...await require('./windows').installJRubyTools())
  }
  // Set the PATH now, so the MSYS2 'tar' is in Path on Windows
  common.setupPath(paths)
  if (!inToolCache) {
    await io.mkdirP(rubyPrefix)
    await downloadAndExtract(platform, engine, version, rubyPrefix)
  }
  // Ensure JRuby has minimum Java version to run
  if (engine === "jruby") {
    await common.setupJavaHome(rubyPrefix)
  }
  return rubyPrefix
 }
 async function downloadAndExtract(platform, engine, version, rubyPrefix) {
  const parentDir = path.dirname(rubyPrefix)
  const downloadPath = await common.measure('Downloading Ruby', async () => {
    const url = getDownloadURL(platform, engine, version)
    console.log(url)
    try {
      return await common.download(url)
    } catch (error) {
      if (error.message.includes('404')) {
        throw new Error(`Unavailable version ${version} for ${engine} on ${platform}
          You can request it at https://github.com/ruby/setup-ruby/issues
          Cause: ${error.message}`)
      } else {
        throw error
      }
    }
  })
  await common.measure('Extracting  Ruby', async () => {
    if (windows) {
      // Windows 2016 doesn't have system tar, use MSYS2's, it needs unix style paths
      await exec.exec('tar', ['-xz', '-C', common.win2nix(parentDir), '-f', common.win2nix(downloadPath)])
    } else {
      await exec.exec('tar', ['-xz', '-C', parentDir, '-f', downloadPath])
    }
  })
  if (common.shouldUseToolCache(engine, version)) {
    common.createToolCacheCompleteFile(rubyPrefix)
  }
 }
 function getDownloadURL(platform, engine, version) {
  let builderPlatform = null
  if (platform.startsWith('windows-')) {
    builderPlatform = `windows-${os.arch()}`
  } else if (platform.startsWith('macos-')) {
    builderPlatform = `darwin-${os.arch()}`
  } else if (platform.startsWith('ubuntu-')) {
    builderPlatform = `${platform}-${os.arch()}`
  }
  if (builderPlatform === null || !['x64', 'arm64'].includes(os.arch())) {
    throw new Error(`Unknown download URL for platform ${platform}-${os.arch()}`)
  }
  if (common.isHeadVersion(version)) {
    return getLatestHeadBuildURL(builderPlatform, engine, version)
  } else {
    return `${releasesURL}/download/${engine}-${version}/${engine}-${version}-${builderPlatform}.tar.gz`
  }
 }
 function getLatestHeadBuildURL(platform, engine, version) {
  var repo = `${engine}-dev-builder`
  if (engine === 'truffleruby+graalvm') {
    repo = 'truffleruby-dev-builder'
  }
  return `https://github.com/ruby/${repo}/releases/latest/download/${engine}-${version}-${platform}.tar.gz`
 }
@@ -0,0 +1,62 @@
 const common = require('./common')
 const path = require('path')
 const exec = require('@actions/exec')
 const semver = require('semver')
 export async function rubygemsUpdate(rubygemsVersionInput, rubyPrefix, platform, engine, rubyVersion) {
  const gem = path.join(rubyPrefix, 'bin', 'gem')
  let gemVersion = ''
  await exec.exec(gem, ['--version'], {
    listeners: {
      stdout: (data) => (gemVersion += data.toString()),
    }
  });
  gemVersion = semver.coerce(gemVersion.trim())
  console.log(`Default RubyGems version is ${gemVersion}`)
  if (rubygemsVersionInput === 'latest') {
    console.log('Updating RubyGems to latest version')
    await rubygemsLatest(gem, platform, engine, rubyVersion)
  } else if (semver.gt(rubygemsVersionInput, gemVersion)) {
    console.log(`Updating RubyGems to ${rubygemsVersionInput}`)
    await exec.exec(gem, ['update', '--system', rubygemsVersionInput])
  } else {
    console.log(`Skipping RubyGems update because the given version (${rubygemsVersionInput}) is not newer than the default version (${gemVersion})`)
  }
  return true
 }
 // Older RubyGems versions do not account for 'required_ruby_version' when
 // running 'gem update --system', so we have to force a compatible version of
 // rubygems-update.  See https://github.com/ruby/setup-ruby/pull/551 and
 // https://github.com/rubygems/rubygems/issues/7329
 async function rubygemsLatest(gem, platform, engine, rubyVersion) {
  if (engine === 'ruby') {
    const floatVersion = common.floatVersion(rubyVersion)
    if (common.isHeadVersion(rubyVersion)) {
      console.log('Ruby master builds use included RubyGems')
    } else if (floatVersion >= 3.2) {
      await exec.exec(gem, ['update', '--system'])
    } else if (floatVersion >= 3.1) {
      await exec.exec(gem, ['update', '--system', '3.6.9'])
    } else if (floatVersion >= 3.0) {
      await exec.exec(gem, ['update', '--system', '3.5.23'])
    } else if (floatVersion >= 2.6) {
      await exec.exec(gem, ['update', '--system', '3.4.22'])
    } else if (floatVersion >= 2.3) {
      await exec.exec(gem, ['update', '--system', '3.3.27'])
    } else if (floatVersion >= 1.9) {
      await exec.exec(`${gem} install rubygems-update -v 2.7.11 --no-document`)
      await exec.exec('update_rubygems')
    } else {
      console.log(`Cannot update RubyGems for Ruby version ${rubyVersion}`)
    }
  } else {
    // non MRI Rubies (TruffleRuby and JRuby)
    await exec.exec(gem, ['update', '--system'])
  }
 }
@@ -0,0 +1,13 @@
 require 'rbconfig'
 require 'stringio'
 puts "CPPFLAGS: #{RbConfig::CONFIG["CPPFLAGS"]}"
 $stderr = StringIO.new
 begin
  system RbConfig.ruby, "-e", "p :OK"
  out = $stderr.string
 ensure
  $stderr = STDERR
 end
 abort out unless out.empty?
@@ -0,0 +1,33 @@
 require 'json'
 hash = File.read('ruby-builder-versions.json')
 versions = JSON.load(hash).transform_keys(&:to_sym)
 ONLY_LATEST_PATCH = ENV['ONLY_LATEST_PATCH']
 def filter(versions)
  versions -= %w[head]
  if ONLY_LATEST_PATCH
    versions = versions.group_by { |v| v[/^\d+\.\d+/] }.map { _2.last }
  end
  versions
 end
 if ONLY_LATEST_PATCH
  puts filter(versions[:ruby]).map { |v| "ruby-#{v}" }.join(', ')
 else
  by_minor = versions[:ruby].group_by { |v| v[/^\d+\.\d+/] }
  by_minor.each_pair do |minor, versions|
    puts versions.map { |v| "ruby-#{v}" }.join(', ') if minor
  end
 end
 puts
 puts filter(versions[:truffleruby]).map { |v| "truffleruby-#{v}" }.join(', ')
 puts
 puts filter(versions[:"truffleruby+graalvm"]).map { |v| "truffleruby+graalvm-#{v}" }.join(', ')
 puts
 puts filter(versions[:jruby]).map { |v| "jruby-#{v}" }.join(', ')
 puts "For Windows:"
 puts filter(versions[:jruby]).join(', ')
@@ -0,0 +1,309 @@
 {
  "2.0.0": {
    "x64": "https://github.com/oneclick/rubyinstaller/releases/download/devkit-4.7.2/DevKit-mingw64-64-4.7.2-20130224-1432-sfx.exe"
  },
  "2.1.9": {
    "x64": "https://github.com/oneclick/rubyinstaller/releases/download/devkit-4.7.2/DevKit-mingw64-64-4.7.2-20130224-1432-sfx.exe"
  },
  "2.2.6": {
    "x64": "https://github.com/oneclick/rubyinstaller/releases/download/devkit-4.7.2/DevKit-mingw64-64-4.7.2-20130224-1432-sfx.exe"
  },
  "2.3.0": {
    "x64": "https://github.com/oneclick/rubyinstaller/releases/download/devkit-4.7.2/DevKit-mingw64-64-4.7.2-20130224-1432-sfx.exe"
  },
  "2.3.1": {
    "x64": "https://github.com/oneclick/rubyinstaller/releases/download/devkit-4.7.2/DevKit-mingw64-64-4.7.2-20130224-1432-sfx.exe"
  },
  "2.3.3": {
    "x64": "https://github.com/oneclick/rubyinstaller/releases/download/devkit-4.7.2/DevKit-mingw64-64-4.7.2-20130224-1432-sfx.exe"
  },
  "2.4.1": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.4.2": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.4.3": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.4.4": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.4.5": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.4.6": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.4.7": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.4.9": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.4.10": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.5.0": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.5.1": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.5.3": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.5.5": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.5.6": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.5.7": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.5.8": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.5.9": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.6.0": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.6.1": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.6.2": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.6.3": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.6.4": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.6.5": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.6.6": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.6.7": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.6.8": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.6.9": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.6.10": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.7.0": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.7.1": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.7.2": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.7.3": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.7.4": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.7.5": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.7.6": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.7.7": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "2.7.8": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "3.0.0": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "3.0.1": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "3.0.2": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "3.0.3": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "3.0.4": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "3.0.5": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "3.0.6": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "3.0.7": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "3.1.0": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "3.1.1": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "3.1.2": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "3.1.3": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "3.1.4": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "3.1.5": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "3.1.6": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "3.1.7": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64-mingw-w64@r688-gcc@14-openssl@1.1.7z"
  },
  "3.2.0": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64-mingw-w64@r688-gcc@14.7z"
  },
  "3.2.1": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64-mingw-w64@r688-gcc@14.7z"
  },
  "3.2.2": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64-mingw-w64@r688-gcc@14.7z"
  },
  "3.2.3": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64-mingw-w64@r688-gcc@14.7z"
  },
  "3.2.4": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64-mingw-w64@r688-gcc@14.7z"
  },
  "3.2.5": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64-mingw-w64@r688-gcc@14.7z"
  },
  "3.2.6": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64-mingw-w64@r688-gcc@14.7z"
  },
  "3.2.7": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64-mingw-w64@r688-gcc@14.7z"
  },
  "3.2.8": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64-mingw-w64@r688-gcc@14.7z"
  },
  "3.2.9": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64.7z"
  },
  "3.2.10": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64.7z"
  },
  "3.3.0": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64-mingw-w64@r688-gcc@14.7z"
  },
  "3.3.1": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64-mingw-w64@r688-gcc@14.7z"
  },
  "3.3.2": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64-mingw-w64@r688-gcc@14.7z"
  },
  "3.3.3": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64-mingw-w64@r688-gcc@14.7z"
  },
  "3.3.4": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64-mingw-w64@r688-gcc@14.7z"
  },
  "3.3.5": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64-mingw-w64@r688-gcc@14.7z"
  },
  "3.3.6": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64-mingw-w64@r688-gcc@14.7z"
  },
  "3.3.7": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64-mingw-w64@r688-gcc@14.7z"
  },
  "3.3.8": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64-mingw-w64@r688-gcc@14.7z"
  },
  "3.3.9": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64.7z"
  },
  "3.3.10": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64.7z"
  },
  "3.3.11": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64.7z"
  },
  "3.4.1": {
    "arm64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-clangarm64-mingw-w64@r688.7z",
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64-mingw-w64@r688-gcc@14.7z"
  },
  "3.4.2": {
    "arm64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-clangarm64-mingw-w64@r688.7z",
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64-mingw-w64@r688-gcc@14.7z"
  },
  "3.4.3": {
    "arm64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-clangarm64-mingw-w64@r688.7z",
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64-mingw-w64@r688-gcc@14.7z"
  },
  "3.4.4": {
    "arm64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-clangarm64.7z",
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64.7z"
  },
  "3.4.5": {
    "arm64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-clangarm64.7z",
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64.7z"
  },
  "3.4.6": {
    "arm64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-clangarm64.7z",
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64.7z"
  },
  "3.4.7": {
    "arm64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-clangarm64.7z",
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64.7z"
  },
  "3.4.8": {
    "arm64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-clangarm64.7z",
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64.7z"
  },
  "3.4.9": {
    "arm64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-clangarm64.7z",
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64.7z"
  },
  "4.0.0": {
    "arm64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-clangarm64.7z",
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64.7z"
  },
  "4.0.1": {
    "arm64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-clangarm64.7z",
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64.7z"
  },
  "4.0.2": {
    "arm64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-clangarm64.7z",
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64.7z"
  },
  "head": {
    "arm64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-clangarm64.7z",
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64.7z"
  },
  "mingw": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-mingw64.7z"
  },
  "mswin": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/vcpkg-x64-windows.7z"
  },
  "ucrt": {
    "x64": "https://github.com/ruby/setup-msys2-gcc/releases/latest/download/msys2-ucrt64.7z"
  }
 }
@@ -0,0 +1,309 @@
 {
  "2.0.0": {
    "x64": "https://github.com/oneclick/rubyinstaller/releases/download/ruby-2.0.0-p648/ruby-2.0.0-p648-x64-mingw32.7z"
  },
  "2.1.9": {
    "x64": "https://github.com/oneclick/rubyinstaller/releases/download/ruby-2.1.9/ruby-2.1.9-x64-mingw32.7z"
  },
  "2.2.6": {
    "x64": "https://github.com/oneclick/rubyinstaller/releases/download/ruby-2.2.6/ruby-2.2.6-x64-mingw32.7z"
  },
  "2.3.0": {
    "x64": "https://github.com/oneclick/rubyinstaller/releases/download/ruby-2.3.0/ruby-2.3.0-x64-mingw32.7z"
  },
  "2.3.1": {
    "x64": "https://github.com/oneclick/rubyinstaller/releases/download/ruby-2.3.1/ruby-2.3.1-x64-mingw32.7z"
  },
  "2.3.3": {
    "x64": "https://github.com/oneclick/rubyinstaller/releases/download/ruby-2.3.3/ruby-2.3.3-x64-mingw32.7z"
  },
  "2.4.1": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/2.4.1-2/rubyinstaller-2.4.1-2-x64.7z"
  },
  "2.4.2": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/rubyinstaller-2.4.2-2/rubyinstaller-2.4.2-2-x64.7z"
  },
  "2.4.3": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/rubyinstaller-2.4.3-2/rubyinstaller-2.4.3-2-x64.7z"
  },
  "2.4.4": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/rubyinstaller-2.4.4-2/rubyinstaller-2.4.4-2-x64.7z"
  },
  "2.4.5": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/rubyinstaller-2.4.5-1/rubyinstaller-2.4.5-1-x64.7z"
  },
  "2.4.6": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-2.4.6-1/rubyinstaller-2.4.6-1-x64.7z"
  },
  "2.4.7": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-2.4.7-1/rubyinstaller-2.4.7-1-x64.7z"
  },
  "2.4.9": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-2.4.9-1/rubyinstaller-2.4.9-1-x64.7z"
  },
  "2.4.10": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-2.4.10-1/rubyinstaller-2.4.10-1-x64.7z"
  },
  "2.5.0": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/rubyinstaller-2.5.0-2/rubyinstaller-2.5.0-2-x64.7z"
  },
  "2.5.1": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/rubyinstaller-2.5.1-2/rubyinstaller-2.5.1-2-x64.7z"
  },
  "2.5.3": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/rubyinstaller-2.5.3-1/rubyinstaller-2.5.3-1-x64.7z"
  },
  "2.5.5": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-2.5.5-1/rubyinstaller-2.5.5-1-x64.7z"
  },
  "2.5.6": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-2.5.6-1/rubyinstaller-2.5.6-1-x64.7z"
  },
  "2.5.7": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-2.5.7-1/rubyinstaller-2.5.7-1-x64.7z"
  },
  "2.5.8": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-2.5.8-2/rubyinstaller-2.5.8-2-x64.7z"
  },
  "2.5.9": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-2.5.9-1/rubyinstaller-2.5.9-1-x64.7z"
  },
  "2.6.0": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-2.6.0-1/rubyinstaller-2.6.0-1-x64.7z"
  },
  "2.6.1": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-2.6.1-1/rubyinstaller-2.6.1-1-x64.7z"
  },
  "2.6.2": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-2.6.2-1/rubyinstaller-2.6.2-1-x64.7z"
  },
  "2.6.3": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-2.6.3-1/rubyinstaller-2.6.3-1-x64.7z"
  },
  "2.6.4": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-2.6.4-1/rubyinstaller-2.6.4-1-x64.7z"
  },
  "2.6.5": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-2.6.5-1/rubyinstaller-2.6.5-1-x64.7z"
  },
  "2.6.6": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-2.6.6-2/rubyinstaller-2.6.6-2-x64.7z"
  },
  "2.6.7": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-2.6.7-1/rubyinstaller-2.6.7-1-x64.7z"
  },
  "2.6.8": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-2.6.8-1/rubyinstaller-2.6.8-1-x64.7z"
  },
  "2.6.9": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-2.6.9-1/rubyinstaller-2.6.9-1-x64.7z"
  },
  "2.6.10": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-2.6.10-1/rubyinstaller-2.6.10-1-x64.7z"
  },
  "2.7.0": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-2.7.0-1/rubyinstaller-2.7.0-1-x64.7z"
  },
  "2.7.1": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-2.7.1-1/rubyinstaller-2.7.1-1-x64.7z"
  },
  "2.7.2": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-2.7.2-1/rubyinstaller-2.7.2-1-x64.7z"
  },
  "2.7.3": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-2.7.3-1/rubyinstaller-2.7.3-1-x64.7z"
  },
  "2.7.4": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-2.7.4-1/rubyinstaller-2.7.4-1-x64.7z"
  },
  "2.7.5": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-2.7.5-1/rubyinstaller-2.7.5-1-x64.7z"
  },
  "2.7.6": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-2.7.6-1/rubyinstaller-2.7.6-1-x64.7z"
  },
  "2.7.7": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-2.7.7-1/rubyinstaller-2.7.7-1-x64.7z"
  },
  "2.7.8": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-2.7.8-1/rubyinstaller-2.7.8-1-x64.7z"
  },
  "3.0.0": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.0.0-1/rubyinstaller-3.0.0-1-x64.7z"
  },
  "3.0.1": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.0.1-1/rubyinstaller-3.0.1-1-x64.7z"
  },
  "3.0.2": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.0.2-1/rubyinstaller-3.0.2-1-x64.7z"
  },
  "3.0.3": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.0.3-1/rubyinstaller-3.0.3-1-x64.7z"
  },
  "3.0.4": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.0.4-1/rubyinstaller-3.0.4-1-x64.7z"
  },
  "3.0.5": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.0.5-1/rubyinstaller-3.0.5-1-x64.7z"
  },
  "3.0.6": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.0.6-1/rubyinstaller-3.0.6-1-x64.7z"
  },
  "3.0.7": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.0.7-1/rubyinstaller-3.0.7-1-x64.7z"
  },
  "3.1.0": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.1.0-1/rubyinstaller-3.1.0-1-x64.7z"
  },
  "3.1.1": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.1.1-1/rubyinstaller-3.1.1-1-x64.7z"
  },
  "3.1.2": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.1.2-1/rubyinstaller-3.1.2-1-x64.7z"
  },
  "3.1.3": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.1.3-1/rubyinstaller-3.1.3-1-x64.7z"
  },
  "3.1.4": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.1.4-1/rubyinstaller-3.1.4-1-x64.7z"
  },
  "3.1.5": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.1.5-1/rubyinstaller-3.1.5-1-x64.7z"
  },
  "3.1.6": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.1.6-1/rubyinstaller-3.1.6-1-x64.7z"
  },
  "3.1.7": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.1.7-1/rubyinstaller-3.1.7-1-x64.7z"
  },
  "3.2.0": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.2.0-1/rubyinstaller-3.2.0-1-x64.7z"
  },
  "3.2.1": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.2.1-1/rubyinstaller-3.2.1-1-x64.7z"
  },
  "3.2.2": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.2.2-1/rubyinstaller-3.2.2-1-x64.7z"
  },
  "3.2.3": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.2.3-1/rubyinstaller-3.2.3-1-x64.7z"
  },
  "3.2.4": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.2.4-1/rubyinstaller-3.2.4-1-x64.7z"
  },
  "3.2.5": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.2.5-1/rubyinstaller-3.2.5-1-x64.7z"
  },
  "3.2.6": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.2.6-1/rubyinstaller-3.2.6-1-x64.7z"
  },
  "3.2.7": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.2.7-1/rubyinstaller-3.2.7-1-x64.7z"
  },
  "3.2.8": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.2.8-1/rubyinstaller-3.2.8-1-x64.7z"
  },
  "3.2.9": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.2.9-1/rubyinstaller-3.2.9-1-x64.7z"
  },
  "3.2.10": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.2.10-1/rubyinstaller-3.2.10-1-x64.7z"
  },
  "3.3.0": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.3.0-1/rubyinstaller-3.3.0-1-x64.7z"
  },
  "3.3.1": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.3.1-1/rubyinstaller-3.3.1-1-x64.7z"
  },
  "3.3.2": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.3.2-1/rubyinstaller-3.3.2-1-x64.7z"
  },
  "3.3.3": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.3.3-1/rubyinstaller-3.3.3-1-x64.7z"
  },
  "3.3.4": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.3.4-1/rubyinstaller-3.3.4-1-x64.7z"
  },
  "3.3.5": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.3.5-1/rubyinstaller-3.3.5-1-x64.7z"
  },
  "3.3.6": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.3.6-2/rubyinstaller-3.3.6-2-x64.7z"
  },
  "3.3.7": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.3.7-1/rubyinstaller-3.3.7-1-x64.7z"
  },
  "3.3.8": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.3.8-1/rubyinstaller-3.3.8-1-x64.7z"
  },
  "3.3.9": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.3.9-1/rubyinstaller-3.3.9-1-x64.7z"
  },
  "3.3.10": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.3.10-1/rubyinstaller-3.3.10-1-x64.7z"
  },
  "3.3.11": {
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.3.11-1/rubyinstaller-3.3.11-1-x64.7z"
  },
  "3.4.1": {
    "arm64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.4.1-2/rubyinstaller-3.4.1-2-arm.7z",
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.4.1-2/rubyinstaller-3.4.1-2-x64.7z"
  },
  "3.4.2": {
    "arm64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.4.2-1/rubyinstaller-3.4.2-1-arm.7z",
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.4.2-1/rubyinstaller-3.4.2-1-x64.7z"
  },
  "3.4.3": {
    "arm64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.4.3-1/rubyinstaller-3.4.3-1-arm.7z",
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.4.3-1/rubyinstaller-3.4.3-1-x64.7z"
  },
  "3.4.4": {
    "arm64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.4.4-2/rubyinstaller-3.4.4-2-arm.7z",
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.4.4-2/rubyinstaller-3.4.4-2-x64.7z"
  },
  "3.4.5": {
    "arm64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.4.5-1/rubyinstaller-3.4.5-1-arm.7z",
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.4.5-1/rubyinstaller-3.4.5-1-x64.7z"
  },
  "3.4.6": {
    "arm64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.4.6-1/rubyinstaller-3.4.6-1-arm.7z",
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.4.6-1/rubyinstaller-3.4.6-1-x64.7z"
  },
  "3.4.7": {
    "arm64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.4.7-1/rubyinstaller-3.4.7-1-arm.7z",
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.4.7-1/rubyinstaller-3.4.7-1-x64.7z"
  },
  "3.4.8": {
    "arm64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.4.8-1/rubyinstaller-3.4.8-1-arm.7z",
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.4.8-1/rubyinstaller-3.4.8-1-x64.7z"
  },
  "3.4.9": {
    "arm64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.4.9-1/rubyinstaller-3.4.9-1-arm.7z",
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-3.4.9-1/rubyinstaller-3.4.9-1-x64.7z"
  },
  "4.0.0": {
    "arm64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-4.0.0-1/rubyinstaller-4.0.0-1-arm.7z",
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-4.0.0-1/rubyinstaller-4.0.0-1-x64.7z"
  },
  "4.0.1": {
    "arm64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-4.0.1-1/rubyinstaller-4.0.1-1-arm.7z",
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-4.0.1-1/rubyinstaller-4.0.1-1-x64.7z"
  },
  "4.0.2": {
    "arm64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-4.0.2-1/rubyinstaller-4.0.2-1-arm.7z",
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-4.0.2-1/rubyinstaller-4.0.2-1-x64.7z"
  },
  "head": {
    "arm64": "https://github.com/oneclick/rubyinstaller2/releases/download/rubyinstaller-head/rubyinstaller-head-arm.7z",
    "x64": "https://github.com/oneclick/rubyinstaller2/releases/download/rubyinstaller-head/rubyinstaller-head-x64.7z"
  },
  "mingw": {
    "x64": "https://github.com/MSP-Greg/ruby-loco/releases/download/ruby-master/ruby-mingw.7z"
  },
  "mswin": {
    "x64": "https://github.com/MSP-Greg/ruby-loco/releases/download/ruby-master/ruby-mswin.7z"
  },
  "ucrt": {
    "x64": "https://github.com/MSP-Greg/ruby-loco/releases/download/ruby-master/ruby-ucrt.7z"
  }
 }
@@ -1,68 +1,237 @@
-// Most of this logic is from
+// 7z arguments
-// https://github.com/MSP-Greg/actions-ruby/blob/master/lib/main.js
+//   -aoa overwrite existing, -bd disable progress indicator
 const fs = require('fs')
 const os = require('os')
 const path = require('path')
 const cp = require('child_process')
 const core = require('@actions/core')
 const exec = require('@actions/exec')
-const tc = require('@actions/tool-cache')
+const common = require('./common')
 const rubyInstallerVersions = require('./windows-versions.json')
 const toolchainVersions = require('./windows-toolchain-versions.json')
-const releasesURL = 'https://github.com/oneclick/rubyinstaller2/releases'
+export function getAvailableVersions(_platform, engine) {
-
+  if (engine === 'ruby') {
-export async function downloadExtractAndSetPATH(ruby) {
+    return Object.keys(rubyInstallerVersions).filter(version => os.arch() in rubyInstallerVersions[version])
-  const version = ruby.split('-', 2)[1]
+  } else {
-  if (!ruby.startsWith('ruby-') || version.startsWith('2.3')) {
+    return undefined
    throw new Error(`Only ruby >= 2.4 is supported on Windows currently (input: ${ruby})`)
  }
-  const tag = `RubyInstaller-${version}-1`
+}
  const base = `${tag.toLowerCase()}-x64`
-  const url = `${releasesURL}/download/${tag}/${base}.7z`
+export async function install(platform, engine, version) {
-  console.log(url)
+  const url = rubyInstallerVersions[version][os.arch()]
-  const downloadPath = await tc.downloadTool(url)
+  if (!url.endsWith('.7z')) {
-  await exec.exec(`7z x ${downloadPath} -xr!${base}\\share\\doc -oC:\\`)
+    throw new Error(`URL should end in .7z: ${url}`)
-  const rubyPrefix = `C:\\${base}`
+  }
  const base = path.posix.basename(url, '.7z')
-  const msys2 = await linkMSYS2()
+  let rubyPrefix, inToolCache
-  const newPath = setupPath(msys2, rubyPrefix)
+  if (common.shouldUseToolCache(engine, version)) {
-  core.exportVariable('PATH', newPath)
+    inToolCache = common.toolCacheFind(engine, version)
-
+    if (inToolCache) {
-  if (!fs.existsSync(`${rubyPrefix}\\bin\\bundle.cmd`)) {
+      rubyPrefix = inToolCache
-    await exec.exec(`${rubyPrefix}\\bin\\gem install bundler --no-document`)
+    } else {
      rubyPrefix = common.getToolCacheRubyPrefix(platform, engine, version)
    }
  } else {
    rubyPrefix = `${common.drive}:\\${base}`
  }
  if (!inToolCache) {
    await downloadAndExtract(engine, version, url, base, rubyPrefix);
  }
  const paths = [`${rubyPrefix}\\bin`]
  const windowsToolchain = core.getInput('windows-toolchain')
  if (windowsToolchain === 'none') {
    common.setupPath(paths)
    return rubyPrefix
  }
  const toolchainUrl = toolchainVersions[version][os.arch()]
  // Examples:
  // - DevKit-mingw64-64-4.7.2-20130224-1432-sfx.exe
  // - msys2-clangarm64.7z
  // - vcpkg-x64-windows.7z
  const toolchainName = path.posix.basename(toolchainUrl).split('-')[0].toLowerCase()
  if (toolchainName === 'msys2') {
    paths.push(...await installMSYS2(toolchainUrl, rubyPrefix))
  } else {
    if (toolchainName === 'vcpkg') {
      paths.push(...await installVCPKG(toolchainUrl))
    } else if (toolchainName === 'devkit') {
      paths.push(...await installMSYS1(toolchainUrl))
    } else {
      throw new Error(`Unknown toolchain type: ${toolchainUrl}`)
    }
    // Install msys2 for other rubies to provide better command line tools
    paths.push(...await installMSYS2(toolchainVersions['head'][os.arch()]))
  }
  common.setupPath(paths)
  return rubyPrefix
 }
-async function linkMSYS2() {
+async function downloadAndExtract(engine, version, url, base, rubyPrefix) {
-  const toolCacheVersions = tc.findAllVersions('Ruby')
+  const downloadPath = await common.measure('Downloading Ruby', async () => {
-  toolCacheVersions.sort()
+    console.log(url)
-  if (toolCacheVersions.length == 0) {
+    return await common.download(url)
-    throw new Error('Could not find MSYS2 in the toolcache')
+  })
  const extractPath = process.env.RUNNER_TEMP
  await common.measure('Extracting  Ruby', async () =>
    // -xr extract but exclude share\doc files
    exec.exec('7z', ['x', downloadPath, '-bd', `-xr!${base}\\share\\doc`, `-o${extractPath}`], { silent: true }))
  const parentDir = path.dirname(rubyPrefix)
  if (!fs.existsSync(parentDir)) {
    fs.mkdirSync(parentDir, { recursive: true })
  }
  const latestVersion = toolCacheVersions.slice(-1)[0]
  const latestHostedRuby = tc.find('Ruby', latestVersion)
-  const hostedMSYS2 = `${latestHostedRuby}\\msys64`
+  const extractedPath = path.join(extractPath, base)
-  const msys2 = 'C:\\msys64'
+  if (extractedPath[0] === rubyPrefix[0]) {
-  await exec.exec(`cmd /c mklink /D ${msys2} ${hostedMSYS2}`)
+    fs.renameSync(extractedPath, rubyPrefix)
-  return msys2
+  } else {
    fs.symlinkSync(extractedPath, rubyPrefix, 'junction')
  }
  if (common.shouldUseToolCache(engine, version)) {
    common.createToolCacheCompleteFile(rubyPrefix)
  }
 }
-function setupPath(msys2, rubyPrefix) {
+export async function installJRubyTools() {
-  let path = process.env['PATH'].split(';')
+  return await installMSYS2(toolchainVersions['head'][os.arch()])
 }
-  // Remove conflicting dev tools from PATH
+async function installMSYS2(url, rubyPrefix = process.env.RUNNER_TEMP) {
-  path = path.filter(e => !e.match(/\b(Chocolatey|CMake|mingw64|OpenSSL|Strawberry)\b/))
+  const downloadPath = await common.measure('Downloading msys2 build tools', async () => {
    console.log(url)
    return await common.download(url)
  })
-  // Remove default Ruby in PATH
+  const extractPath = path.join(process.env.RUNNER_TEMP, 'msys64')
-  path = path.filter(e => !e.match(/\bRuby\b/))
+  await common.measure('Extracting  msys2 build tools', async () =>
    exec.exec('7z', ['x', downloadPath, '-aoa', '-bd', `-o${extractPath}`], { silent: true }))
-  // Add MSYS2 in PATH
+  // https://github.com/oneclick/rubyinstaller2/blob/HEAD/lib/ruby_installer/build/msys2_installation.rb
-  path.unshift(`${msys2}\\mingw64`, `${msys2}\\usr`)
+  //
  // ri2 searches for msys64 in the following order:
  // - ENV["MSYS2_PATH"]
  // - File.join(RbConfig::TOPDIR, "msys64")
  // - File.join(File.dirname(RbConfig::TOPDIR), "msys64")
  // - "C:\msys64"
  // - ...
  //
  // The first option ENV["MSYS2_PATH"] is only supported in ruby >=3.0.7.
  // Therefore we use the second option to avoid conflict with existing "C:\msys64"
  const msys2Path = path.join(rubyPrefix, 'msys64')
  if (extractPath !== msys2Path) {
    fs.symlinkSync(extractPath, msys2Path, 'junction')
  }
-  // Add the downloaded Ruby in PATH
+  const ridk = `${rubyPrefix}\\bin\\ridk.cmd`
-  path.unshift(`${rubyPrefix}\\bin`)
+  if (fs.existsSync(ridk)) {
    await common.measure('Setting up ridk environment', async () => exportCommandEnv(`set "MAKE=make" && "${ridk}" enable`))
  }
-  return path.join(';')
+  // Examples:
  // - msys2-clangarm64.7z
  // - msys2-ucrt64-gcc@14.7z
  // - msys2-mingw64-gcc@14-openssl@1.1.7z
  const msys2Type = path.posix.basename(url).split(/[-.]/)[1]
  return [`${msys2Path}\\${msys2Type}\\bin`, `${msys2Path}\\usr\\bin`]
 }
 async function installMSYS1(url) {
  const certFile = [
    'C:\\Program Files\\Git\\mingw64\\etc\\ssl\\cert.pem',
    'C:\\Program Files\\Git\\mingw64\\ssl\\cert.pem',
  ].find(file => fs.existsSync(file))
  if (certFile === undefined) {
    throw new Error("Cannot find Git's cert file")
  }
  const downloadPath = await common.measure('Downloading msys1 build tools', async () => {
    console.log(url)
    return await common.download(url)
  })
  const msys1Path = `${common.drive}:\\DevKit64`
  await common.measure('Extracting  msys1 build tools', async () =>
    exec.exec('7z', ['x', downloadPath, '-aoa', '-bd', `-o${msys1Path}`], { silent: true }))
  await common.measure('Setting up DevKit environment', async () => {
    // ssl dlls cause issues with msys1 Rubies
    const sys32 = 'C:\\Windows\\System32\\'
    const badFiles = [`${sys32}libcrypto-1_1-x64.dll`, `${sys32}libssl-1_1-x64.dll`]
    const existing = badFiles.filter((dll) => fs.existsSync(dll))
    if (existing.length > 0) {
      core.warning(`Renaming ${existing.join(' and ')} to avoid dll resolution conflicts on Ruby < 2.4`)
      existing.forEach(dll => fs.renameSync(dll, `${dll}_`))
    }
    exportEnv({
      CC: 'gcc',
      CPP: 'cpp',
      CXX: 'g++',
      MAKE: 'make',
      RI_DEVKIT: msys1Path,
      SSL_CERT_FILE: certFile
    })
  })
  return [`${msys1Path}\\mingw\\x86_64-w64-mingw32\\bin`, `${msys1Path}\\mingw\\bin`, `${msys1Path}\\bin`]
 }
 /* Sets MSVC environment for use in Actions
 *   allows steps to run without running vcvars*.bat, also for PowerShell
 *   this assumes a single Visual Studio version being available in the Windows images */
 async function installVCPKG(url) {
  const downloadPath = await common.measure('Downloading mswin vcpkg packages', async () => {
    console.log(url)
    return await common.download(url)
  })
  const extractPath = process.env.VCPKG_INSTALLATION_ROOT
  await common.measure('Extracting  mswin vcpkg packages', async () =>
    exec.exec('7z', ['x', downloadPath, '-aoa', '-bd', `-o${extractPath}`], { silent: true }))
  return await common.measure('Setting up MSVC environment', async () => {
    const cmd = 'vswhere -latest -property installationPath'
    const vcVarsBat = os.arch() === 'arm64' ? 'vcvarsarm64.bat' : 'vcvars64.bat'
    const vcVars = `${cp.execSync(cmd).toString().trim()}\\VC\\Auxiliary\\Build\\${vcVarsBat}`
    if (!fs.existsSync(vcVars)) {
      throw new Error(`Missing vcVars file: ${vcVars}`)
    }
    return exportCommandEnv(`set "MAKE=nmake" && "${vcVars}"`)
  })
 }
 // Run a cmd command, export its environment, and return new paths
 function exportCommandEnv(command) {
  const cmd = `cmd.exe /s /c "${command} >NUL && "${process.execPath}" -e console.log(JSON.stringify(process.env))"`
  const env = JSON.parse(cp.execSync(cmd).toString())
  const paths = env.Path.replace(`${path.delimiter}${process.env.Path}`, '').split(path.delimiter)
  delete env.Path
  exportEnv(env)
  return paths
 }
 function exportEnv(env) {
  for (const [k, v] of Object.entries(env)) {
    if (process.env[k] !== v) {
      console.log(`${k}=${v}`)
      core.exportVariable(k, v)
    }
  }
 }
		`@@ -0,0 +1,3 @@`
							`source 'https://rubygems.org'`

							`gem "path"`
		`@@ -0,0 +1,3 @@`
							`source 'https://rubygems.org'`

							`gem "bundler", "~> 1.0"`
		`@@ -0,0 +1,3 @@`
							`source "https://rubygems.org"`

							`gem "rails", "~> 7.2.0"`
		`@@ -0,0 +1,3 @@`
							`source "https://rubygems.org"`

							`gem "rails", "~> 8.0.0"`