Fix post -main-merge issue (#213 )

🐛 Fix OTP version null check (#211 )
* Fix OTP version null check * Revert "Fix OTP version null check" This reverts commit 2c433c16ac. * Check that the resolved versions contain the spec. * Only perform semver version resolution when spec is not an rc and version-type is not strict * Move version inclusion check to the end of the function, when we may have prepended a 'v' * Refactor function return * Add test case for strict version resolving a spec that is no available version
2026-07-23 07:06:07 +00:00 · 2023-06-21 15:08:08 -05:00 · 2023-06-15 14:45:56 +01:00 · 2023-06-15 14:45:32 +01:00 · 2023-06-15 14:08:54 +01:00 · 2023-05-17 13:07:48 +01:00
68 changed files with 18792 additions and 4266 deletions
@@ -6,14 +6,16 @@ extends:
  - airbnb
 parserOptions:
  ecmaVersion: 12
-rules: {
-  indent: ["warn", 2],
-  max-len: ["warn", 100],
-  no-console: 0,
-  no-undef: "error",
-  no-unused-vars: ["error", {"varsIgnorePattern": "^_"}],
-  no-use-before-define: 0,
-  operator-linebreak: 0,
-  require-jsdoc: 0,
+rules:
+  indent: ["warn", 2]
+  max-len: ["warn", 100]
+  no-undef: "error"
+  no-unused-vars: ["error", {"varsIgnorePattern": "^_"}]
+  no-use-before-define: 0
+  operator-linebreak: 0
+  require-jsdoc: 0
  semi: 0
-}
+
+settings:
+  react:
+    version: 999.999.999
@@ -0,0 +1,61 @@
+---
+name: action
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    types: [opened, synchronize]
+
+env:
+  GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}
+
+jobs:
+  check_integrity:
+    name: Expected local npm actions
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: '14'
+      - run: npm install -g npm
+      - run: npm install
+      - run: npm run build
+      - run: npm run format
+      - run: npm install -g markdownlint-cli
+      - run: npm run markdownlint
+      - run: npm run shellcheck
+      - run: npm run yamllint
+      - run: npm run jslint
+      - name: Check if build left artifacts
+        run: git diff --exit-code --ignore-space-at-eol
+
+  unit_tests_ubuntu:
+    name: Unit tests (Ubuntu)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: '14'
+      - run: npm ci
+      - run: npm test
+      - name: .tool-versions test
+        id: setup-beam
+        uses: ./
+        with:
+          version-file: test/.tool-versions
+          version-type: strict
+
+  unit_tests_windows:
+    name: Unit tests (Windows)
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: '14'
+      - run: npm install --production
+      - run: npm test
@@ -1,32 +0,0 @@
---
-name: ci
-
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-    branches:
-      - main
-
-jobs:
-  check_integrity:
-    name: Make sure expected pre-release actions are performed
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v1
-        with:
-          node-version: '12'
-      - run: npm install -g npm
-      - run: npm install
-      - run: npm run format
-      - run: npm install -g markdownlint-cli
-      - run: npm run markdownlint
-      - run: npm run shellcheck
-      - run: npm run yamllint
-      - run: npm run jslint
-      - run: npm run licenses
-      - run: npm run build
-      - name: Check if build left artifacts
-        run: git diff --exit-code
@@ -0,0 +1,37 @@
+---
+name: hexpm-mirrors
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  test-failing-first-mirror:
+    name: Test option hexpm-mirrors with a dummy first mirror
+    runs-on: ${{matrix.os}}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: ['ubuntu-22.04', 'windows-2022']
+        otp-version: ['24']
+        elixir-version: ['v1.14', '']
+        install-rebar: [true, false]
+        install-hex: [true, false]
+    steps:
+      - uses: actions/checkout@v3
+      - name: Use erlef/setup-beam
+        id: setup-beam
+        uses: ./
+        with:
+          otp-version: ${{matrix.otp-version}}
+          elixir-version: ${{matrix.elixir-version}}
+          install-rebar: ${{matrix.install-rebar}}
+          install-hex: ${{matrix.install-hex}}
+          hexpm-mirrors: |
+            https://mirror.invalid
+            https://cdn.jsdelivr.net/hex
+            https://builds.hex.pm
@@ -1,138 +0,0 @@
---
-name: test
-
-on:
-  push: {branches: main}
-  pull_request: {branches: main}
-  repository_dispatch:
-  workflow_dispatch:
-
-jobs:
-  unit_test:
-    name: Pre-release unit tests
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v1
-        with: {node-version: '12'}
-      - run: npm ci
-      - run: npm test
-
-  integration_test:
-    name: >
-      Pre-release integration tests
-      (Ubuntu ${{matrix.combo.os}},
-       Erlang/OTP ${{matrix.combo.otp-version}},
-       Elixir ${{matrix.combo.elixir-version}},
-       rebar3 ${{matrix.combo.rebar3-version}})
-    runs-on: ${{matrix.combo.os}}
-    strategy:
-      fail-fast: false
-      matrix:
-        combo:
-          - elixir-version: 'v1.0'
-            otp-version: '17'
-            os: 'ubuntu-16.04'
-          - elixir-version: 'v1.0'
-            otp-version: '17'
-            os: 'ubuntu-18.04'
-          - elixir-version: 'v1.1'
-            otp-version: '18'
-            os: 'ubuntu-16.04'
-          - elixir-version: 'v1.1'
-            otp-version: '18'
-            os: 'ubuntu-18.04'
-          - elixir-version: 'v1.2'
-            otp-version: '19'
-            rebar3-version: '3.10'
-            os: 'ubuntu-16.04'
-          - elixir-version: 'v1.2'
-            otp-version: '19'
-            rebar3-version: '3.10'
-            os: 'ubuntu-18.04'
-          - elixir-version: 'v1.4'
-            otp-version: '20'
-            rebar3-version: '3.11'
-            os: 'ubuntu-16.04'
-          - elixir-version: 'v1.4'
-            otp-version: '20'
-            rebar3-version: '3.11'
-            os: 'ubuntu-18.04'
-          - elixir-version: 'v1.4'
-            otp-version: '20'
-            rebar3-version: '3.11'
-            os: 'ubuntu-20.04'
-          - elixir-version: 'v1.6'
-            otp-version: '21'
-            rebar3-version: '3.12'
-            os: 'ubuntu-16.04'
-          - elixir-version: 'v1.6'
-            otp-version: '21'
-            rebar3-version: '3.12'
-            os: 'ubuntu-18.04'
-          - elixir-version: 'v1.6'
-            otp-version: '21'
-            rebar3-version: '3.12'
-            os: 'ubuntu-20.04'
-          - elixir-version: 'v1.7'
-            otp-version: '22'
-            rebar3-version: '3.13'
-            os: 'ubuntu-16.04'
-          - elixir-version: 'v1.7'
-            otp-version: '22'
-            rebar3-version: '3.13'
-            os: 'ubuntu-18.04'
-          - elixir-version: 'v1.7'
-            otp-version: '22'
-            rebar3-version: '3.13'
-            os: 'ubuntu-20.04'
-          - elixir-version: 'v1.10'
-            otp-version: '23'
-            rebar3-version: '3.14'
-            os: 'ubuntu-16.04'
-          - elixir-version: 'v1.10'
-            otp-version: '23'
-            rebar3-version: '3.14'
-            os: 'ubuntu-18.04'
-          - elixir-version: 'v1.10'
-            otp-version: '23'
-            rebar3-version: '3.14'
-            os: 'ubuntu-20.04'
-          - elixir-version: 'v1.12'
-            otp-version: '24'
-            rebar3-version: '3.15'
-            os: 'ubuntu-20.04'
-    steps:
-      - uses: actions/checkout@v2
-      - name: Use erlef/setup-beam
-        id: setup-beam
-        uses: ./
-        with:
-          otp-version: ${{matrix.combo.otp-version}}
-          elixir-version: ${{matrix.combo.elixir-version}}
-          rebar3-version: ${{matrix.combo.rebar3-version}}
-      - name: Erlang/OTP version (action)
-        run: echo "Erlang/OTP ${{steps.setup-beam.outputs.otp-version}}"
-      - name: Elixir version (action)
-        run: echo "Elixir ${{steps.setup-beam.outputs.elixir-version}}"
-        if: ${{matrix.combo.elixir-version}}
-      - name: rebar3 version (action)
-        run: echo "rebar3 ${{steps.setup-beam.outputs.rebar3-version}}"
-        if: ${{matrix.combo.rebar3-version}}
-      - name: mix version and help (CLI)
-        run: |
-          mix -v
-          mix help local.rebar
-          mix help local.hex
-        if: ${{matrix.combo.elixir-version}}
-      - name: Run Mix project tests
-        run: |
-          cd test-projects/mix
-          mix deps.get
-          mix test
-        if: ${{matrix.combo.elixir-version}}
-      - name: Run rebar3 project tests
-        run: |
-          cd test-projects/rebar3
-          rebar3 ct
-        if: ${{matrix.combo.rebar3-version}}
@@ -0,0 +1,220 @@
+---
+name: ubuntu
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    types: [opened, synchronize]
+
+jobs:
+  integration_test:
+    name: >
+      OTP ${{matrix.combo.otp-version}},
+      Elixir ${{matrix.combo.elixir-version}},
+      Gleam ${{matrix.combo.gleam-version}},
+      rebar3 ${{matrix.combo.rebar3-version}}
+    runs-on: ${{matrix.combo.os}}
+    strategy:
+      fail-fast: false
+      matrix:
+        combo:
+          - otp-version: '25.2'
+            elixir-version: '1.14.3'
+            os: 'ubuntu-latest'
+          - otp-version: '25.2'
+            elixir-version: '1.14.3'
+            os: 'ubuntu-latest'
+            version-type: 'strict'
+          - otp-version: '25'
+            elixir-version: '1'
+            rebar3-version: '3'
+            os: 'ubuntu-22.04'
+          - otp-version: '24'
+            elixir-version: '1'
+            rebar3-version: '3'
+            os: 'ubuntu-22.04'
+          - otp-version: '25.0'
+            elixir-version: 'v1.13.4-otp-25'
+            rebar3-version: '3.18.0'
+            os: 'ubuntu-latest'
+            version-type: 'strict'
+          - otp-version: '25.0'
+            elixir-version: 'v1.13.4'
+            rebar3-version: '3.18.0'
+            os: 'ubuntu-latest'
+            version-type: 'strict'
+          - otp-version: '25'
+            rebar3-version: 'nightly'
+            os: 'ubuntu-latest'
+          - otp-version: '24'
+            rebar3-version: 'nightly'
+            os: 'ubuntu-latest'
+          - elixir-version: 'v1.4'
+            otp-version: '20'
+            rebar3-version: '3.15.0'
+            os: 'ubuntu-20.04'
+          - elixir-version: 'v1.4'
+            otp-version: '20'
+            rebar3-version: '3.11'
+            os: 'ubuntu-20.04'
+          - elixir-version: 'v1.6'
+            otp-version: '21'
+            rebar3-version: '3.12'
+            os: 'ubuntu-20.04'
+          - elixir-version: 'v1.6'
+            otp-version: '21'
+            rebar3-version: '3.12'
+            os: 'ubuntu-20.04'
+          - elixir-version: 'v1.7'
+            otp-version: '22'
+            rebar3-version: '3.13'
+            os: 'ubuntu-20.04'
+          - elixir-version: 'v1.7'
+            otp-version: '22'
+            rebar3-version: '3.13'
+            os: 'ubuntu-20.04'
+          - elixir-version: 'v1.10'
+            otp-version: '23'
+            rebar3-version: '3.14'
+            os: 'ubuntu-20.04'
+          - elixir-version: 'v1.13.4'
+            otp-version: '25.0.2'
+            rebar3-version: '3.19'
+            os: 'ubuntu-20.04'
+          - elixir-version: 'v1.10'
+            otp-version: '23'
+            rebar3-version: '3.14'
+            os: 'ubuntu-20.04'
+          - elixir-version: 'v1.12'
+            otp-version: '24'
+            rebar3-version: '3.15'
+            os: 'ubuntu-20.04'
+          - elixir-version: 'v1.13.4'
+            otp-version: '25.0.2'
+            rebar3-version: '3.19'
+            os: 'ubuntu-20.04'
+          - elixir-version: 'v1.11.0'
+            otp-version: '22.3.4.2'
+            os: 'ubuntu-20.04'
+            version-type: 'strict'
+          - elixir-version: '1.10.3'
+            otp-version: '22.3.4.1'
+            os: 'ubuntu-20.04'
+            version-type: 'strict'
+          - elixir-version: '1.10.3'
+            otp-version: '22.3.4.1'
+            os: 'ubuntu-20.04'
+          - elixir-version: 'master'
+            otp-version: '23.1'
+            os:  'ubuntu-20.04'
+          - elixir-version: 'main'
+            otp-version: '25'
+            os:  'ubuntu-20.04'
+            version-type: 'strict'
+          - gleam-version: '0.23'
+            otp-version: '24'
+            os: 'ubuntu-latest'
+            disable_problem_matchers: true
+          - gleam-version: '0.23.0-rc1'
+            otp-version: '24'
+            os: 'ubuntu-latest'
+            disable_problem_matchers: true
+          - gleam-version: '0.23.0-rc1'
+            otp-version: false
+            os: 'ubuntu-latest'
+            disable_problem_matchers: true
+          - gleam-version: '0.22.0' # Version with Gleam's old archive naming convention
+            otp-version: '24'
+            os: 'ubuntu-latest'
+            disable_problem_matchers: true
+          - elixir-version: 'v1.13'
+            otp-version: '24'
+            escript_packages: 'hex protobuf'
+            escript_script: 'protoc-gen-elixir --version'
+            os: 'ubuntu-latest'
+    steps:
+      - uses: actions/checkout@v3
+      - name: Use erlef/setup-beam
+        id: setup-beam
+        uses: ./
+        with:
+          otp-version: ${{matrix.combo.otp-version}}
+          elixir-version: ${{matrix.combo.elixir-version}}
+          gleam-version: ${{matrix.combo.gleam-version}}
+          rebar3-version: ${{matrix.combo.rebar3-version}}
+          version-type: ${{matrix.combo.version-type}}
+      - name: Erlang/OTP version (action)
+        run: echo "Erlang/OTP ${{steps.setup-beam.outputs.otp-version}}"
+        if: ${{matrix.combo.otp-version}}
+      - name: Elixir version (action)
+        run: echo "Elixir ${{steps.setup-beam.outputs.elixir-version}}"
+        if: ${{matrix.combo.elixir-version}}
+      - name: Gleam version (action)
+        run: echo "Gleam ${{steps.setup-beam.outputs.gleam-version}}"
+        if: ${{matrix.combo.gleam-version}}
+      - name: rebar3 version (action)
+        run: echo "rebar3 ${{steps.setup-beam.outputs.rebar3-version}}"
+        if: ${{matrix.combo.rebar3-version}}
+      - name: mix version and help (CLI)
+        run: |
+          mix -v
+          mix help local.rebar
+          mix help local.hex
+        if: ${{matrix.combo.elixir-version}}
+      - name: Run Elixir/Mix project tests
+        run: |
+          cd test/projects/elixir_mix
+          mix deps.get
+          mix test
+        if: ${{matrix.combo.elixir-version}}
+      - name: Run Erlang/rebar3 project tests
+        run: |
+          cd test/projects/erlang_rebar3
+          rebar3 ct
+        if: ${{matrix.combo.rebar3-version}}
+      - name: Format Gleam project (without installing Erlang/OTP)
+        run: |
+          cd test/projects/gleam_gleam
+          gleam format
+        if: ${{ matrix.combo.gleam-version && !matrix.combo.otp-version }}
+      - name: Run Gleam project tests (without `rebar3`)
+        run: |
+          cd test/projects/gleam_gleam
+          gleam test
+        if: ${{ matrix.combo.gleam-version && matrix.combo.otp-version && !matrix.combo.rebar3-version }}
+      - name: Run escript
+        run: |
+          mix escript.install --force ${{matrix.combo.escript_packages}}
+          ${{matrix.combo.escript_script}}
+        if: ${{matrix.combo.escript_packages && matrix.combo.escript_script}}
+  environment_variables:
+    name: Environment variables
+    runs-on: ${{matrix.combo.os}}
+    strategy:
+      fail-fast: false
+      matrix:
+        combo:
+          - otp-version: '24'
+            elixir-version: 'v1.12'
+            gleam-version: '0.23.0-rc1'
+            rebar3-version: 'nightly'
+            os: 'ubuntu-latest'
+    steps:
+      - uses: actions/checkout@v3
+      - name: Use erlef/setup-beam
+        id: setup-beam
+        uses: ./
+        with:
+          otp-version: ${{matrix.combo.otp-version}}
+          elixir-version: ${{matrix.combo.elixir-version}}
+          gleam-version: ${{matrix.combo.gleam-version}}
+          rebar3-version: ${{matrix.combo.rebar3-version}}
+      - run: env
+      - name: List environment variables
+        run: |
+          [ -n "${INSTALL_DIR_FOR_ELIXIR}" ] && echo "${INSTALL_DIR_FOR_ELIXIR}"
+          [ -n "${INSTALL_DIR_FOR_GLEAM}"  ] && echo "${INSTALL_DIR_FOR_GLEAM}"
+          [ -n "${INSTALL_DIR_FOR_OTP}"    ] && echo "${INSTALL_DIR_FOR_OTP}"
+          [ -n "${INSTALL_DIR_FOR_REBAR3}" ] && echo "${INSTALL_DIR_FOR_REBAR3}"
@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+
+set -eux
+
+git config user.name "GitHub Actions"
+git config user.email "actions@user.noreply.github.com"
+
+BRANCH=feature/3rd-party-licenses-update
+
+if git branch -a | grep "$BRANCH" > /dev/null; then
+    # already exists
+    exit
+fi
+
+git fetch origin
+git checkout -b "$BRANCH"
+npm run licenses
+
+if ! git diff --exit-code 1> /dev/null ; then
+    # there's stuff to push
+    git add 3RD_PARTY_LICENSES
+    git commit -m "Update 3rd party licenses"
+    git push origin "$BRANCH"
+
+    gh pr create --fill \
+        --title "Update 3rd party licenses (automation)" \
+        --body "This is an automated action to update the action's 3rd party licenses"
+fi
@@ -0,0 +1,21 @@
+---
+name: Update 3rd party licenses (automation)
+
+on:
+  schedule:
+    - cron: '0 12 * * *'
+  workflow_dispatch:
+
+jobs:
+  update:
+    name: Update 3rd party licenses
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: '14'
+      - run:
+          ./.github/workflows/update_3rd_party_licenses.sh
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -0,0 +1,136 @@
+---
+name: windows
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    types: [opened, synchronize]
+
+jobs:
+  integration_test:
+    name: >
+      OTP ${{matrix.combo.otp-version}},
+      Elixir ${{matrix.combo.elixir-version}},
+      Gleam ${{matrix.combo.gleam-version}},
+      rebar3 ${{matrix.combo.rebar3-version}}
+    runs-on: ${{matrix.combo.os}}
+    strategy:
+      fail-fast: false
+      matrix:
+        combo:
+          - otp-version: '25'
+            rebar3-version: 'nightly'
+            os: 'windows-latest'
+          - otp-version: '24.0.2'
+            rebar3-version: '3.16'
+            os: 'windows-2019'
+          - otp-version: '24.0.2'
+            rebar3-version: 'nightly'
+            os: 'windows-2019'
+          - otp-version: '23.0'
+            rebar3-version: '3.15'
+            os: 'windows-2019'
+          - elixir-version: 'v1.10'
+            otp-version: '23'
+            rebar3-version: '3.14'
+            os: 'windows-latest'
+          - elixir-version: 'v1.13'
+            otp-version: '24'
+            rebar3-version: '3.15'
+            os: 'windows-latest'
+          - gleam-version: '0.19.0-rc3'
+            otp-version: '24'
+            os: 'windows-latest'
+          - gleam-version: '0.23.0-rc1'
+            otp-version: '24'
+            os: 'windows-latest'
+          - elixir-version: 'v1.13'
+            otp-version: '24'
+            escript_packages: 'hex protobuf'
+            escript_script: 'protoc-gen-elixir --version'
+            os: 'windows-latest'
+    steps:
+      - uses: actions/checkout@v3
+      - name: Use erlef/setup-beam
+        id: setup-beam
+        uses: ./
+        with:
+          otp-version: ${{matrix.combo.otp-version}}
+          elixir-version: ${{matrix.combo.elixir-version}}
+          gleam-version: ${{matrix.combo.gleam-version}}
+          rebar3-version: ${{matrix.combo.rebar3-version}}
+      - name: Erlang/OTP version (action)
+        run: echo "Erlang/OTP ${{steps.setup-beam.outputs.otp-version}}"
+      - name: Elixir version (action)
+        run: echo "Elixir ${{steps.setup-beam.outputs.elixir-version}}"
+        if: ${{matrix.combo.elixir-version}}
+      - name: Gleam version (action)
+        run: echo "Gleam ${{steps.setup-beam.outputs.gleam-version}}"
+        if: ${{matrix.combo.gleam-version}}
+      - name: rebar3 version (action)
+        run: echo "rebar3 ${{steps.setup-beam.outputs.rebar3-version}}"
+      - name: Run rebar3 and rebar3.cmd
+        run: |
+          # Should not fail
+          rebar3 version
+          rebar3.cmd version
+        if: ${{matrix.combo.rebar3-version}}
+      - name: rebar3 from Rust
+        run: |
+          cd test/projects/rust_rebar3_cmd
+          cargo test -- --nocapture
+        if: ${{matrix.combo.rebar3-version}}
+      - name: mix version and help (CLI)
+        run: |
+          mix -v
+          mix help local.rebar
+          mix help local.hex
+        if: ${{matrix.combo.elixir-version}}
+      - name: Run Elixir/Mix project tests
+        run: |
+          cd test/projects/elixir_mix
+          mix deps.get
+          mix test
+        if: ${{matrix.combo.elixir-version}}
+      - name: Run Erlang/rebar3 project tests
+        run: |
+          cd test/projects/erlang_rebar3
+          rebar3 ct
+        if: ${{matrix.combo.rebar3-version}}
+      - name: Run escript
+        run: |
+          mix escript.install --force ${{matrix.combo.escript_packages}}
+          ${{matrix.combo.escript_script}}
+        if: ${{matrix.combo.escript_packages && matrix.combo.escript_script}}
+  environment_variables:
+    name: Environment variables
+    runs-on: ${{matrix.combo.os}}
+    strategy:
+      fail-fast: false
+      matrix:
+        combo:
+          - otp-version: '24'
+            elixir-version: 'v1.12'
+            gleam-version: '0.23.0-rc1'
+            rebar3-version: 'nightly'
+            os: 'windows-latest'
+    steps:
+      - uses: actions/checkout@v3
+      - name: Use erlef/setup-beam
+        id: setup-beam
+        uses: ./
+        with:
+          otp-version: ${{matrix.combo.otp-version}}
+          elixir-version: ${{matrix.combo.elixir-version}}
+          gleam-version: ${{matrix.combo.gleam-version}}
+          rebar3-version: ${{matrix.combo.rebar3-version}}
+      - run: env
+      - name: List environment variables
+        run: |
+          [ -n "${INSTALL_DIR_FOR_ELIXIR}" ] && echo "${INSTALL_DIR_FOR_ELIXIR}"
+          [ -n "${INSTALL_DIR_FOR_GLEAM}"  ] && echo "${INSTALL_DIR_FOR_GLEAM}"
+          [ -n "${INSTALL_DIR_FOR_OTP}"    ] && echo "${INSTALL_DIR_FOR_OTP}"
+          [ -n "${INSTALL_DIR_FOR_REBAR3}" ] && echo "${INSTALL_DIR_FOR_REBAR3}"
+        shell: bash
@@ -1,2 +1,3 @@
 node_modules/**
 dist/.github/workflows
+test/.tool-versions
@@ -25,6 +25,7 @@ Here are a few things you can do that will increase the likelihood of your pull
 - Write tests.
 - Keep your change as focused as possible. If there are multiple changes you would like to make that are not dependent upon each other, consider submitting them as separate pull requests.
 - Write a [good commit message](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html).
+- Execute `npm run build-dist` and fix any issues arising from that

 ## Resources

@@ -1,6 +1,6 @@
 # Elixir Problem Matchers

-Elixir Problem Matchers in [elixir-matchers.json](.github/elixir-matchers.json)
+Elixir Problem Matchers in [elixir-matchers.json](matchers/elixir-matchers.json)
 are adapted from [here](https://github.com/fr1zle/vscode-elixir/blob/45eddb589acd7ac98e0c7305d1c2b24668ca709a/package.json#L70-L118),
 available under the [MIT license](https://github.com/fr1zle/vscode-elixir/blob/45eddb589acd7ac98e0c7305d1c2b24668ca709a/LICENSE.md):

@@ -1,100 +1,134 @@
 <!-- markdownlint-disable MD013 -->
-# setup-beam [![GitHub Actions Test][test-img]][test] [![GitHub Actions CI][ci-img]][ci]
+# setup-beam [![GitHub Actions][action-img]][action] [![GitHub Actions][ubuntu-img]][ubuntu] [![GitHub Actions][windows-img]][windows]

-[test]: https://github.com/erlef/setup-beam
-[test-img]: https://github.com/erlef/setup-beam/workflows/test/badge.svg
-[ci]: https://github.com/erlef/setup-beam
-[ci-img]: https://github.com/erlef/setup-beam/workflows/ci/badge.svg
+[action]: https://github.com/erlef/setup-beam/actions/workflows/action.yml
+[action-img]: https://github.com/erlef/setup-beam/actions/workflows/action.yml/badge.svg
+[ubuntu]: https://github.com/erlef/setup-beam/actions/workflows/ubuntu.yml
+[ubuntu-img]: https://github.com/erlef/setup-beam/actions/workflows/ubuntu.yml/badge.svg
+[windows]: https://github.com/erlef/setup-beam/actions/workflows/windows.yml
+[windows-img]: https://github.com/erlef/setup-beam/actions/workflows/windows.yml/badge.svg

 This action sets up an Erlang/OTP environment for use in a GitHub Actions
 workflow by:

- installing Erlang/OTP
- optionally, installing Elixir
- optionally, installing `rebar3`
+- installing [Erlang/OTP](https://www.erlang.org/)
+- optionally, installing [Elixir](https://elixir-lang.org/)
+- optionally, installing [Gleam](https://gleam.run/)
+- optionally, installing [`rebar3`](https://www.rebar3.org/)
+- optionally, installing [`hex`](https://hex.pm/)
+- optionally, opting for strict or loose version matching
+- optionally, having
+  [problem matchers](https://github.com/actions/toolkit/blob/main/docs/problem-matchers.md) show
+  warnings and errors on pull requests
+- optionally, using a version file (as explained in "Version file", below), to identify versions

-**Note** Currently, this action only supports Actions' `ubuntu-` runtimes.
+**Note**: currently, this action only supports Actions' `ubuntu-` and `windows-` runtimes.

 ## Usage

-See [action.yml](action.yml).
+See [action.yml](action.yml) for the action's specification.

-**Note** The Erlang/OTP release version specification is [relatively
+**Note**: the Erlang/OTP release version specification is [relatively
 complex](http://erlang.org/doc/system_principles/versions.html#version-scheme).
-For best results, we recommend specifying exact Erlang/OTP, Elixir versions, and
-`rebar3` versions.
-However, values like `22.x` are also accepted, and we attempt to resolve them
-according to semantic versioning rules.
+For best results, we recommend specifying exact
+versions, and setting option `version-type` to `strict`.
+However, values like `22.x`, or even `>22`, are also accepted, and we attempt to resolve them
+according to semantic versioning rules. This implicitly means `version-type` is `loose`,
+which is also the default value for this option.

-Additionally, it is recommended that one specifies Erlang/OTP, Elixir and `rebar3` versions
+Additionally, it is recommended that one specifies versions
 using YAML strings, as these examples do, so that numbers like `23.0` don't
 end up being parsed as `23`, which is not equivalent.

-For pre-release Elixir versions, such as `1.11.0-rc.0`, use the full version
-specifier (`1.11.0-rc.0`). Pre-release versions are opt-in, so `1.11.x` will
-not match a pre-release.
+For pre-release versions, such as `v1.11.0-rc.0`, use the full version
+specifier (`v1.11.0-rc.0`) and set option `version-type` to `strict`. Pre-release versions are
+opt-in, so `1.11.x` will not match a pre-release.

-### Compatibility between Ubuntu and Erlang/OTP
+### Compatibility between Operating System and Erlang/OTP

-This list presents the known working version combos between Ubuntu
+This list presents the known working version combos between the target operating system
 and Erlang/OTP.

-| Ubuntu       | Erlang/OTP | Status
-|-             |-           |-
-| ubuntu-16.04 | 17 - 23    | ✅
-| ubuntu-18.04 | 17 - 23    | ✅
-| ubuntu-20.04 | 20 - 23    | ✅
+| Operating system | Erlang/OTP | Status
+|-                 |-           |-
+| ubuntu-18.04     | 17 - 25    | ✅
+| ubuntu-20.04     | 20 - 25    | ✅
+| ubuntu-22.04     | 24.2 - 25  | ✅
+| windows-2019     | 21* - 25   | ✅
+| windows-2022     | 21* - 25   | ✅

-### Basic example (Elixir)
+**Note** *: prior to 23, Windows builds are only available for minor versions, e.g. 21.0, 21.3, 22.0, etc.
+
+### Self-hosted runners
+
+Self-hosted runners need to set env. variable `ImageOS` to one of the following, since the action
+uses that to download assets:
+
+| ImageOS  | Operating system
+|-         |-
+| ubuntu18 | ubuntu-18.04
+| ubuntu20 | ubuntu-20.04
+| ubuntu22 | ubuntu-22.04
+| win19    | windows-2019
+| win22    | windows-2022
+
+as per the following example:

 ```yaml
-on: push
+...

 jobs:
  test:
-    runs-on: ubuntu-latest
+    runs-on: self-hosted
+    env:
+      ImageOS: ubuntu20 # equivalent to runs-on ubuntu-20.04
    steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
      - uses: erlef/setup-beam@v1
-        with:
-          otp-version: '22.2'
-          elixir-version: '1.9.4'
-      - run: mix deps.get
-      - run: mix test
+        ...
 ```

-### Basic example (`rebar3`)
+### Version file
+
+A version file is specified via input `version-file` (e.g.`.tool-versions`). This
+allows not having to use YML input for versions, though the action does check (and
+will exit with error) if both inputs are set.
+
+**Note**: if you're using a version file, option `version-type` is checked to be `strict`,
+and will make the action exit with error otherwise.
+
+The following version file formats are supported:
+
+- `.tool-versions`, as specified by [asdf: Configuration](https://asdf-vm.com/manage/configuration.html)
+
+Supported version elements are the same as the ones defined for the YML portion of the action,
+with the following correspondence.
+
+#### `.tool-versions` format
+
+| YML              | `.tool-versions` |
+|-                 |-
+| `otp-version`    | `erlang`
+| `elixir-version` | `elixir`
+| `gleam-version`  | `gleam`
+| `rebar3-version` | `rebar`
+
+### Example (Erlang/OTP + Elixir, on Ubuntu)

 ```yaml
+# create this in .github/workflows/ci.yml
 on: push

 jobs:
  test:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: erlef/setup-beam@v1
-        with:
-          otp-version: '22.2'
-          rebar3-version: '3.14.2'
-      - run: rebar3 ct
-```
-
-### Matrix example (Elixir)
-
-```yaml
-on: push
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
    name: OTP ${{matrix.otp}} / Elixir ${{matrix.elixir}}
    strategy:
      matrix:
        otp: ['20.3', '21.3', '22.2']
        elixir: ['1.8.2', '1.9.4']
    steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
      - uses: erlef/setup-beam@v1
        with:
          otp-version: ${{matrix.otp}}
@@ -103,21 +137,22 @@ jobs:
      - run: mix test
 ```

-### Matrix example (`rebar3`)
+### Example (Erlang/OTP + `rebar3`, on Ubuntu)

 ```yaml
+# create this in .github/workflows/ci.yml
 on: push

 jobs:
  test:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
    name: Erlang/OTP ${{matrix.otp}} / rebar3 ${{matrix.rebar3}}
    strategy:
      matrix:
        otp: ['20.3', '21.3', '22.2']
        rebar3: ['3.14.1', '3.14.3']
    steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
      - uses: erlef/setup-beam@v1
        with:
          otp-version: ${{matrix.otp}}
@@ -125,69 +160,130 @@ jobs:
      - run: rebar3 ct
 ```

-### Phoenix example
+### Example (Erlang/OTP + `rebar3`, on Windows)

 ```yaml
+# create this in .github/workflows/ci.yml
+on: push
+
+jobs:
+  test:
+    runs-on: windows-2022
+    steps:
+      - uses: actions/checkout@v3
+      - uses: erlef/setup-beam@v1
+        with:
+          otp-version: '24'
+          rebar3-version: '3.16.1'
+      - run: rebar3 ct
+```
+
+### Example (Gleam on Ubuntu)
+
+```yaml
+# create this in .github/workflows/ci.yml
 on: push

 jobs:
  test:
    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: erlef/setup-beam@v1
+        with:
+          otp-version: '24'
+          gleam-version: '0.23.0-rc1'
+      - run: gleam test
+```

-    services:
-      db:
-        image: postgres:11
-        ports: ['5432:5432']
-        env:
-          POSTGRES_PASSWORD: postgres
-        options: >-
-          --health-cmd pg_isready
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
+### Example (Gleam on Ubuntu without OTP)

+```yaml
+# create this in .github/workflows/ci.yml
+on: push
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: erlef/setup-beam@v1
+        with:
+          otp-version: false
+          gleam-version: '0.23.0-rc1'
+      - run: gleam check
+```
+
+**Note**: the `otp-version: false` input is only applicable when installing Gleam.
+
+## Alternative hex.pm mirrors
+
+It is possible to use alternative hex.pm mirror(s), in their declared order, with
+option `hexpm-mirrors`. By default, the action will use `builds.hex.pm`.
+To use other alternative mirrors, add one per line, as shown below.
+
+```yaml
+# create this in .github/workflows/ci.yml
+on: push
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - uses: erlef/setup-beam@v1
        with:
-          otp-version: '22.2'
-          elixir-version: '1.9.4'
-      - run: mix deps.get
-      - run: mix test
+          otp-version: '25'
+          # Use `cdn.jsdelivr.net/hex` as an alternative to `builds.hex.pm`
+          hexpm-mirrors: https://cdn.jsdelivr.net/hex
 ```

-#### Authenticating with Postgres in Phoenix
+Alternatively, you may try `cdn.jsdelivr.net/hex` if `builds.hex.pm` fails:

-When using the Phoenix example above, the `postgres` container has some
-default authentication set up. Specifically, it expects a username of
-"postgres", and a password of "postgres". It will be available at
-`localhost:5432`.
+```yaml
+# create this in .github/workflows/ci.yml
+on: push

-The simplest way of setting these auth values in CI is by checking for the
-`GITHUB_ACTIONS` environment variable that is set in all workflows:
-
-```elixir
-# config/test.exs
-
-use Mix.Config
-
-# Configure the database for local testing
-config :app, App.Repo,
-  database: "my_app_test",
-  hostname: "localhost",
-  pool: Ecto.Adapters.SQL.Sandbox
-
-# Configure the database for GitHub Actions
-if System.get_env("GITHUB_ACTIONS") do
-  config :app, App.Repo,
-    username: "postgres",
-    password: "postgres"
-end
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: erlef/setup-beam@v1
+        with:
+          otp-version: '25'
+          hexpm-mirrors: |
+            https://builds.hex.pm
+            https://cdn.jsdelivr.net/hex
 ```

+## Environment variables
+
+Base installation folders (useful for e.g. fetching headers for NIFs) are available in the following
+environment variables:
+
+- `INSTALL_DIR_FOR_OTP`: base folder for Erlang/OTP
+- `INSTALL_DIR_FOR_ELIXIR`: base folder for Elixir
+- `INSTALL_DIR_FOR_GLEAM`: base folder for Gleam
+- `INSTALL_DIR_FOR_REBAR3`: base folder for `rebar3`
+
 ## Elixir Problem Matchers

-The Elixir Problem Matchers in this repository are adapted from [here](https://github.com/fr1zle/vscode-elixir/blob/45eddb589acd7ac98e0c7305d1c2b24668ca709a/package.json#L70-L118). See [MATCHER_NOTICE](MATCHER_NOTICE.md) for license details.
+The Elixir Problem Matchers in this repository are adapted from
+[here](https://github.com/fr1zle/vscode-elixir/blob/45eddb589acd7ac98e0c7305d1c2b24668ca709a/package.json#L70-L118).
+See [MATCHER_NOTICE](MATCHER_NOTICE.md) for license details.
+
+## Action versioning
+
+`setup-beam` has three version paths, described below, for example version `1.8.0`:
+
+- `@v1`: the latest in the `1.y.z` series (this tag is movable),
+- `@v1.8`: the latest in the `1.8.z` series (this tag is movable),
+- `@v1.8.0`: release `1.8.0` (this tag is not movable).
+
+We make a real effort to not introduce incompatibilities without changing the major
+version number. To be extra safe against changes causing issues in your CI you should specify
+an exact version with `@vx.y.z`.

 ## License

@@ -1,182 +0,0 @@
-simulateInput('otp-version', '23.2')
-simulateInput('elixir-version', '1.11')
-simulateInput('rebar3-version', '3.14')
-simulateInput('install-rebar', 'true')
-simulateInput('install-hex', 'true')
-
-const assert = require('assert')
-const setupElixir = require('../src/setup-beam')
-const installer = require('../src/installer')
-
-async function all() {
-  await testFailInstallOTP()
-  await testFailInstallElixir()
-  await testFailInstallRebar3()
-
-  await testOTPVersions()
-  await testElixirVersions()
-  await testRebar3Versions()
-}
-
-async function testFailInstallOTP() {
-  const otpOSVersion = 'ubuntu-08.04'
-  const otpVersion = 'OTP-23.2'
-  assert.rejects(
-    async () => {
-      await installer.installOTP(otpOSVersion, otpVersion)
-    },
-    (err) => {
-      assert.ok(err instanceof Error)
-      return true
-    },
-    `Installing Erlang/OTP ${otpVersion} over ${otpOSVersion} is supposed to fail`,
-  )
-}
-
-async function testFailInstallElixir() {
-  let exVersion
-
-  exVersion = '0.11'
-  assert.rejects(
-    async () => {
-      await installer.installElixir(exVersion)
-    },
-    (err) => {
-      assert.ok(err instanceof Error)
-      return true
-    },
-    `Installing Elixir ${exVersion} is supposed to fail`,
-  )
-
-  exVersion = 'v1.0.0-otp-17'
-  assert.rejects(
-    async () => {
-      await installer.installElixir(exVersion)
-    },
-    (err) => {
-      assert.ok(err instanceof Error)
-      return true
-    },
-    `Installing Elixir ${exVersion} is supposed to fail`,
-  )
-}
-
-async function testFailInstallRebar3() {
-  const r3Version = '0.14.4'
-  assert.rejects(
-    async () => {
-      await installer.installRebar3(r3Version)
-    },
-    (err) => {
-      assert.ok(err instanceof Error)
-      return true
-    },
-    `Installing rebar3 ${r3Version} is supposed to fail`,
-  )
-}
-
-async function testOTPVersions() {
-  let got
-  let expected
-  let spec
-  let osVersion
-
-  spec = '19.3.x'
-  osVersion = 'ubuntu-16.04'
-  expected = 'OTP-19.3.6'
-  got = await setupElixir.getOTPVersion(spec, osVersion)
-  assert.deepStrictEqual(got, expected)
-
-  spec = '^19.3.6'
-  osVersion = 'ubuntu-16.04'
-  expected = 'OTP-19.3.6'
-  got = await setupElixir.getOTPVersion(spec, osVersion)
-  assert.deepStrictEqual(got, expected)
-
-  spec = '^19.3'
-  osVersion = 'ubuntu-18.04'
-  expected = 'OTP-19.3.6'
-  got = await setupElixir.getOTPVersion(spec, osVersion)
-  assert.deepStrictEqual(got, expected)
-
-  spec = '20'
-  osVersion = 'ubuntu-20.04'
-  expected = 'OTP-20.3.8'
-  got = await setupElixir.getOTPVersion(spec, osVersion)
-  assert.deepStrictEqual(got, expected)
-
-  spec = '20.x'
-  osVersion = 'ubuntu-20.04'
-  expected = 'OTP-20.3.8'
-  got = await setupElixir.getOTPVersion(spec, osVersion)
-  assert.deepStrictEqual(got, expected)
-
-  spec = '20.0'
-  osVersion = 'ubuntu-20.04'
-  expected = 'OTP-20.0.5'
-  got = await setupElixir.getOTPVersion(spec, osVersion)
-  assert.deepStrictEqual(got, expected)
-
-  spec = '20.0.x'
-  osVersion = 'ubuntu-20.04'
-  expected = 'OTP-20.0.5'
-  got = await setupElixir.getOTPVersion(spec, osVersion)
-  assert.deepStrictEqual(got, expected)
-}
-
-async function testElixirVersions() {
-  let got
-  let expected
-  let spec
-  let otpVersion
-
-  spec = '1.1.x'
-  otpVersion = 'OTP-23'
-  expected = 'v1.1.1'
-  got = await setupElixir.getElixirVersion(spec, otpVersion)
-  assert.deepStrictEqual(got, expected)
-
-  spec = '1.10.4'
-  otpVersion = 'OTP-23'
-  expected = 'v1.10.4-otp-23'
-  got = await setupElixir.getElixirVersion(spec, otpVersion)
-  assert.deepStrictEqual(got, expected)
-
-  spec = '1.11.0-rc.0'
-  otpVersion = 'OTP-23'
-  expected = 'v1.11.0-rc.0-otp-23'
-  got = await setupElixir.getElixirVersion(spec, otpVersion)
-  assert.deepStrictEqual(got, expected)
-}
-
-async function testRebar3Versions() {
-  let got
-  let expected
-  let spec
-
-  spec = '3.13.x'
-  expected = '3.13.2'
-  got = await setupElixir.getRebar3Version(spec)
-  assert.deepStrictEqual(got, expected)
-
-  spec = '3.13.2'
-  expected = '3.13.2'
-  got = await setupElixir.getRebar3Version(spec)
-  assert.deepStrictEqual(got, expected)
-
-  spec = '3.13'
-  expected = '3.13.2'
-  got = await setupElixir.getRebar3Version(spec)
-  assert.deepStrictEqual(got, expected)
-}
-
-function simulateInput(key, value) {
-  process.env[`INPUT_${key.replace(/ /g, '_').toUpperCase()}`] = value
-}
-
-all()
-  .then(() => process.exit(0))
-  .catch((err) => {
-    console.error(err)
-    process.exit(1)
-  })
@@ -1,5 +1,5 @@
 ---
-name: Setup Erlang/OTP with optional Elixir and/or rebar3
+name: Setup Erlang/OTP with optional Elixir (and mix) and/or rebar3
 description: >
  Set up a specific version of Erlang/OTP, Elixir, and/or rebar3
  and add the command-line tools to the PATH
@@ -8,25 +8,56 @@ branding:
  color: blue
  icon: code
 inputs:
+  github-token:
+    description: >
+      A GitHub token used to access the GitHub REST API for retrieving release and version information.
+      While this action will never perform anything more than read operations against the GitHub REST API,
+      we do not recommend providing a self-generated personal access token which may provide more access than is
+      required of this action. This input instead is merely a convenience so that users of this action do not
+      have to manually pass an automatically generated token via their environment settings within a workflow.
+      [Learn more about automatically generated tokens](https://docs.github.com/en/actions/security-guides/automatic-token-authentication)
+    default: ${{ github.token }}
+  otp-version:
+    description: Version range or exact version of Erlang/OTP to use,
+      or false when installing only Gleam without OTP
  elixir-version:
    description: Version range or exact version of Elixir to use
-  otp-version:
-    description: Version range or exact version of Erlang/OTP to use
+  gleam-version:
+    description: Version range or exact version of Gleam to use
  install-hex:
-    description: Whether to install Hex
+    description: Whether to install Hex (with mix local.hex
+      when installing Elixir)
    default: true
  install-rebar:
-    description: Whether to install Rebar
+    description: Whether to install Rebar (with mix local.rebar
+      when installing Elixir)
    default: true
  rebar3-version:
-    description: Version range or exact version of rebar3 to use
+    description: Version range or exact version of rebar3 to use (or nightly)
+  version-type:
+    description: strict means the versions are take as-are; loose means we try
+      to guess versions based on semver rules
+    default: loose
+  disable_problem_matchers:
+    description: whether to have the problem matchers present in the results
+      (or not)
+    default: false
+  version-file:
+    description: a versions file (e.g. as used by `asdf`), which defines inputs
+    default: ''
+  hexpm-mirrors:
+    description: mirror(s) for hex.pm, one per line
+    default: |
+        https://builds.hex.pm
 outputs:
  elixir-version:
    description: Exact version of Elixir that was installed
  otp-version:
    description: Exact version of Erlang/OTP that was installed
+  gleam-version:
+    description: Exact version of Gleam that was installed
  rebar3-version:
    description: Exact version of rebar3 that was installed
 runs:
-  using: node12
+  using: node16
  main: dist/index.js
@@ -41,6 +41,22 @@
          "line": 2
        }
      ]
+    },
+    {
+      "owner": "elixir-credoOutputDefault",
+      "severity": "warning",
+      "pattern": [
+        {
+          "regexp": "^\u2503\\s\\[\\w\\]\\s[\u2191|\u2197|\u2192|\u2198|\u2193]\\s(.*)$",
+          "message": 1
+        },
+        {
+          "regexp": "^\u2503\\s{7}(.*):(\\d+):(\\d+)\\s.*$",
+          "file": 1,
+          "line": 2,
+          "column": 3
+        }
+      ]
    }
  ]
 }
@@ -41,6 +41,22 @@
          "line": 2
        }
      ]
+    },
+    {
+      "owner": "elixir-credoOutputDefault",
+      "severity": "warning",
+      "pattern": [
+        {
+          "regexp": "^\u2503\\s\\[\\w\\]\\s[\u2191|\u2197|\u2192|\u2198|\u2193]\\s(.*)$",
+          "message": 1
+        },
+        {
+          "regexp": "^\u2503\\s{7}(.*):(\\d+):(\\d+)\\s.*$",
+          "file": 1,
+          "line": 2,
+          "column": 3
+        }
+      ]
    }
  ]
 }
@@ -1,20 +0,0 @@
-#!/bin/bash
-
-set -eo pipefail
-
-cd "$RUNNER_TEMP"
-
-VSN=${1}
-FILE_INPUT="${VSN}.zip"
-FILE_OUTPUT=elixir.zip
-DIR_FOR_BIN=.setup-beam/elixir
-
-rm -f "${FILE_OUTPUT}"
-rm -rf "${DIR_FOR_BIN}"
-wget -q -O "${FILE_OUTPUT}" "https://repo.hex.pm/builds/elixir/${FILE_INPUT}"
-mkdir -p "${DIR_FOR_BIN}"
-unzip -q -d "${DIR_FOR_BIN}" "${FILE_OUTPUT}"
-rm -f "${FILE_OUTPUT}"
-echo "$(pwd)/${DIR_FOR_BIN}/bin" >> "$GITHUB_PATH"
-echo "Installed Elixir version follows"
-${DIR_FOR_BIN}/bin/iex -v
@@ -0,0 +1,37 @@
+param([Parameter(Mandatory=$true)][string]${VSN})
+
+$ErrorActionPreference="Stop"
+
+Set-Location ${Env:RUNNER_TEMP}
+
+$FILE_OUTPUT="gleam.zip"
+$DIR_FOR_BIN=".setup-beam/gleam"
+
+function Version-Greater-Than([string]${THIS_ONE}, [string]${REFERENCE}) {
+  $THIS_ONE=$THIS_ONE.replace('v', '')
+  $THIS_ONE=$THIS_ONE.replace('rc', '')
+  $THIS_ONE=$THIS_ONE.replace('-', '')
+  return [version]${THIS_ONE} -gt [version]${REFERENCE}
+}
+
+function Uses-LLVM-Triplets([string]${THIS_VSN}) {
+  return "${THIS_VSN}" -eq "nightly" -or (Version-Greater-Than "${THIS_VSN}" "0.22.1")
+}
+
+if (Uses-LLVM-Triplets "$VSN") {
+   $FILE_INPUT="gleam-${VSN}-x86_64-pc-windows-msvc.zip"
+} else {
+   $FILE_INPUT="gleam-${VSN}-windows-64bit.zip"
+}
+
+$ProgressPreference="SilentlyContinue"
+Invoke-WebRequest "https://github.com/gleam-lang/gleam/releases/download/${VSN}/${FILE_INPUT}" -OutFile "${FILE_OUTPUT}"
+$ProgressPreference="Continue"
+New-Item "${DIR_FOR_BIN}/bin" -ItemType Directory | Out-Null
+$ProgressPreference="SilentlyContinue"
+Expand-Archive -DestinationPath "${DIR_FOR_BIN}/bin" -Path "${FILE_OUTPUT}"
+$ProgressPreference="Continue"
+Write-Output "Installed Gleam version follows"
+& "${DIR_FOR_BIN}/bin/gleam" "--version" | Write-Output
+
+"INSTALL_DIR_FOR_GLEAM=${Env:RUNNER_TEMP}/${DIR_FOR_BIN}" | Out-File -FilePath ${Env:GITHUB_ENV} -Encoding utf8 -Append
@@ -0,0 +1,35 @@
+#!/bin/bash
+
+set -eo pipefail
+
+cd "${RUNNER_TEMP}"
+
+VSN="$1"
+FILE_OUTPUT=gleam.tar.gz
+DIR_FOR_BIN=.setup-beam/gleam
+
+version_gt() {
+  REFERENCE=$1
+  test "$(printf '%s\n' "$@" | sort -V | head -n 1)" != "$REFERENCE"
+}
+
+uses_llvm_triplets() {
+  local VERSION="$1"
+  test "${VERSION}" = "nightly" || version_gt "${VERSION}" "v0.22.1"
+}
+
+if uses_llvm_triplets "$VSN"
+then
+  FILE_INPUT="gleam-${VSN}-x86_64-unknown-linux-musl.tar.gz"
+else
+  FILE_INPUT="gleam-${VSN}-linux-amd64.tar.gz"
+fi
+
+wget -q -O "${FILE_OUTPUT}" "https://github.com/gleam-lang/gleam/releases/download/${VSN}/${FILE_INPUT}"
+mkdir -p "${DIR_FOR_BIN}/bin"
+tar zxf "${FILE_OUTPUT}" -C "${DIR_FOR_BIN}/bin"
+
+echo "Installed Gleam version follows"
+${DIR_FOR_BIN}/bin/gleam --version
+
+echo "INSTALL_DIR_FOR_GLEAM=${RUNNER_TEMP}/${DIR_FOR_BIN}" >> "${GITHUB_ENV}"
@@ -1,22 +0,0 @@
-#!/bin/bash
-
-set -eo pipefail
-
-cd "$RUNNER_TEMP"
-
-OS=${1}
-VSN=${2}
-FILE_INPUT="${VSN}.tar.gz"
-FILE_OUTPUT=otp.tar.gz
-DIR_FOR_BIN=.setup-beam/otp
-
-rm -f "${FILE_OUTPUT}"
-rm -rf "${DIR_FOR_BIN}"
-wget -q -O "${FILE_OUTPUT}" "https://repo.hex.pm/builds/otp/${OS}/${FILE_INPUT}"
-mkdir -p "${DIR_FOR_BIN}"
-tar zxf "${FILE_OUTPUT}" -C "${DIR_FOR_BIN}" --strip-components=1
-rm -f "${FILE_OUTPUT}"
-"${DIR_FOR_BIN}/Install" -minimal "$(pwd)/${DIR_FOR_BIN}"
-echo "$(pwd)/${DIR_FOR_BIN}/bin" >> "$GITHUB_PATH"
-echo "Installed Erlang/OTP version follows"
-${DIR_FOR_BIN}/bin/erl -version
@@ -1,20 +0,0 @@
-#!/bin/bash
-
-set -eo pipefail
-
-cd "$RUNNER_TEMP"
-
-VSN=${1}
-FILE_INPUT=rebar3
-FILE_OUTPUT=rebar3
-DIR_FOR_BIN=.setup-beam/rebar3
-
-rm -f "${FILE_OUTPUT}"
-rm -rf "${DIR_FOR_BIN}"
-wget -q -O "${FILE_OUTPUT}" "https://github.com/erlang/rebar3/releases/download/${VSN}/${FILE_INPUT}"
-mkdir -p "${DIR_FOR_BIN}/bin"
-chmod +x "${FILE_OUTPUT}"
-mv "${FILE_OUTPUT}" "${DIR_FOR_BIN}/bin"
-echo "$(pwd)/${DIR_FOR_BIN}/bin" >> "$GITHUB_PATH"
-echo "Installed rebar3 version follows"
-${DIR_FOR_BIN}/bin/rebar3 version
@@ -0,0 +1,32 @@
+param([Parameter(Mandatory=$true)][string]${VSN})
+
+$ErrorActionPreference="Stop"
+
+Set-Location ${Env:RUNNER_TEMP}
+
+$FILE_INPUT="rebar3"
+$FILE_OUTPUT="rebar3"
+$FILE_OUTPUT_PS1="rebar3.ps1"
+$FILE_OUTPUT_CMD="rebar3.cmd"
+$DIR_FOR_BIN=".setup-beam/rebar3"
+
+$ProgressPreference="SilentlyContinue"
+$REBAR3_TARGET="https://github.com/erlang/rebar3/releases/download/${VSN}/${FILE_INPUT}"
+$REBAR3_NIGHTLY=""
+If ( ${VSN} -eq "nightly" )
+{
+    $REBAR3_TARGET="https://s3.amazonaws.com/rebar3-nightly/rebar3"
+    $REBAR3_NIGHTLY=" (from nightly build)"
+}
+Invoke-WebRequest "${REBAR3_TARGET}" -OutFile "${FILE_OUTPUT}"
+$ProgressPreference="Continue"
+New-Item "${DIR_FOR_BIN}/bin" -ItemType Directory | Out-Null
+Move-Item "${FILE_OUTPUT}" "${DIR_FOR_BIN}/bin"
+Write-Output "& escript.exe ${PWD}/${DIR_FOR_BIN}/bin/${FILE_OUTPUT} `${args}" | Out-File -FilePath "${FILE_OUTPUT_PS1}" -Encoding utf8 -Append
+Write-Output "@echo off`r`nescript.exe ${PWD}/${DIR_FOR_BIN}/bin/${FILE_OUTPUT} %*" | Out-File -FilePath "${FILE_OUTPUT_CMD}" -Encoding utf8 -Append
+Move-Item "${FILE_OUTPUT_PS1}" "${DIR_FOR_BIN}/bin"
+Move-Item "${FILE_OUTPUT_CMD}" "${DIR_FOR_BIN}/bin"
+Write-Output "Installed rebar3 version${REBAR3_NIGHTLY} follows"
+& "${DIR_FOR_BIN}/bin/rebar3.cmd" "version" | Write-Output
+
+"INSTALL_DIR_FOR_REBAR3=${Env:RUNNER_TEMP}/${DIR_FOR_BIN}" | Out-File -FilePath ${Env:GITHUB_ENV} -Encoding utf8 -Append
@@ -0,0 +1,25 @@
+#!/bin/bash
+
+set -eo pipefail
+
+cd "${RUNNER_TEMP}"
+
+VSN=${1}
+FILE_INPUT=rebar3
+FILE_OUTPUT=rebar3
+DIR_FOR_BIN=.setup-beam/rebar3
+
+REBAR3_TARGET="https://github.com/erlang/rebar3/releases/download/${VSN}/${FILE_INPUT}"
+REBAR3_NIGHTLY=""
+if [ "${VSN}" == "nightly" ]; then
+    REBAR3_TARGET="https://s3.amazonaws.com/rebar3-nightly/rebar3"
+    REBAR3_NIGHTLY=" (from nightly build)"
+fi
+wget -q -O "${FILE_OUTPUT}" "${REBAR3_TARGET}"
+mkdir -p "${DIR_FOR_BIN}/bin"
+chmod +x "${FILE_OUTPUT}"
+mv "${FILE_OUTPUT}" "${DIR_FOR_BIN}/bin"
+echo "Installed rebar3 version${REBAR3_NIGHTLY} follows"
+${DIR_FOR_BIN}/bin/rebar3 version
+
+echo "INSTALL_DIR_FOR_REBAR3=${RUNNER_TEMP}/${DIR_FOR_BIN}" >> "${GITHUB_ENV}"
@@ -1,82 +0,0 @@
-@actions/core
-MIT
-The MIT License (MIT)
-
-Copyright 2019 GitHub
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-@actions/exec
-MIT
-
-@actions/io
-MIT
-The MIT License (MIT)
-
-Copyright 2019 GitHub
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-lru-cache
-ISC
-The ISC License
-
-Copyright (c) Isaac Z. Schlueter and Contributors
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted, provided that the above
-copyright notice and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
-IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-
-semver
-ISC
-The ISC License
-
-Copyright (c) Isaac Z. Schlueter and Contributors
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted, provided that the above
-copyright notice and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
-IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-
-yallist
-ISC
-The ISC License
-
-Copyright (c) Isaac Z. Schlueter and Contributors
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted, provided that the above
-copyright notice and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
-IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
@@ -0,0 +1,62 @@
+{
+  "problemMatcher": [
+    {
+      "owner": "elixir-mixCompileError",
+      "severity": "error",
+      "pattern": [
+        {
+          "regexp": "^\\*\\* \\((\\w+)\\) (.*):(\\d+): (.*)$",
+          "file": 2,
+          "line": 3,
+          "message": 0
+        }
+      ]
+    },
+    {
+      "owner": "elixir-mixCompileWarning",
+      "severity": "warning",
+      "pattern": [
+        {
+          "regexp": "^warning: (.*)$",
+          "message": 1
+        },
+        {
+          "regexp": "^  (.*):(\\d+).*$",
+          "file": 1,
+          "line": 2
+        }
+      ]
+    },
+    {
+      "owner": "elixir-mixTestFailure",
+      "severity": "error",
+      "pattern": [
+        {
+          "regexp": "^\\s*\\d+\\) (.*)$",
+          "message": 1
+        },
+        {
+          "regexp": "^\\s*(.*):(\\d+)$",
+          "file": 1,
+          "line": 2
+        }
+      ]
+    },
+    {
+      "owner": "elixir-credoOutputDefault",
+      "severity": "warning",
+      "pattern": [
+        {
+          "regexp": "^\u2503\\s\\[\\w\\]\\s[\u2191|\u2197|\u2192|\u2198|\u2193]\\s(.*)$",
+          "message": 1
+        },
+        {
+          "regexp": "^\u2503\\s{7}(.*):(\\d+):(\\d+)\\s.*$",
+          "file": 1,
+          "line": 2,
+          "column": 3
+        }
+      ]
+    }
+  ]
+}
@@ -1,17 +1,17 @@
 {
  "name": "setup-beam",
-  "version": "1.7.1",
  "license": "MIT",
  "private": true,
  "scripts": {
-    "build": "ncc build src/setup-beam.js --no-cache --license licenses.txt",
-    "format": "prettier src/**/*.js --write && prettier __tests__/**/*.js --write",
-    "jslint": "eslint src/**/*.js && eslint __tests__/**/*.js",
+    "build": "ncc build src/setup-beam.js --no-cache",
+    "format": "prettier src/**/*.js --write && prettier test/**/*.js --write",
+    "jslint": "eslint src/**/*.js && eslint test/**/*.js",
    "licenses": "yarn licenses generate-disclaimer > 3RD_PARTY_LICENSES",
    "markdownlint": "markdownlint *.md",
-    "shellcheck": "shellcheck src/install-*",
-    "test": "node __tests__/setup-beam.test.js",
-    "yamllint": "yamllint .github/workflows/**.yml && yamllint .*.yml && yamllint *.yml"
+    "shellcheck": "shellcheck src/install-*.sh .github/workflows/*.sh",
+    "test": "node test/setup-beam.test.js && node ./test/problem-matchers.test.js",
+    "yamllint": "yamllint .github/workflows/**.yml && yamllint .*.yml && yamllint *.yml",
+    "build-dist": "npm install && npm run build && npm run format && npm run markdownlint && npm run shellcheck && npm run yamllint && npm run jslint"
  },
  "husky": {
    "hooks": {
@@ -19,22 +19,27 @@
    }
  },
  "dependencies": {
-    "@actions/core": "1.2.6",
-    "@actions/exec": "1.0.4",
-    "semver": "7.3.4"
+    "@actions/core": "1.10.0",
+    "@actions/exec": "1.1.1",
+    "@actions/http-client": "2.1.0",
+    "@actions/tool-cache": "^2.0.1",
+    "semver": "7.3.8"
  },
  "devDependencies": {
-    "@vercel/ncc": "0.27.0",
-    "eslint": "7.22.0",
-    "eslint-config-airbnb": "v18.2.1",
-    "husky": "5.2.0",
-    "markdownlint": "0.23.1",
-    "prettier": "2.2.1",
-    "shellcheck": "1.0.0",
-    "yaml-lint": "1.2.4",
-    "yarn": "1.22.10"
+    "@vercel/ncc": "0.34.0",
+    "eslint": "8.25.0",
+    "eslint-config-airbnb": "19.0.4",
+    "eslint-plugin-import": "2.26.0",
+    "eslint-plugin-jsx-a11y": "6.6.1",
+    "eslint-plugin-react": "7.31.10",
+    "husky": "8.0.1",
+    "markdownlint": "0.26.2",
+    "prettier": "2.7.1",
+    "shellcheck": "1.1.0",
+    "yaml-lint": "1.7.0",
+    "yarn": "1.22.19"
  },
  "engines": {
-    "node": ">=12"
+    "node": ">=16"
  }
 }
@@ -1,20 +0,0 @@
-#!/bin/bash
-
-set -eo pipefail
-
-cd "$RUNNER_TEMP"
-
-VSN=${1}
-FILE_INPUT="${VSN}.zip"
-FILE_OUTPUT=elixir.zip
-DIR_FOR_BIN=.setup-beam/elixir
-
-rm -f "${FILE_OUTPUT}"
-rm -rf "${DIR_FOR_BIN}"
-wget -q -O "${FILE_OUTPUT}" "https://repo.hex.pm/builds/elixir/${FILE_INPUT}"
-mkdir -p "${DIR_FOR_BIN}"
-unzip -q -d "${DIR_FOR_BIN}" "${FILE_OUTPUT}"
-rm -f "${FILE_OUTPUT}"
-echo "$(pwd)/${DIR_FOR_BIN}/bin" >> "$GITHUB_PATH"
-echo "Installed Elixir version follows"
-${DIR_FOR_BIN}/bin/iex -v
@@ -0,0 +1,37 @@
+param([Parameter(Mandatory=$true)][string]${VSN})
+
+$ErrorActionPreference="Stop"
+
+Set-Location ${Env:RUNNER_TEMP}
+
+$FILE_OUTPUT="gleam.zip"
+$DIR_FOR_BIN=".setup-beam/gleam"
+
+function Version-Greater-Than([string]${THIS_ONE}, [string]${REFERENCE}) {
+  $THIS_ONE=$THIS_ONE.replace('v', '')
+  $THIS_ONE=$THIS_ONE.replace('rc', '')
+  $THIS_ONE=$THIS_ONE.replace('-', '')
+  return [version]${THIS_ONE} -gt [version]${REFERENCE}
+}
+
+function Uses-LLVM-Triplets([string]${THIS_VSN}) {
+  return "${THIS_VSN}" -eq "nightly" -or (Version-Greater-Than "${THIS_VSN}" "0.22.1")
+}
+
+if (Uses-LLVM-Triplets "$VSN") {
+   $FILE_INPUT="gleam-${VSN}-x86_64-pc-windows-msvc.zip"
+} else {
+   $FILE_INPUT="gleam-${VSN}-windows-64bit.zip"
+}
+
+$ProgressPreference="SilentlyContinue"
+Invoke-WebRequest "https://github.com/gleam-lang/gleam/releases/download/${VSN}/${FILE_INPUT}" -OutFile "${FILE_OUTPUT}"
+$ProgressPreference="Continue"
+New-Item "${DIR_FOR_BIN}/bin" -ItemType Directory | Out-Null
+$ProgressPreference="SilentlyContinue"
+Expand-Archive -DestinationPath "${DIR_FOR_BIN}/bin" -Path "${FILE_OUTPUT}"
+$ProgressPreference="Continue"
+Write-Output "Installed Gleam version follows"
+& "${DIR_FOR_BIN}/bin/gleam" "--version" | Write-Output
+
+"INSTALL_DIR_FOR_GLEAM=${Env:RUNNER_TEMP}/${DIR_FOR_BIN}" | Out-File -FilePath ${Env:GITHUB_ENV} -Encoding utf8 -Append
@@ -0,0 +1,35 @@
+#!/bin/bash
+
+set -eo pipefail
+
+cd "${RUNNER_TEMP}"
+
+VSN="$1"
+FILE_OUTPUT=gleam.tar.gz
+DIR_FOR_BIN=.setup-beam/gleam
+
+version_gt() {
+  REFERENCE=$1
+  test "$(printf '%s\n' "$@" | sort -V | head -n 1)" != "$REFERENCE"
+}
+
+uses_llvm_triplets() {
+  local VERSION="$1"
+  test "${VERSION}" = "nightly" || version_gt "${VERSION}" "v0.22.1"
+}
+
+if uses_llvm_triplets "$VSN"
+then
+  FILE_INPUT="gleam-${VSN}-x86_64-unknown-linux-musl.tar.gz"
+else
+  FILE_INPUT="gleam-${VSN}-linux-amd64.tar.gz"
+fi
+
+wget -q -O "${FILE_OUTPUT}" "https://github.com/gleam-lang/gleam/releases/download/${VSN}/${FILE_INPUT}"
+mkdir -p "${DIR_FOR_BIN}/bin"
+tar zxf "${FILE_OUTPUT}" -C "${DIR_FOR_BIN}/bin"
+
+echo "Installed Gleam version follows"
+${DIR_FOR_BIN}/bin/gleam --version
+
+echo "INSTALL_DIR_FOR_GLEAM=${RUNNER_TEMP}/${DIR_FOR_BIN}" >> "${GITHUB_ENV}"
@@ -1,22 +0,0 @@
-#!/bin/bash
-
-set -eo pipefail
-
-cd "$RUNNER_TEMP"
-
-OS=${1}
-VSN=${2}
-FILE_INPUT="${VSN}.tar.gz"
-FILE_OUTPUT=otp.tar.gz
-DIR_FOR_BIN=.setup-beam/otp
-
-rm -f "${FILE_OUTPUT}"
-rm -rf "${DIR_FOR_BIN}"
-wget -q -O "${FILE_OUTPUT}" "https://repo.hex.pm/builds/otp/${OS}/${FILE_INPUT}"
-mkdir -p "${DIR_FOR_BIN}"
-tar zxf "${FILE_OUTPUT}" -C "${DIR_FOR_BIN}" --strip-components=1
-rm -f "${FILE_OUTPUT}"
-"${DIR_FOR_BIN}/Install" -minimal "$(pwd)/${DIR_FOR_BIN}"
-echo "$(pwd)/${DIR_FOR_BIN}/bin" >> "$GITHUB_PATH"
-echo "Installed Erlang/OTP version follows"
-${DIR_FOR_BIN}/bin/erl -version
@@ -1,20 +0,0 @@
-#!/bin/bash
-
-set -eo pipefail
-
-cd "$RUNNER_TEMP"
-
-VSN=${1}
-FILE_INPUT=rebar3
-FILE_OUTPUT=rebar3
-DIR_FOR_BIN=.setup-beam/rebar3
-
-rm -f "${FILE_OUTPUT}"
-rm -rf "${DIR_FOR_BIN}"
-wget -q -O "${FILE_OUTPUT}" "https://github.com/erlang/rebar3/releases/download/${VSN}/${FILE_INPUT}"
-mkdir -p "${DIR_FOR_BIN}/bin"
-chmod +x "${FILE_OUTPUT}"
-mv "${FILE_OUTPUT}" "${DIR_FOR_BIN}/bin"
-echo "$(pwd)/${DIR_FOR_BIN}/bin" >> "$GITHUB_PATH"
-echo "Installed rebar3 version follows"
-${DIR_FOR_BIN}/bin/rebar3 version
@@ -0,0 +1,32 @@
+param([Parameter(Mandatory=$true)][string]${VSN})
+
+$ErrorActionPreference="Stop"
+
+Set-Location ${Env:RUNNER_TEMP}
+
+$FILE_INPUT="rebar3"
+$FILE_OUTPUT="rebar3"
+$FILE_OUTPUT_PS1="rebar3.ps1"
+$FILE_OUTPUT_CMD="rebar3.cmd"
+$DIR_FOR_BIN=".setup-beam/rebar3"
+
+$ProgressPreference="SilentlyContinue"
+$REBAR3_TARGET="https://github.com/erlang/rebar3/releases/download/${VSN}/${FILE_INPUT}"
+$REBAR3_NIGHTLY=""
+If ( ${VSN} -eq "nightly" )
+{
+    $REBAR3_TARGET="https://s3.amazonaws.com/rebar3-nightly/rebar3"
+    $REBAR3_NIGHTLY=" (from nightly build)"
+}
+Invoke-WebRequest "${REBAR3_TARGET}" -OutFile "${FILE_OUTPUT}"
+$ProgressPreference="Continue"
+New-Item "${DIR_FOR_BIN}/bin" -ItemType Directory | Out-Null
+Move-Item "${FILE_OUTPUT}" "${DIR_FOR_BIN}/bin"
+Write-Output "& escript.exe ${PWD}/${DIR_FOR_BIN}/bin/${FILE_OUTPUT} `${args}" | Out-File -FilePath "${FILE_OUTPUT_PS1}" -Encoding utf8 -Append
+Write-Output "@echo off`r`nescript.exe ${PWD}/${DIR_FOR_BIN}/bin/${FILE_OUTPUT} %*" | Out-File -FilePath "${FILE_OUTPUT_CMD}" -Encoding utf8 -Append
+Move-Item "${FILE_OUTPUT_PS1}" "${DIR_FOR_BIN}/bin"
+Move-Item "${FILE_OUTPUT_CMD}" "${DIR_FOR_BIN}/bin"
+Write-Output "Installed rebar3 version${REBAR3_NIGHTLY} follows"
+& "${DIR_FOR_BIN}/bin/rebar3.cmd" "version" | Write-Output
+
+"INSTALL_DIR_FOR_REBAR3=${Env:RUNNER_TEMP}/${DIR_FOR_BIN}" | Out-File -FilePath ${Env:GITHUB_ENV} -Encoding utf8 -Append
@@ -0,0 +1,25 @@
+#!/bin/bash
+
+set -eo pipefail
+
+cd "${RUNNER_TEMP}"
+
+VSN=${1}
+FILE_INPUT=rebar3
+FILE_OUTPUT=rebar3
+DIR_FOR_BIN=.setup-beam/rebar3
+
+REBAR3_TARGET="https://github.com/erlang/rebar3/releases/download/${VSN}/${FILE_INPUT}"
+REBAR3_NIGHTLY=""
+if [ "${VSN}" == "nightly" ]; then
+    REBAR3_TARGET="https://s3.amazonaws.com/rebar3-nightly/rebar3"
+    REBAR3_NIGHTLY=" (from nightly build)"
+fi
+wget -q -O "${FILE_OUTPUT}" "${REBAR3_TARGET}"
+mkdir -p "${DIR_FOR_BIN}/bin"
+chmod +x "${FILE_OUTPUT}"
+mv "${FILE_OUTPUT}" "${DIR_FOR_BIN}/bin"
+echo "Installed rebar3 version${REBAR3_NIGHTLY} follows"
+${DIR_FOR_BIN}/bin/rebar3 version
+
+echo "INSTALL_DIR_FOR_REBAR3=${RUNNER_TEMP}/${DIR_FOR_BIN}" >> "${GITHUB_ENV}"
@@ -1,23 +1,135 @@
+const core = require('@actions/core')
 const { exec } = require('@actions/exec')
+const tc = require('@actions/tool-cache')
 const path = require('path')
+const fs = require('fs')
+const os = require('os')

 /**
 * Install Erlang/OTP.
 *
 * @param {string} osVersion
 * @param {string} otpVersion
+ * @param {string[]} hexMirrors
 */
-async function installOTP(osVersion, otpVersion) {
-  await exec(path.join(__dirname, 'install-otp'), [osVersion, otpVersion])
+async function installOTP(osVersion, otpVersion, hexMirrors) {
+  if (hexMirrors.length === 0) {
+    throw new Error(
+      `Could not install Erlang/OTP ${otpVersion} from any hex.pm mirror`,
+    )
+  }
+
+  const [hexMirror, ...hexMirrorsT] = hexMirrors
+  const fullVersion = `${osVersion}/${otpVersion}`
+  let cachedPath = tc.find('otp', fullVersion)
+  const OS = process.platform
+
+  try {
+    if (OS === 'linux') {
+      if (!cachedPath) {
+        const tarPath = await tc.downloadTool(
+          `https://builds.hex.pm/builds/otp/${fullVersion}.tar.gz`,
+        )
+        const extractPath = await tc.extractTar(tarPath, undefined, [
+          'zx',
+          '--strip-components=1',
+        ])
+        cachedPath = await tc.cacheDir(extractPath, 'otp', fullVersion)
+      }
+
+      await exec(path.join(cachedPath, 'Install'), ['-minimal', cachedPath])
+
+      const otpPath = path.join(cachedPath, 'bin')
+
+      core.addPath(otpPath)
+      core.exportVariable('INSTALL_DIR_FOR_OTP', cachedPath)
+
+      core.info('Installed Erlang/OTP version')
+      await exec(path.join(otpPath, 'erl'), ['-version'])
+    } else if (OS === 'win32') {
+      if (!cachedPath) {
+        const exePath = await tc.downloadTool(
+          'https://github.com/erlang/otp/releases/download/' +
+            `OTP-${otpVersion}/otp_win64_${otpVersion}.exe`,
+        )
+        cachedPath = await tc.cacheFile(exePath, 'otp.exe', 'otp', fullVersion)
+      }
+
+      const otpDir = path.join(process.env.RUNNER_TEMP, '.setup-beam', 'otp')
+      const otpPath = path.join(otpDir, 'bin')
+
+      await fs.promises.mkdir(otpDir, { recursive: true })
+      await exec(path.join(cachedPath, 'otp.exe'), ['/S', `/D=${otpDir}`])
+
+      core.addPath(otpPath)
+      core.exportVariable('INSTALL_DIR_FOR_OTP', otpDir)
+
+      core.info('Installed Erlang/OTP version')
+      await exec(path.join(otpPath, 'erl'), ['+V'])
+    }
+  } catch (err) {
+    core.info(`Install OTP failed for mirror ${hexMirror}`)
+    core.info(`${err}\n${err.stack}`)
+    await installOTP(osVersion, otpVersion, hexMirrorsT)
+  }
 }

 /**
 * Install Elixir.
 *
 * @param {string} elixirVersion
+ * @param {string[]} hexMirrors
 */
-async function installElixir(elixirVersion) {
-  await exec(path.join(__dirname, 'install-elixir'), [elixirVersion])
+async function installElixir(elixirVersion, hexMirrors) {
+  if (hexMirrors.length === 0) {
+    throw new Error(
+      `Could not install Elixir ${elixirVersion} from any hex.pm mirror`,
+    )
+  }
+  const [hexMirror, ...hexMirrorsT] = hexMirrors
+
+  try {
+    let cachedPath = tc.find('elixir', elixirVersion)
+
+    if (!cachedPath) {
+      const zipPath = await tc.downloadTool(
+        `${hexMirror}/builds/elixir/${elixirVersion}.zip`,
+      )
+      const extractPath = await tc.extractZip(zipPath)
+      cachedPath = await tc.cacheDir(extractPath, 'elixir', elixirVersion)
+    }
+
+    const elixirPath = path.join(cachedPath, 'bin')
+    const escriptsPath = path.join(os.homedir(), '.mix', 'escripts')
+
+    core.addPath(elixirPath)
+    core.addPath(escriptsPath)
+    core.exportVariable('INSTALL_DIR_FOR_ELIXIR', cachedPath)
+
+    core.info('Installed Elixir version')
+    await exec(path.join(elixirPath, 'elixir'), ['-v'])
+
+    await fs.promises.mkdir(escriptsPath, { recursive: true })
+  } catch (err) {
+    core.info(`Elixir install failed for mirror ${hexMirror}`)
+    core.info(`${err}\n${err.stack}`)
+    await installElixir(elixirVersion, hexMirrorsT)
+  }
+}
+
+/**
+ * Install Gleam.
+ *
+ * @param {string} gleamVersion
+ */
+async function installGleam(gleamVersion) {
+  const OS = process.platform
+  if (OS === 'linux') {
+    await exec(path.join(__dirname, 'install-gleam.sh'), [gleamVersion])
+  } else if (OS === 'win32') {
+    const script = path.join(__dirname, 'install-gleam.ps1')
+    await exec(`pwsh.exe ${script} -VSN:${gleamVersion}`)
+  }
 }

 /**
@@ -26,18 +138,27 @@ async function installElixir(elixirVersion) {
 * @param {string} rebar3Version
 */
 async function installRebar3(rebar3Version) {
-  await exec(path.join(__dirname, 'install-rebar3'), [rebar3Version])
+  const OS = process.platform
+  if (OS === 'linux') {
+    await exec(path.join(__dirname, 'install-rebar3.sh'), [rebar3Version])
+  } else if (OS === 'win32') {
+    const script = path.join(__dirname, 'install-rebar3.ps1')
+    await exec(`pwsh.exe ${script} -VSN:${rebar3Version}`)
+  }
 }

 function checkPlatform() {
-  if (process.platform !== 'linux') {
-    throw new Error('@erlef/setup-beam only supports Ubuntu Linux at this time')
+  if (process.platform !== 'linux' && process.platform !== 'win32') {
+    throw new Error(
+      '@erlef/setup-beam only supports Ubuntu and Windows at this time',
+    )
  }
 }

 module.exports = {
  installOTP,
  installElixir,
+  installGleam,
  installRebar3,
  checkPlatform,
 }
@@ -1,8 +1,9 @@
 const core = require('@actions/core')
 const { exec } = require('@actions/exec')
+const http = require('@actions/http-client')
 const path = require('path')
 const semver = require('semver')
-const https = require('https')
+const fs = require('fs')
 const installer = require('./installer')

 main().catch((err) => {
@@ -12,152 +13,223 @@ main().catch((err) => {
 async function main() {
  installer.checkPlatform()

-  const osVersion = getRunnerOSVersion()
-  const otpSpec = core.getInput('otp-version', { required: true })
-  const otpVersion = await installOTP(otpSpec, osVersion)
-
-  const elixirSpec = core.getInput('elixir-version', { required: false })
-  const elixirInstalled = await maybeInstallElixir(elixirSpec, otpVersion)
-  if (elixirInstalled === true) {
-    const shouldMixRebar = core.getInput('install-rebar', {
-      required: false,
-    })
-    await mix(shouldMixRebar, 'rebar')
-    const shouldMixHex = core.getInput('install-hex', {
-      required: false,
-    })
-    await mix(shouldMixHex, 'hex')
+  const versionFilePath = getInput('version-file', false)
+  let versions
+  if (versionFilePath) {
+    if (!isStrictVersion()) {
+      throw new Error(
+        "you have to set version-type=strict if you're using version-file",
+      )
+    }
+    versions = parseVersionFile(versionFilePath)
  }

-  const rebar3Spec = core.getInput('rebar3-version', { required: false })
-  maybeInstallRebar3(rebar3Spec)
+  const osVersion = getRunnerOSVersion()
+  const otpSpec = getInput('otp-version', true, 'erlang', versions)
+  const elixirSpec = getInput('elixir-version', false, 'elixir', versions)
+  const gleamSpec = getInput('gleam-version', false, 'gleam', versions)
+  const rebar3Spec = getInput('rebar3-version', false, 'rebar', versions)
+  const hexMirrors = core.getMultilineInput('hexpm-mirrors', {
+    required: false,
+  })
+
+  if (otpSpec !== 'false') {
+    await installOTP(otpSpec, osVersion, hexMirrors)
+    const elixirInstalled = await maybeInstallElixir(
+      elixirSpec,
+      otpSpec,
+      hexMirrors,
+    )
+
+    if (elixirInstalled === true) {
+      const shouldMixRebar = getInput('install-rebar', false)
+      await mix(shouldMixRebar, 'rebar', hexMirrors)
+      const shouldMixHex = getInput('install-hex', false)
+      await mix(shouldMixHex, 'hex', hexMirrors)
+    }
+  } else if (!gleamSpec) {
+    throw new Error('otp-version=false is only available when installing Gleam')
+  }
+
+  await maybeInstallGleam(gleamSpec)
+  await maybeInstallRebar3(rebar3Spec)
 }

-async function installOTP(otpSpec, osVersion) {
-  const otpVersion = await getOTPVersion(otpSpec, osVersion)
-  console.log(
-    `##[group]Installing Erlang/OTP ${otpVersion} - built on ${osVersion}`,
-  )
-  await installer.installOTP(osVersion, otpVersion)
+async function installOTP(otpSpec, osVersion, hexMirrors) {
+  const otpVersion = await getOTPVersion(otpSpec, osVersion, hexMirrors)
+  core.startGroup(`Installing Erlang/OTP ${otpVersion} - built on ${osVersion}`)
+  await installer.installOTP(osVersion, otpVersion, hexMirrors)
  core.setOutput('otp-version', otpVersion)
-  prependToPath(`${process.env.RUNNER_TEMP}/.setup-beam/otp/bin`)
-  console.log('##[endgroup]')
+  core.endGroup()

  return otpVersion
 }

-async function maybeInstallElixir(elixirSpec, otpVersion) {
-  if (elixirSpec) {
-    const elixirVersion = await getElixirVersion(elixirSpec, otpVersion)
-    console.log(`##[group]Installing Elixir ${elixirVersion}`)
-    await installer.installElixir(elixirVersion)
-    core.setOutput('elixir-version', elixirVersion)
-    const matchersPath = path.join(__dirname, '..', '.github')
-    console.log(
-      `##[add-matcher]${path.join(matchersPath, 'elixir-matchers.json')}`,
-    )
-    prependToPath(`${process.env.RUNNER_TEMP}/.setup-beam/elixir/bin`)
-    console.log('##[endgroup]')
+async function maybeInstallElixir(elixirSpec, otpSpec, hexMirrors) {
+  let installed = false

-    return true
+  if (elixirSpec) {
+    const elixirVersion = await getElixirVersion(
+      elixirSpec,
+      otpSpec,
+      hexMirrors,
+    )
+    core.startGroup(`Installing Elixir ${elixirVersion}`)
+    await installer.installElixir(elixirVersion, hexMirrors)
+    core.setOutput('elixir-version', elixirVersion)
+    const disableProblemMatchers = getInput('disable_problem_matchers', false)
+    if (disableProblemMatchers === 'false') {
+      const elixirMatchers = path.join(
+        __dirname,
+        '..',
+        'matchers',
+        'elixir-matchers.json',
+      )
+      core.info(`##[add-matcher]${elixirMatchers}`)
+    }
+    core.endGroup()
+
+    installed = true
  }

-  return false
+  return installed
 }

-async function mix(shouldMix, what) {
-  if (shouldMix) {
+async function mixWithMirrors(cmd, args, hexMirrors) {
+  if (hexMirrors.length === 0) {
+    throw new Error('mix failed with every mirror')
+  }
+  const [hexMirror, ...hexMirrorsT] = hexMirrors
+  process.env.HEX_MIRROR = hexMirror
+  try {
+    return await exec(cmd, args)
+  } catch (err) {
+    core.info(
+      `mix failed with mirror ${process.env.HEX_MIRROR} with message ${err.message})`,
+    )
+  }
+  return mixWithMirrors(cmd, args, hexMirrorsT)
+}
+
+async function mix(shouldMix, what, hexMirrors) {
+  if (shouldMix === 'true') {
    const cmd = 'mix'
    const args = [`local.${what}`, '--force']
-    console.log(`##[group]Running ${cmd} ${args}`)
-    await exec(cmd, args)
-    console.log('##[endgroup]')
+    core.startGroup(`Running ${cmd} ${args}`)
+    await mixWithMirrors(cmd, args, hexMirrors)
+    core.endGroup()
  }
 }

+async function maybeInstallGleam(gleamSpec) {
+  let installed = false
+
+  if (gleamSpec) {
+    const gleamVersion = await getGleamVersion(gleamSpec)
+    core.startGroup(`Installing Gleam ${gleamVersion}`)
+    await installer.installGleam(gleamVersion)
+    core.setOutput('gleam-version', gleamVersion)
+    core.addPath(`${process.env.RUNNER_TEMP}/.setup-beam/gleam/bin`)
+    core.endGroup()
+
+    installed = true
+  }
+
+  return installed
+}
+
 async function maybeInstallRebar3(rebar3Spec) {
+  let installed = false
+  let rebar3Version
+
  if (rebar3Spec) {
-    const rebar3Version = await getRebar3Version(rebar3Spec)
-    console.log(`##[group]Installing rebar3 ${rebar3Version}`)
+    if (rebar3Spec === 'nightly') {
+      rebar3Version = 'nightly'
+    } else {
+      rebar3Version = await getRebar3Version(rebar3Spec)
+    }
+    core.startGroup(`Installing rebar3 ${rebar3Version}`)
    await installer.installRebar3(rebar3Version)
    core.setOutput('rebar3-version', rebar3Version)
-    prependToPath(`${process.env.RUNNER_TEMP}/.setup-beam/rebar3/bin`)
-    console.log('##[endgroup]')
+    core.addPath(`${process.env.RUNNER_TEMP}/.setup-beam/rebar3/bin`)
+    core.endGroup()

-    return true
+    installed = true
  }

-  return false
+  return installed
 }

-async function getOTPVersion(otpSpec0, osVersion) {
-  const otpVersions = await getOTPVersions(osVersion)
-  const otpSpec = otpSpec0.match(/^(OTP-)?([^ ]+)/)
-  let otpVersion
-  if (otpSpec[1]) {
-    throw new Error(
-      `Requested Erlang/OTP version (from spec ${otpSpec0}) ` +
-        "should not contain 'OTP-'",
-    )
-  }
-  if (otpSpec) {
-    otpVersion = getVersionFromSpec(
-      otpSpec[2],
-      Array.from(otpVersions.keys()).sort(),
-    )
+async function getOTPVersion(otpSpec0, osVersion, hexMirrors) {
+  const otpVersions = await getOTPVersions(osVersion, hexMirrors)
+  let otpSpec = otpSpec0 // might be a branch (?)
+  const otpVersion = getVersionFromSpec(
+    otpSpec,
+    Array.from(otpVersions.keys()).sort(),
+  )
+  if (isVersion(otpSpec0)) {
+    otpSpec = `OTP-${otpSpec0}` // ... it's a version!
  }
  if (otpVersion === null) {
    throw new Error(
-      `Requested Erlang/OTP version (from spec ${otpSpec0}) not found in build listing`,
+      `Requested Erlang/OTP version (${otpSpec0}) not found in version list ` +
+        "(should you be using option 'version-type': 'strict'?)",
    )
  }

  return otpVersions.get(otpVersion) // from the reference, for download
 }

-async function getElixirVersion(exSpec0, otpVersion) {
-  const elixirVersions = await getElixirVersions()
+async function getElixirVersion(exSpec0, otpVersion0, hexMirrors) {
+  const otpVersion = otpVersion0.match(/^([^-]+-)?(.+)$/)[2]
+  const otpVersionMajor = otpVersion.match(/^([^.]+).*$/)[1]
+  const elixirVersions = await getElixirVersions(hexMirrors)
  const semverVersions = Array.from(elixirVersions.keys()).sort()
-
-  const exSpec = exSpec0.match(/^(.+)(-otp-.+)/) || exSpec0.match(/^(.+)/)
-  let elixirVersion
-  if (exSpec[2]) {
+  const exSpec = exSpec0.replace(/-otp-.*$/, '')
+  const elixirVersionFromSpec = getVersionFromSpec(exSpec, semverVersions, true)
+  let elixirVersionForDownload = elixirVersionFromSpec
+  if (isVersion(otpVersionMajor)) {
+    elixirVersionForDownload = `${elixirVersionFromSpec}-otp-${otpVersionMajor}`
+  }
+  if (elixirVersionFromSpec === null) {
    throw new Error(
-      `Requested Elixir / Erlang/OTP version (from spec ${exSpec0} / ${otpVersion}) ` +
-        "should not contain '-otp-...'",
+      `Requested Elixir version (${exSpec0}) not found in version list ` +
+        "(should you be using option 'version-type': 'strict'?)",
    )
  }
-  if (exSpec) {
-    elixirVersion = getVersionFromSpec(exSpec[1], semverVersions)
-  }
-  if (!exSpec || elixirVersion === null) {
-    throw new Error(
-      `Requested Elixir version (from spec ${exSpec0}) not found in build listing`,
-    )
-  }
-  const otpMatch = otpVersion.match(/^(?:OTP-)?([^.]+)/)
-  let elixirVersionWithOTP

-  if (elixirVersions.get(elixirVersion)) {
-    const otpVersionMajor = otpMatch[1]
-    // We try for a version like `v1.4.5-otp-20`...
-    if (elixirVersions.get(elixirVersion).includes(otpMatch[1])) {
-      // ... and it's available: use it!
-      elixirVersionWithOTP = `${elixirVersion}-otp-${otpVersionMajor}`
-      core.info(`Using Elixir / -otp- version ${elixirVersionWithOTP}`)
-    } else {
-      // ... and it's not available: fallback to the "generic" version (v1.4.5 only).
-      elixirVersionWithOTP = elixirVersion
-      core.info(`Using Elixir ${elixirVersionWithOTP}`)
-    }
+  const elixirVersionComp = elixirVersions.get(elixirVersionFromSpec)
+  if (
+    (elixirVersionComp && elixirVersionComp.includes(otpVersionMajor)) ||
+    !isVersion(otpVersionMajor)
+  ) {
+    core.info(
+      `Using Elixir ${elixirVersionFromSpec} (built for Erlang/OTP ${otpVersionMajor})`,
+    )
  } else {
    throw new Error(
-      `Requested Elixir / Erlang/OTP version (from spec ${exSpec0} / ${otpVersion}) not ` +
-        'found in build listing',
+      `Requested Elixir / Erlang/OTP version (${exSpec0} / ${otpVersion0}) not ` +
+        'found in version list (did you check Compatibility between Elixir and Erlang/OTP?).' +
+        'Elixir and Erlang/OTP compatibility can be found at: ' +
+        'https://hexdocs.pm/elixir/compatibility-and-deprecations.html',
    )
  }

-  return elixirVersionWithOTP
+  return maybePrependWithV(elixirVersionForDownload)
+}
+
+async function getGleamVersion(gleamSpec0) {
+  const gleamSpec = gleamSpec0.match(/^v?(.+)$/)
+  const gleamVersions = await getGleamVersions()
+  const gleamVersion = getVersionFromSpec(gleamSpec[1], gleamVersions, true)
+  if (gleamVersion === null) {
+    throw new Error(
+      `Requested Gleam version (${gleamSpec0}) not found in version list ` +
+        "(should you be using option 'version-type': 'strict'?)",
+    )
+  }
+
+  return maybePrependWithV(gleamVersion, gleamVersion)
 }

 async function getRebar3Version(r3Spec) {
@@ -165,48 +237,70 @@ async function getRebar3Version(r3Spec) {
  const rebar3Version = getVersionFromSpec(r3Spec, rebar3Versions)
  if (rebar3Version === null) {
    throw new Error(
-      `Requested rebar3 version (from spec ${r3Spec}) not found in build listing`,
+      `Requested rebar3 version (${r3Spec}) not found in version list ` +
+        "(should you be using option 'version-type': 'strict'?)",
    )
  }

  return rebar3Version
 }

-async function getOTPVersions(osVersion) {
-  const otpVersionsListing = await get(
-    `https://repo.hex.pm/builds/otp/${osVersion}/builds.txt`,
-  )
+async function getOTPVersions(osVersion, hexMirrors) {
+  let otpVersionsListings
+  let originListing
+  if (process.platform === 'linux') {
+    originListing = `/builds/otp/${osVersion}/builds.txt`
+    otpVersionsListings = await getWithMirrors(originListing, hexMirrors)
+  } else if (process.platform === 'win32') {
+    originListing =
+      'https://api.github.com/repos/erlang/otp/releases?per_page=100'
+    otpVersionsListings = await get(originListing, [1, 2, 3])
+  }
+  debugLog(`OTP versions listings from ${originListing}`, otpVersionsListings)
+
  const otpVersions = new Map()

-  otpVersionsListing
-    .trim()
-    .split('\n')
-    .forEach((line) => {
-      const otpMatch = line.match(/^(OTP-)?([^ ]+)/)
-
-      let otpVersion = otpMatch[2]
-      if (semver.validRange(otpVersion)) {
-        otpVersion = semver.minVersion(otpVersion).version
-      }
-      otpVersions.set(otpVersion, otpMatch[0]) // we keep the original for later reference
+  if (process.platform === 'linux') {
+    otpVersionsListings
+      .trim()
+      .split('\n')
+      .forEach((line) => {
+        const otpMatch = line
+          .match(/^([^ ]+)?( .+)/)[1]
+          .match(/^([^-]+-)?(.+)$/)
+        const otpVersion = otpMatch[2]
+        otpVersions.set(otpVersion, otpMatch[0]) // we keep the original for later reference
+      })
+  } else if (process.platform === 'win32') {
+    otpVersionsListings.forEach((otpVersionsListing) => {
+      jsonParseAsList(otpVersionsListing)
+        .map((x) => x.assets)
+        .flat()
+        .filter((x) => x.name.match(/^otp_win64_.*.exe$/))
+        .forEach((x) => {
+          const otpMatch = x.name.match(/^otp_win64_(.*).exe$/)
+          const otpVersion = otpMatch[1]
+          otpVersions.set(otpVersion, otpVersion)
+        })
    })
-
+  }
  return otpVersions
 }

-async function getElixirVersions() {
-  const elixirVersionsListing = await get(
-    'https://repo.hex.pm/builds/elixir/builds.txt',
+async function getElixirVersions(hexMirrors) {
+  const elixirVersionsListings = await getWithMirrors(
+    '/builds/elixir/builds.txt',
+    hexMirrors,
  )
  const otpVersionsForElixirMap = new Map()

-  elixirVersionsListing
+  elixirVersionsListings
    .trim()
    .split('\n')
    .forEach((line) => {
      const elixirMatch =
-        line.match(/^(.+)-otp-([^ ]+)/) || line.match(/^([^ ]+)/)
-      const elixirVersion = elixirMatch[1]
+        line.match(/^v?(.+)-otp-([^ ]+)/) || line.match(/^v?([^ ]+)/)
+      const elixirVersion = maybePrependWithV(elixirMatch[1])
      const otpVersion = elixirMatch[2]
      const otpVersions = otpVersionsForElixirMap.get(elixirVersion) || []
      if (otpVersion) {
@@ -219,65 +313,278 @@ async function getElixirVersions() {
  return otpVersionsForElixirMap
 }

-async function getRebar3Versions() {
-  const resultJSON = await get(
-    'https://api.github.com/repos/erlang/rebar3/releases',
+async function getGleamVersions() {
+  const resultJSONs = await get(
+    'https://api.github.com/repos/gleam-lang/gleam/releases?per_page=100',
+    [1, 2, 3],
  )
-  const rebar3VersionsListing = JSON.parse(resultJSON)
-    .map((x) => x.tag_name)
-    .sort()
+  const gleamVersionsListing = []
+  resultJSONs.forEach((resultJSON) => {
+    jsonParseAsList(resultJSON)
+      .map((x) => x.tag_name)
+      .sort()
+      .forEach((v) => gleamVersionsListing.push(v))
+  })
+  return gleamVersionsListing
+}

+async function getRebar3Versions() {
+  const resultJSONs = await get(
+    'https://api.github.com/repos/erlang/rebar3/releases?per_page=100',
+    [1, 2, 3],
+  )
+  const rebar3VersionsListing = []
+  resultJSONs.forEach((resultJSON) => {
+    jsonParseAsList(resultJSON)
+      .map((x) => x.tag_name)
+      .sort()
+      .forEach((v) => rebar3VersionsListing.push(v))
+  })
  return rebar3VersionsListing
 }

-function getVersionFromSpec(spec, versions) {
-  if (versions.includes(spec)) {
-    return spec
+function isStrictVersion() {
+  return getInput('version-type', false) === 'strict'
+}
+
+function getVersionFromSpec(spec, versions, maybePrependWithV0) {
+  let version = null
+
+  if (spec.match(/rc/) || isStrictVersion()) {
+    version = spec
  }

-  return semver.maxSatisfying(versions, semver.validRange(spec))
+  if (version === null) {
+    // We keep a map of semver => "spec" in order to use semver ranges to find appropriate versions
+    const versionsMap = versions.sort(sortVersions).reduce((acc, v) => {
+      if (!v.match(/rc/)) {
+        // release candidates are opt-in
+        acc[maybeCoerced(v)] = v
+      }
+      return acc
+    }, {})
+    const rangeForMax = semver.validRange(spec)
+    if (rangeForMax) {
+      version =
+        versionsMap[semver.maxSatisfying(Object.keys(versionsMap), rangeForMax)]
+    } else {
+      version = versionsMap[maybeCoerced(spec)]
+    }
+  }
+
+  let v = version === null || version === undefined ? null : version
+  if (maybePrependWithV0 && v != null) {
+    v = maybePrependWithV(v)
+  }
+
+  if (!versions.includes(v)) {
+    v = null
+  }
+
+  return v
+}
+
+function maybeCoerced(v) {
+  let ret
+
+  try {
+    ret = semver.coerce(v).version
+  } catch {
+    // some stuff can't be coerced, like 'master'
+    ret = v
+  }
+
+  return ret
+}
+
+function sortVersions(left, right) {
+  let ret = 0
+  const newL = verAsComparableStr(left)
+  const newR = verAsComparableStr(right)
+
+  function verAsComparableStr(ver) {
+    const matchGroups = 5
+    const verSpec = /([^.]+)?\.?([^.]+)?\.?([^.]+)?\.?([^.]+)?\.?([^.]+)?/
+    const matches = ver.match(verSpec).splice(1, matchGroups)
+    return matches.reduce((acc, v) => acc + (v || '0').padStart(3, '0'), '')
+  }
+
+  if (newL < newR) {
+    ret = -1
+  } else if (newL > newR) {
+    ret = 1
+  }
+
+  return ret
 }

 function getRunnerOSVersion() {
-  const mapToUbuntuVersion = {
-    ubuntu16: 'ubuntu-16.04',
+  const ImageOSToContainer = {
    ubuntu18: 'ubuntu-18.04',
    ubuntu20: 'ubuntu-20.04',
+    ubuntu22: 'ubuntu-22.04',
+    win19: 'windows-2019',
+    win22: 'windows-2022',
+  }
+  const containerFromEnvImageOS = ImageOSToContainer[process.env.ImageOS]
+
+  if (!containerFromEnvImageOS) {
+    throw new Error(
+      "Tried to map a target OS from env. variable 'ImageOS' (got " +
+        `${process.env.ImageOS}` +
+        "), but failed. If you're using a " +
+        "self-hosted runner, you should set 'env': 'ImageOS': ... to one of the following: " +
+        "['" +
+        `${Object.keys(ImageOSToContainer).join("', '")}` +
+        "']",
+    )
  }

-  return mapToUbuntuVersion[process.env.ImageOS] || 'ubuntu-18.04'
+  return containerFromEnvImageOS
 }

-function get(url) {
-  return new Promise((resolve, reject) => {
-    https
-      .get(
-        url,
-        {
-          headers: { 'user-agent': 'setup-beam' },
-        },
-        (res) => {
-          let data = ''
-          res.on('data', (chunk) => {
-            data += chunk
-          })
-          res.on('end', () => {
-            resolve(data)
-          })
-        },
+async function get(url0, pageIdxs) {
+  async function getPage(pageIdx) {
+    const url = new URL(url0)
+    const headers = {}
+    const GithubToken = getInput('github-token', false)
+
+    if (GithubToken && url.host === 'api.github.com') {
+      headers.authorization = `Bearer ${GithubToken}`
+    }
+
+    if (pageIdx !== null) {
+      url.searchParams.append('page', pageIdx)
+    }
+
+    const httpClient = new http.HttpClient('setup-beam', [], {
+      allowRetries: true,
+      maxRetries: 3,
+    })
+
+    const response = await httpClient.get(url, headers)
+
+    if (response.statusCode >= 400 && response.statusCode <= 599) {
+      throw new Error(
+        `Got ${response.statusCode} from ${url}. Exiting with error`,
      )
-      .on('error', (err) => {
-        reject(err)
-      })
-  })
+    }
+
+    return response.readBody()
+  }
+
+  if (pageIdxs[0] === null) {
+    return getPage(null)
+  }
+  return Promise.all(pageIdxs.map(getPage))
 }

-function prependToPath(what) {
-  process.env.PATH = `${what}:${process.env.PATH}`
+async function getWithMirrors(resourcePath, hexMirrors) {
+  if (hexMirrors.length === 0) {
+    throw new Error(`Could not fetch ${resourcePath} from any hex.pm mirror`)
+  }
+  const [hexMirror, ...hexMirrorsT] = hexMirrors
+  try {
+    return await get(`${hexMirror}${resourcePath}`, [null])
+  } catch (err) {
+    core.info(`get failed for URL ${hexMirror}${resourcePath}`)
+  }
+  return getWithMirrors(resourcePath, hexMirrorsT)
+}
+
+function maybePrependWithV(v) {
+  if (isVersion(v)) {
+    return `v${v.replace('v', '')}`
+  }
+  return v
+}
+
+function isVersion(v) {
+  return /^v?\d+/.test(v)
+}
+
+function getInput(inputName, required, alternativeName, alternatives) {
+  const alternativeValue = (alternatives || new Map()).get(alternativeName)
+  let input = core.getInput(inputName, {
+    required: alternativeValue ? false : required,
+  })
+  // We can't have both input and alternativeValue set
+  if (input && alternativeValue) {
+    throw new Error(
+      `Found input ${inputName}=${input} (from the YML) \
+alongside ${alternativeName}=${alternativeValue} \
+(from the version file). You must choose one or the other.`,
+    )
+  } else if (!input) {
+    input = alternativeValue
+  }
+  return input
+}
+
+function parseVersionFile(versionFilePath0) {
+  const versionFilePath = path.join(
+    process.env.GITHUB_WORKSPACE,
+    versionFilePath0,
+  )
+  if (!fs.existsSync(versionFilePath)) {
+    throw new Error(
+      `The specified version file, ${versionFilePath0}, does not exist`,
+    )
+  }
+  core.startGroup(`Parsing version file at ${versionFilePath0}`)
+  const appVersions = new Map()
+  const versions = fs.readFileSync(versionFilePath, 'utf8')
+  // For the time being we parse .tool-versions
+  // If we ever start parsing something else, this should
+  // become default in a new option named e.g. version-file-type
+  versions.split('\n').forEach((line) => {
+    const appVersion = line.match(/^([^ ]+)[ ]+([^ #]+)/)
+    if (appVersion) {
+      const app = appVersion[1]
+      if (['erlang', 'elixir', 'gleam', 'rebar'].includes(app)) {
+        const [, , version] = appVersion
+        core.info(`Consuming ${app} at version ${version}`)
+        appVersions.set(app, version)
+      }
+    }
+  })
+  if (!appVersions.size) {
+    core.info('There was apparently nothing to consume')
+  } else {
+    core.info('... done!')
+  }
+  core.endGroup()
+
+  return appVersions
+}
+
+function jsonParseAsList(maybeJson) {
+  try {
+    const obj = JSON.parse(maybeJson)
+    if (!Array.isArray(obj)) {
+      throw new Error('expected a list!')
+    }
+    return obj
+  } catch (exc) {
+    throw new Error(
+      `Got an exception when trying to parse non-JSON list ${maybeJson}: ${exc}`,
+    )
+  }
+}
+
+function debugLog(groupName, message) {
+  if (process.env.RUNNER_DEBUG) {
+    core.startGroup(`Debugging for ${groupName}`)
+    core.debug(message)
+    core.endGroup()
+  }
 }

 module.exports = {
  getOTPVersion,
  getElixirVersion,
+  getGleamVersion,
  getRebar3Version,
+  getVersionFromSpec,
+  parseVersionFile,
 }
@@ -0,0 +1,82 @@
+const assert = require('assert')
+const core = require('@actions/core')
+const { problemMatcher } = require('../matchers/elixir-matchers.json')
+
+async function all() {
+  await testElixirMixCompileError()
+  await testElixirMixCompileWarning()
+  await testElixirMixTestFailure()
+  await testElixirCredoOutputDefault()
+}
+
+async function testElixirMixCompileError() {
+  const [matcher] = problemMatcher.find(
+    ({ owner }) => owner === 'elixir-mixCompileError',
+  ).pattern
+
+  const output = '** (CompileError) lib/test.ex:16: undefined function err/0'
+  const [message, , file, line] = output.match(matcher.regexp)
+  assert.equal(file, 'lib/test.ex')
+  assert.equal(line, '16')
+  assert.equal(message, output)
+}
+
+async function testElixirMixCompileWarning() {
+  const [messagePattern, filePattern] = problemMatcher.find(
+    ({ owner }) => owner === 'elixir-mixCompileWarning',
+  ).pattern
+
+  const firstOutput =
+    'warning: variable "err" does not exist and is being expanded to "err()"'
+  const secondOutput = '  lib/test.ex:16: Test.hello/0'
+
+  const [, message] = firstOutput.match(messagePattern.regexp)
+  assert.equal(
+    message,
+    'variable "err" does not exist and is being expanded to "err()"',
+  )
+
+  const [, file, line] = secondOutput.match(filePattern.regexp)
+  assert.equal(file, 'lib/test.ex')
+  assert.equal(line, '16')
+}
+
+async function testElixirMixTestFailure() {
+  const [messagePattern, filePattern] = problemMatcher.find(
+    ({ owner }) => owner === 'elixir-mixTestFailure',
+  ).pattern
+
+  const firstOutput = '1) test throws (TestTest)'
+  const secondOutput = '  test/test_test.exs:9'
+
+  const [, message] = firstOutput.match(messagePattern.regexp)
+  assert.equal(message, 'test throws (TestTest)')
+
+  const [, file, line] = secondOutput.match(filePattern.regexp)
+  assert.equal(file, 'test/test_test.exs')
+  assert.equal(line, '9')
+}
+
+async function testElixirCredoOutputDefault() {
+  const [messagePattern, filePattern] = problemMatcher.find(
+    ({ owner }) => owner === 'elixir-credoOutputDefault',
+  ).pattern
+
+  const firstOutput = '┃ [F] → Function is too complex (CC is 29, max is 9).'
+  const secondOutput = '┃       lib/test.ex:15:7 #(Test.hello)'
+
+  const [, message] = firstOutput.match(messagePattern.regexp)
+  assert.equal(message, 'Function is too complex (CC is 29, max is 9).')
+
+  const [, file, line, column] = secondOutput.match(filePattern.regexp)
+  assert.equal(file, 'lib/test.ex')
+  assert.equal(line, '15')
+  assert.equal(column, '7')
+}
+
+all()
+  .then(() => process.exit(0))
+  .catch((err) => {
+    core.error(err)
+    process.exit(1)
+  })
@@ -0,0 +1,21 @@
+name: test
+
+on:
+  push:
+    branches:
+      - master
+      - main
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2.0.0
+      - uses: erlef/setup-beam@v1.9.0
+        with:
+          otp-version: "23.2"
+          gleam-version: "0.23.0-rc1"
+      - run: gleam format --check src test
+      - run: gleam deps download
+      - run: gleam test
@@ -0,0 +1,4 @@
+*.beam
+*.ez
+build
+erl_crash.dump
@@ -0,0 +1,19 @@
+# gleam_gleam
+
+A Gleam project
+
+## Quick start
+
+```sh
+gleam run   # Run the project
+gleam test  # Run the tests
+gleam shell # Run an Erlang shell
+```
+
+## Installation
+
+If available on Hex this package can be added to your Gleam project.
+
+```sh
+gleam add gleam_gleam
+```
@@ -0,0 +1,16 @@
+name = "gleam_gleam"
+version = "0.1.0"
+
+# Fill out these fields if you intend to generate HTML documentation or publish
+# your project to the Hex package manager.
+#
+# licences = ["Apache-2.0"]
+# description = "A Gleam library..."
+# repository = { type = "github", user = "username", repo = "project" }
+# links = [{ title = "Website", href = "https://gleam.run" }]
+
+[dependencies]
+gleam_stdlib = "~> 0.18"
+
+[dev-dependencies]
+gleeunit = "~> 0.5"
@@ -0,0 +1,11 @@
+# This file was generated by Gleam
+# You typically do not need to edit this file
+
+packages = [
+  { name = "gleam_stdlib", version = "0.22.3", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "F2C2D389B06426E1289D5419F89BDE8E0F7F35A40B2BBB3C88188481F0D44A9F" },
+  { name = "gleeunit", version = "0.6.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "A006864621DB80C4FBB0746580703502FD81A4D38D23FCB20A8120984D353DF0" },
+]
+
+[requirements]
+gleam_stdlib = "~> 0.18"
+gleeunit = "~> 0.5"
@@ -0,0 +1,5 @@
+import gleam/io
+
+pub fn main() {
+  io.println("Hello from gleam_gleam!")
+}
@@ -0,0 +1,12 @@
+import gleeunit
+import gleeunit/should
+
+pub fn main() {
+  gleeunit.main()
+}
+
+// gleeunit test functions end in `_test`
+pub fn hello_world_test() {
+  1
+  |> should.equal(1)
+}
@@ -0,0 +1,2 @@
+/target/
+main
@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "rust_rebar3_cmd"
+version = "0.1.0"
@@ -0,0 +1,8 @@
+[package]
+name = "rust_rebar3_cmd"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
@@ -0,0 +1,32 @@
+use std::env;
+use std::process;
+use std::string;
+
+// an example function...
+fn main() {
+    let key = "PATH";
+    match env::var(key) {
+        Ok(val) => println!("{key}: {val:?}"),
+        Err(e) => println!("couldn't interpret {key}: {e}"),
+    }
+}
+
+#[allow(dead_code)]
+fn rebar3_cmd_version() -> Result<String, string::FromUtf8Error> {
+    println!("going for rebar3.cmd");
+    let output = process::Command::new("rebar3.cmd")
+        .arg("version")
+        .output()
+        .expect("error");
+    return String::from_utf8(output.stdout);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn it_works() {
+        rebar3_cmd_version().unwrap();
+    }
+}
@@ -0,0 +1,486 @@
+simulateInput('otp-version', '25.1.2')
+simulateInput('elixir-version', '1.14.2')
+simulateInput('rebar3-version', '3.20')
+simulateInput('install-rebar', 'true')
+simulateInput('install-hex', 'true')
+simulateInput('github-token', process.env.GITHUB_TOKEN)
+simulateInput('hexpm-mirrors', ['https://builds.hex.pm'])
+
+const assert = require('assert')
+const fs = require('fs')
+const core = require('@actions/core')
+const setupBeam = require('../src/setup-beam')
+const installer = require('../src/installer')
+
+async function all() {
+  await testFailInstallOTP()
+  await testFailInstallElixir()
+  await testFailInstallGleam()
+  await testFailInstallRebar3()
+
+  await testOTPVersions()
+  await testElixirVersions()
+  await testGleamVersions()
+  await testRebar3Versions()
+
+  await testGetVersionFromSpec()
+
+  await testParseVersionFile()
+}
+
+async function testFailInstallOTP() {
+  const otpOSVersion = 'ubuntu-08.04'
+  const otpVersion = 'OTP-23.2'
+  assert.rejects(
+    async () => {
+      await installer.installOTP(otpOSVersion, otpVersion)
+    },
+    (err) => {
+      assert.ok(err instanceof Error)
+      return true
+    },
+    `Installing Erlang/OTP ${otpVersion} over ${otpOSVersion} is supposed to fail`,
+  )
+}
+
+async function testFailInstallElixir() {
+  let exVersion
+
+  exVersion = '0.11'
+  assert.rejects(
+    async () => {
+      await installer.installElixir(exVersion)
+    },
+    (err) => {
+      assert.ok(err instanceof Error)
+      return true
+    },
+    `Installing Elixir ${exVersion} is supposed to fail`,
+  )
+
+  exVersion = 'v1.0.0-otp-17'
+  assert.rejects(
+    async () => {
+      await installer.installElixir(exVersion)
+    },
+    (err) => {
+      assert.ok(err instanceof Error)
+      return true
+    },
+    `Installing Elixir ${exVersion} is supposed to fail`,
+  )
+}
+
+async function testFailInstallGleam() {
+  const gleamVersion = '0.1.3'
+  assert.rejects(
+    async () => {
+      await installer.installGleam(gleamVersion)
+    },
+    (err) => {
+      assert.ok(err instanceof Error)
+      return true
+    },
+    `Installing Gleam ${gleamVersion} is supposed to fail`,
+  )
+}
+
+async function testFailInstallRebar3() {
+  const r3Version = '0.14.4'
+  assert.rejects(
+    async () => {
+      await installer.installRebar3(r3Version)
+    },
+    (err) => {
+      assert.ok(err instanceof Error)
+      return true
+    },
+    `Installing rebar3 ${r3Version} is supposed to fail`,
+  )
+}
+
+async function testOTPVersions() {
+  let got
+  let expected
+  let spec
+  let osVersion
+  const hexMirrors = ['https://repo.hex.pm', 'https://cdn.jsdelivr.net/hex']
+
+  if (process.platform === 'linux') {
+    spec = '19.3.x'
+    osVersion = 'ubuntu-16.04'
+    expected = 'OTP-19.3.6.13'
+    got = await setupBeam.getOTPVersion(spec, osVersion, hexMirrors)
+    assert.deepStrictEqual(got, expected)
+
+    spec = '^19.3.6'
+    osVersion = 'ubuntu-16.04'
+    expected = 'OTP-19.3.6.13'
+    got = await setupBeam.getOTPVersion(spec, osVersion, hexMirrors)
+    assert.deepStrictEqual(got, expected)
+
+    spec = '^19.3'
+    osVersion = 'ubuntu-18.04'
+    expected = 'OTP-19.3.6.13'
+    got = await setupBeam.getOTPVersion(spec, osVersion, hexMirrors)
+    assert.deepStrictEqual(got, expected)
+
+    spec = '20'
+    osVersion = 'ubuntu-20.04'
+    expected = 'OTP-20.3.8.26'
+    got = await setupBeam.getOTPVersion(spec, osVersion, hexMirrors)
+    assert.deepStrictEqual(got, expected)
+
+    spec = '20.x'
+    osVersion = 'ubuntu-20.04'
+    expected = 'OTP-20.3.8.26'
+    got = await setupBeam.getOTPVersion(spec, osVersion, hexMirrors)
+    assert.deepStrictEqual(got, expected)
+
+    spec = '20.0'
+    osVersion = 'ubuntu-20.04'
+    expected = 'OTP-20.0.5'
+    got = await setupBeam.getOTPVersion(spec, osVersion, hexMirrors)
+    assert.deepStrictEqual(got, expected)
+
+    spec = '20.0.x'
+    osVersion = 'ubuntu-20.04'
+    expected = 'OTP-20.0.5'
+    got = await setupBeam.getOTPVersion(spec, osVersion, hexMirrors)
+    assert.deepStrictEqual(got, expected)
+  }
+
+  if (process.platform === 'win32') {
+    spec = '24.0.1'
+    osVersion = 'windows-latest'
+    expected = '24.0.1'
+    got = await setupBeam.getOTPVersion(spec, osVersion, hexMirrors)
+    assert.deepStrictEqual(got, expected)
+
+    spec = '23.2.x'
+    osVersion = 'windows-2016'
+    expected = '23.2.7'
+    got = await setupBeam.getOTPVersion(spec, osVersion, hexMirrors)
+    assert.deepStrictEqual(got, expected)
+
+    spec = '23.0'
+    osVersion = 'windows-2019'
+    expected = '23.0.4'
+    got = await setupBeam.getOTPVersion(spec, osVersion, hexMirrors)
+    assert.deepStrictEqual(got, expected)
+  }
+}
+
+async function testElixirVersions() {
+  let got
+  let expected
+  let spec
+  let otpVersion
+  let before
+  const hexMirrors = ['https://repo.hex.pm']
+
+  spec = '1.1.x'
+  otpVersion = 'OTP-17'
+  expected = 'v1.1.1-otp-17'
+  got = await setupBeam.getElixirVersion(spec, otpVersion, hexMirrors)
+  assert.deepStrictEqual(got, expected)
+
+  spec = '1.10.4'
+  otpVersion = 'OTP-23'
+  expected = 'v1.10.4-otp-23'
+  got = await setupBeam.getElixirVersion(spec, otpVersion, hexMirrors)
+  assert.deepStrictEqual(got, expected)
+
+  spec = '1.12.1'
+  otpVersion = 'OTP-24.0.2'
+  expected = 'v1.12.1-otp-24'
+  got = await setupBeam.getElixirVersion(spec, otpVersion, hexMirrors)
+  assert.deepStrictEqual(got, expected)
+
+  before = simulateInput('version-type', 'strict')
+  spec = '1.14.0'
+  otpVersion = 'master'
+  expected = 'v1.14.0'
+  got = await setupBeam.getElixirVersion(spec, otpVersion, hexMirrors)
+  assert.deepStrictEqual(got, expected)
+  simulateInput('version-type', before)
+
+  before = simulateInput('version-type', 'strict')
+  spec = 'v1.11.0-rc.0'
+  otpVersion = 'OTP-23'
+  expected = 'v1.11.0-rc.0-otp-23'
+  got = await setupBeam.getElixirVersion(spec, otpVersion, hexMirrors)
+  assert.deepStrictEqual(got, expected)
+  simulateInput('version-type', before)
+
+  before = simulateInput('version-type', 'strict')
+  spec = 'v1.11.0'
+  otpVersion = '22.3.4.2'
+  expected = 'v1.11.0-otp-22'
+  got = await setupBeam.getElixirVersion(spec, otpVersion, hexMirrors)
+  assert.deepStrictEqual(got, expected)
+  simulateInput('version-type', before)
+
+  before = simulateInput('version-type', 'strict')
+  spec = 'main'
+  otpVersion = '23.1'
+  expected = 'main-otp-23'
+  got = await setupBeam.getElixirVersion(spec, otpVersion, hexMirrors)
+  assert.deepStrictEqual(got, expected)
+  simulateInput('version-type', before)
+}
+
+async function testGleamVersions() {
+  let got
+  let expected
+  let spec
+  let otpVersion
+
+  spec = 'v0.3.0'
+  otpVersion = 'OTP-23'
+  expected = 'v0.3.0'
+  got = await setupBeam.getGleamVersion(spec, otpVersion)
+  assert.deepStrictEqual(got, expected)
+
+  spec = '0.13.2'
+  otpVersion = 'OTP-24'
+  expected = 'v0.13.2'
+  got = await setupBeam.getGleamVersion(spec, otpVersion)
+  assert.deepStrictEqual(got, expected)
+
+  const before = simulateInput('version-type', 'strict')
+  spec = 'v0.14.0-rc2'
+  otpVersion = 'OTP-22'
+  expected = 'v0.14.0-rc2'
+  got = await setupBeam.getGleamVersion(spec, otpVersion)
+  assert.deepStrictEqual(got, expected)
+  simulateInput('version-type', before)
+}
+
+async function testRebar3Versions() {
+  let got
+  let expected
+  let spec
+
+  spec = '3.10.x'
+  expected = '3.10.0'
+  got = await setupBeam.getRebar3Version(spec)
+  assert.deepStrictEqual(got, expected)
+
+  spec = '3.11'
+  expected = '3.11.1'
+  got = await setupBeam.getRebar3Version(spec)
+  assert.deepStrictEqual(got, expected)
+
+  spec = '3.10'
+  expected = '3.10.0'
+  got = await setupBeam.getRebar3Version(spec)
+  assert.deepStrictEqual(got, expected)
+}
+
+async function testGetVersionFromSpec() {
+  let got
+  let expected
+  let spec
+  let before
+  const versions = [
+    '3.2.30.5',
+    '3.2.3.5',
+    '1',
+    '2',
+    '3.2.3.4.1',
+    '1.0.9',
+    '3.2.3.40.1',
+    '1.0.2',
+    '2.0',
+    '2.10',
+    '2.9',
+    '1.0',
+    '3.2.3.4.2',
+    '1.1.0',
+    '3.4.5.4',
+    '3.4.5.3',
+    '3.4.5.4.1',
+    '24.0-rc3',
+    '24.0-rc2',
+    '24.0',
+    '23.3.4',
+    '23.3.3',
+    '22.3.4.9.1',
+    '22.3.4.12.1',
+    '22.3.4.10.1',
+    'master',
+    'v11.11.0-rc.0-otp-23',
+    '22.3.4.2',
+  ]
+
+  spec = '1'
+  expected = '1.1.0'
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+
+  spec = '1.0'
+  expected = '1.0.9'
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+
+  before = simulateInput('version-type', 'strict')
+  spec = '1'
+  expected = '1'
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+  simulateInput('version-type', before)
+
+  before = simulateInput('version-type', 'strict')
+  spec = '1.0'
+  expected = '1.0'
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+  simulateInput('version-type', before)
+
+  spec = '2'
+  expected = '2.10'
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+
+  spec = '3'
+  expected = '3.4.5.4.1'
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+
+  spec = '3.2'
+  expected = '3.2.30.5'
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+
+  spec = '>20'
+  expected = '24.0'
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+
+  spec = '24.0'
+  expected = '24.0'
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+
+  before = simulateInput('version-type', 'strict')
+  spec = '24.0-rc3'
+  expected = '24.0-rc3'
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+  simulateInput('version-type', before)
+
+  spec = '24.0-rc2'
+  expected = '24.0-rc2'
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+
+  spec = '22.3'
+  expected = '22.3.4.12.1'
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+
+  spec = '23.3.3'
+  expected = '23.3.3'
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+
+  spec = '24'
+  expected = '24.0'
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+
+  spec = '23.3'
+  expected = '23.3.4'
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+
+  before = simulateInput('version-type', 'strict')
+  spec = 'master'
+  expected = 'master'
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+  simulateInput('version-type', before)
+
+  spec = 'master'
+  expected = 'master'
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+
+  before = simulateInput('version-type', 'strict')
+  spec = '22.3.4.2'
+  expected = '22.3.4.2'
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+  simulateInput('version-type', before)
+
+  before = simulateInput('version-type', 'strict')
+  spec = '22.3.4.3'
+  expected = null
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+  simulateInput('version-type', before)
+}
+
+async function testParseVersionFile() {
+  const otpVersion = unsimulateInput('otp-version')
+  const elixirVersion = unsimulateInput('elixir-version')
+  const gleamVersion = unsimulateInput('gleam-version')
+  const rebar3Version = unsimulateInput('rebar3-version')
+
+  const erlang = '25.1.1'
+  const elixir = '1.14.1'
+  const gleam = '0.23.0'
+  const rebar3 = '3.16.0'
+  const toolVersions = `# a comment
+erlang   ${erlang}# comment, no space
+elixir ${elixir}  # comment, with space
+ not-gleam 0.23 # not picked up
+gleam ${gleam} 
+rebar ${rebar3}`
+  const filename = 'test/.tool-versions'
+  fs.writeFileSync(filename, toolVersions)
+  process.env.GITHUB_WORKSPACE = ''
+  const appVersions = setupBeam.parseVersionFile(filename)
+  assert.strictEqual(appVersions.get('erlang'), erlang)
+  assert.strictEqual(appVersions.get('elixir'), elixir)
+
+  assert.ok(async () => {
+    await installer.installOTP(erlang)
+  })
+  assert.ok(async () => {
+    await installer.installElixir(elixir)
+  })
+  assert.ok(async () => {
+    await installer.installGleam(gleam)
+  })
+  assert.ok(async () => {
+    await installer.installRebar3(rebar3)
+  })
+
+  simulateInput('otp-version', otpVersion)
+  simulateInput('elixir-version', elixirVersion)
+  simulateInput('gleam-version', gleamVersion)
+  simulateInput('rebar3-version', rebar3Version)
+}
+
+function unsimulateInput(key) {
+  return simulateInput(key, '')
+}
+
+function simulateInput(key, value) {
+  const before = process.env[input(key)]
+  process.env[input(key)] = value
+  return before
+}
+
+function input(key) {
+  return `INPUT_${key.replace(/ /g, '_').toUpperCase()}`
+}
+
+all()
+  .then(() => process.exit(0))
+  .catch((err) => {
+    core.error(err)
+    process.exit(1)
+  })