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
71 changed files with 7356 additions and 2378 deletions
@@ -9,7 +9,6 @@ parserOptions:
 rules:
  indent: ["warn", 2]
  max-len: ["warn", 100]
-  no-console: 0
  no-undef: "error"
  no-unused-vars: ["error", {"varsIgnorePattern": "^_"}]
  no-use-before-define: 0
@@ -6,16 +6,18 @@ on:
    branches:
      - main
  pull_request:
-    branches:
-      - main
+    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@v2
-      - uses: actions/setup-node@v1
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
        with:
          node-version: '14'
      - run: npm install -g npm
@@ -28,25 +30,31 @@ jobs:
      - run: npm run yamllint
      - run: npm run jslint
      - name: Check if build left artifacts
-        run: git diff --exit-code
+        run: git diff --exit-code --ignore-space-at-eol

  unit_tests_ubuntu:
    name: Unit tests (Ubuntu)
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v1
+      - 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@v2
-      - uses: actions/setup-node@v1
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
        with:
          node-version: '14'
      - run: npm install --production
@@ -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
@@ -6,8 +6,7 @@ on:
    branches:
      - main
  pull_request:
-    branches:
-      - main
+    types: [opened, synchronize]

 jobs:
  integration_test:
@@ -21,6 +20,13 @@ jobs:
      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'
@@ -45,20 +51,10 @@ jobs:
          - otp-version: '24'
            rebar3-version: 'nightly'
            os: 'ubuntu-latest'
-          - elixir-version: 'v1.0'
-            otp-version: '17'
-            os: 'ubuntu-18.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-18.04'
          - elixir-version: 'v1.4'
            otp-version: '20'
-            rebar3-version: '3.6.0'
-            os: 'ubuntu-18.04'
+            rebar3-version: '3.15.0'
+            os: 'ubuntu-20.04'
          - elixir-version: 'v1.4'
            otp-version: '20'
            rebar3-version: '3.11'
@@ -66,7 +62,7 @@ jobs:
          - elixir-version: 'v1.6'
            otp-version: '21'
            rebar3-version: '3.12'
-            os: 'ubuntu-18.04'
+            os: 'ubuntu-20.04'
          - elixir-version: 'v1.6'
            otp-version: '21'
            rebar3-version: '3.12'
@@ -74,7 +70,7 @@ jobs:
          - elixir-version: 'v1.7'
            otp-version: '22'
            rebar3-version: '3.13'
-            os: 'ubuntu-18.04'
+            os: 'ubuntu-20.04'
          - elixir-version: 'v1.7'
            otp-version: '22'
            rebar3-version: '3.13'
@@ -82,11 +78,11 @@ jobs:
          - elixir-version: 'v1.10'
            otp-version: '23'
            rebar3-version: '3.14'
-            os: 'ubuntu-18.04'
+            os: 'ubuntu-20.04'
          - elixir-version: 'v1.13.4'
            otp-version: '25.0.2'
            rebar3-version: '3.19'
-            os: 'ubuntu-18.04'
+            os: 'ubuntu-20.04'
          - elixir-version: 'v1.10'
            otp-version: '23'
            rebar3-version: '3.14'
@@ -113,21 +109,33 @@ jobs:
          - elixir-version: 'master'
            otp-version: '23.1'
            os:  'ubuntu-20.04'
-          - elixir-version: 'master'
+          - elixir-version: 'main'
            otp-version: '25'
            os:  'ubuntu-20.04'
-          - gleam-version: '0.16'
-            otp-version: '24'
-            rebar3-version: '3.16'
-            os: 'ubuntu-latest'
-          - gleam-version: '0.19.0-rc3'
+            version-type: 'strict'
+          - gleam-version: '0.23'
            otp-version: '24'
            os: 'ubuntu-latest'
-          - gleam-version: '0.19.0-rc3'
+            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@v2
+      - uses: actions/checkout@v3
      - name: Use erlef/setup-beam
        id: setup-beam
        uses: ./
@@ -157,30 +165,30 @@ jobs:
        if: ${{matrix.combo.elixir-version}}
      - name: Run Elixir/Mix project tests
        run: |
-          cd test-projects/elixir_mix
+          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
+          cd test/projects/erlang_rebar3
          rebar3 ct
        if: ${{matrix.combo.rebar3-version}}
-      - name: Run Gleam/rebar3 project tests
+      - name: Format Gleam project (without installing Erlang/OTP)
        run: |
-          cd test-projects/gleam_rebar3
-          rebar3 eunit
-        if: ${{matrix.combo.gleam-version}}
-      - name: Type check Gleam project (without installing Erlang/OTP)
-        run: |
-          cd test-projects/gleam_gleam
-          gleam check
+          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
+          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}}
@@ -190,11 +198,11 @@ jobs:
        combo:
          - otp-version: '24'
            elixir-version: 'v1.12'
-            gleam-version: '0.19'
+            gleam-version: '0.23.0-rc1'
            rebar3-version: 'nightly'
            os: 'ubuntu-latest'
    steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
      - name: Use erlef/setup-beam
        id: setup-beam
        uses: ./
@@ -206,7 +214,7 @@ jobs:
      - run: env
      - name: List environment variables
        run: |
-          echo "${{env.INSTALL_DIR_FOR_ELIXIR}}"
-          echo "${{env.INSTALL_DIR_FOR_GLEAM}}"
-          echo "${{env.INSTALL_DIR_FOR_OTP}}"
-          echo "${{env.INSTALL_DIR_FOR_REBAR3}}"
+          [ -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}"
@@ -1,5 +1,5 @@
 ---
-name: update_3rd_party_licenses
+name: Update 3rd party licenses (automation)

 on:
  schedule:
@@ -11,11 +11,11 @@ jobs:
    name: Update 3rd party licenses
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v1
+      - 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}}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -6,8 +6,7 @@ on:
    branches:
      - main
  pull_request:
-    branches:
-      - main
+    types: [opened, synchronize]

 jobs:
  integration_test:
@@ -37,16 +36,23 @@ jobs:
            otp-version: '23'
            rebar3-version: '3.14'
            os: 'windows-latest'
-          - elixir-version: 'v1.11'
+          - elixir-version: 'v1.13'
            otp-version: '24'
            rebar3-version: '3.15'
            os: 'windows-latest'
-          - gleam-version: '0.16'
+          - gleam-version: '0.19.0-rc3'
            otp-version: '24'
-            rebar3-version: '3.16'
+            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@v2
+      - uses: actions/checkout@v3
      - name: Use erlef/setup-beam
        id: setup-beam
        uses: ./
@@ -65,6 +71,17 @@ jobs:
        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
@@ -73,20 +90,20 @@ jobs:
        if: ${{matrix.combo.elixir-version}}
      - name: Run Elixir/Mix project tests
        run: |
-          cd test-projects/elixir_mix
+          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
+          cd test/projects/erlang_rebar3
          rebar3 ct
        if: ${{matrix.combo.rebar3-version}}
-      - name: Run Gleam/rebar3 project tests
+      - name: Run escript
        run: |
-          cd test-projects/gleam_rebar3
-          rebar3 eunit
-        if: ${{matrix.combo.gleam-version}}
+          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}}
@@ -96,11 +113,11 @@ jobs:
        combo:
          - otp-version: '24'
            elixir-version: 'v1.12'
-            gleam-version: '0.19'
+            gleam-version: '0.23.0-rc1'
            rebar3-version: 'nightly'
            os: 'windows-latest'
    steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
      - name: Use erlef/setup-beam
        id: setup-beam
        uses: ./
@@ -112,7 +129,8 @@ jobs:
      - run: env
      - name: List environment variables
        run: |
-          echo "${{env.INSTALL_DIR_FOR_ELIXIR}}"
-          echo "${{env.INSTALL_DIR_FOR_GLEAM}}"
-          echo "${{env.INSTALL_DIR_FOR_OTP}}"
-          echo "${{env.INSTALL_DIR_FOR_REBAR3}}"
+          [ -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
@@ -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,12 +1,12 @@
 <!-- markdownlint-disable MD013 -->
 # setup-beam [![GitHub Actions][action-img]][action] [![GitHub Actions][ubuntu-img]][ubuntu] [![GitHub Actions][windows-img]][windows]

-[action]: https://github.com/erlef/setup-beam
-[action-img]: https://github.com/erlef/setup-beam/workflows/action/badge.svg
-[ubuntu]: https://github.com/erlef/setup-beam
-[ubuntu-img]: https://github.com/erlef/setup-beam/workflows/ubuntu/badge.svg
-[windows]: https://github.com/erlef/setup-beam
-[windows-img]: https://github.com/erlef/setup-beam/workflows/windows/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:
@@ -16,9 +16,11 @@ workflow by:
 - 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-` and `windows-` runtimes.

@@ -81,11 +83,36 @@ jobs:
    env:
      ImageOS: ubuntu20 # equivalent to runs-on ubuntu-20.04
    steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
      - uses: erlef/setup-beam@v1
        ...
 ```

+### 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
@@ -94,14 +121,14 @@ 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}}
@@ -118,14 +145,14 @@ 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}}
@@ -143,7 +170,7 @@ jobs:
  test:
    runs-on: windows-2022
    steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
      - uses: erlef/setup-beam@v1
        with:
          otp-version: '24'
@@ -161,11 +188,11 @@ jobs:
  test:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
      - uses: erlef/setup-beam@v1
        with:
          otp-version: '24'
-          gleam-version: '0.19.0-rc3'
+          gleam-version: '0.23.0-rc1'
      - run: gleam test
 ```

@@ -179,16 +206,57 @@ jobs:
  test:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
      - uses: erlef/setup-beam@v1
        with:
          otp-version: false
-          gleam-version: '0.19.0-rc3'
+          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: '25'
+          # Use `cdn.jsdelivr.net/hex` as an alternative to `builds.hex.pm`
+          hexpm-mirrors: https://cdn.jsdelivr.net/hex
+```
+
+Alternatively, you may try `cdn.jsdelivr.net/hex` if `builds.hex.pm` fails:
+
+```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: '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
@@ -8,10 +8,18 @@ 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
-    required: true
  elixir-version:
    description: Version range or exact version of Elixir to use
  gleam-version:
@@ -31,8 +39,16 @@ inputs:
      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)
+    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
@@ -57,22 +57,6 @@
          "column": 3
        }
      ]
-    },
-    {
-      "owner": "elixir-dialyzerOutputDefault",
-      "severity": "warning",
-      "pattern": [
-        {
-          "regexp": "^(.*):(\\d+):(.*)",
-          "file": 1,
-          "line": 2,
-          "code": 3
-        },
-        {
-          "regexp": "^(.*)$",
-          "message": 1
-        }
-      ]
    }
  ]
 }
@@ -57,22 +57,6 @@
          "column": 3
        }
      ]
-    },
-    {
-      "owner": "elixir-dialyzerOutputDefault",
-      "severity": "warning",
-      "pattern": [
-        {
-          "regexp": "^(.*):(\\d+):(.*)",
-          "file": 1,
-          "line": 2,
-          "code": 3
-        },
-        {
-          "regexp": "^(.*)$",
-          "message": 1
-        }
-      ]
    }
  ]
 }
@@ -1,21 +0,0 @@
-param([Parameter(Mandatory=$true)][string]${VSN})
-
-$ErrorActionPreference="Stop"
-
-Set-Location ${Env:RUNNER_TEMP}
-
-$FILE_INPUT="${VSN}.zip"
-$FILE_OUTPUT="elixir.zip"
-$DIR_FOR_BIN=".setup-beam/elixir"
-
-$ProgressPreference="SilentlyContinue"
-Invoke-WebRequest "https://repo.hex.pm/builds/elixir/${FILE_INPUT}" -OutFile "${FILE_OUTPUT}"
-$ProgressPreference="Continue"
-New-Item "${DIR_FOR_BIN}" -ItemType Directory | Out-Null
-$ProgressPreference="SilentlyContinue"
-Expand-Archive -DestinationPath "${DIR_FOR_BIN}" -Path "${FILE_OUTPUT}"
-$ProgressPreference="Continue"
-Write-Output "Installed Elixir version follows"
-& "${DIR_FOR_BIN}/bin/elixir" "-v" | Write-Output
-
-"INSTALL_DIR_FOR_ELIXIR=${Env:RUNNER_TEMP}/${DIR_FOR_BIN}" | Out-File -FilePath ${Env:GITHUB_ENV} -Encoding utf8 -Append
@@ -1,18 +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
-
-wget -q -O "${FILE_OUTPUT}" "https://repo.hex.pm/builds/elixir/${FILE_INPUT}"
-mkdir -p "${DIR_FOR_BIN}"
-unzip -q -o -d "${DIR_FOR_BIN}" "${FILE_OUTPUT}"
-echo "Installed Elixir version follows"
-${DIR_FOR_BIN}/bin/elixir -v
-
-echo "INSTALL_DIR_FOR_ELIXIR=${RUNNER_TEMP}/${DIR_FOR_BIN}" >> "${GITHUB_ENV}"
@@ -4,10 +4,26 @@ $ErrorActionPreference="Stop"

 Set-Location ${Env:RUNNER_TEMP}

-$FILE_INPUT="gleam-${VSN}-windows-64bit.zip"
 $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"
@@ -4,11 +4,27 @@ set -eo pipefail

 cd "${RUNNER_TEMP}"

-VSN=${1}
-FILE_INPUT=gleam-${VSN}-linux-amd64.tar.gz
+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"
@@ -1,22 +0,0 @@
-param([Parameter(Mandatory=$true)][string]${VSN})
-
-$ErrorActionPreference="Stop"
-
-Set-Location ${Env:RUNNER_TEMP}
-
-$FILE_OUTPUT="otp.exe"
-$DIR_FOR_BIN=".setup-beam/otp"
-
-$ProgressPreference="SilentlyContinue"
-Invoke-WebRequest "https://github.com/erlang/otp/releases/download/OTP-${VSN}/otp_win64_${VSN}.exe" -OutFile "${FILE_OUTPUT}"
-$ProgressPreference="Continue"
-New-Item "${DIR_FOR_BIN}" -ItemType Directory | Out-Null
-Move-Item "${FILE_OUTPUT}" "${DIR_FOR_BIN}"
-Start-Process "./${DIR_FOR_BIN}/${FILE_OUTPUT}" /S -Wait
-$ErlExec = Get-ChildItem -Path "C:/Program Files/" -Recurse -Depth 2 -Filter 'erl.exe' -Name | ForEach-Object { Write-Output "C:/Program Files/$_" }
-$ErlPath = Split-Path -Path "${ErlExec}"
-Write-Output "${ErlPath}" | Out-File -FilePath otp_path.txt -Encoding utf8 -NoNewline
-Write-Output "Installed Erlang/OTP version follows"
-& "${ErlPath}/erl.exe" "+V" | Write-Output
-
-"INSTALL_DIR_FOR_OTP="+(Get-Item ${ErlPath}).parent.FullName | Out-File -FilePath ${Env:GITHUB_ENV} -Encoding utf8 -Append
@@ -1,20 +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
-
-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
-"${DIR_FOR_BIN}/Install" -minimal "$(pwd)/${DIR_FOR_BIN}"
-echo "Installed Erlang/OTP version follows"
-${DIR_FOR_BIN}/bin/erl -version
-
-echo "INSTALL_DIR_FOR_OTP=${RUNNER_TEMP}/${DIR_FOR_BIN}" >> "${GITHUB_ENV}"
@@ -7,6 +7,7 @@ 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"
@@ -22,9 +23,10 @@ $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
-type ${FILE_OUTPUT_PS1}
+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" "version" | Write-Output
+& "${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,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
+        }
+      ]
+    }
+  ]
+}
@@ -4,12 +4,12 @@
  "private": true,
  "scripts": {
    "build": "ncc build src/setup-beam.js --no-cache",
-    "format": "prettier src/**/*.js --write && prettier __tests__/**/*.js --write",
-    "jslint": "eslint src/**/*.js && eslint __tests__/**/*.js",
+    "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-*.sh .github/workflows/*.sh",
-    "test": "node __tests__/setup-beam.test.js && node ./__tests__/problem-matchers.test.js",
+    "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"
  },
@@ -19,23 +19,25 @@
    }
  },
  "dependencies": {
-    "@actions/core": "1.6.0",
+    "@actions/core": "1.10.0",
    "@actions/exec": "1.1.1",
-    "semver": "7.3.6"
+    "@actions/http-client": "2.1.0",
+    "@actions/tool-cache": "^2.0.1",
+    "semver": "7.3.8"
  },
  "devDependencies": {
-    "@vercel/ncc": "0.33.4",
-    "eslint": "8.14.0",
+    "@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.5.1",
-    "eslint-plugin-react": "7.29.0",
-    "husky": "7.0.4",
-    "markdownlint": "0.25.1",
-    "prettier": "2.6.2",
+    "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.3.0",
-    "yarn": "1.22.18"
+    "yaml-lint": "1.7.0",
+    "yarn": "1.22.19"
  },
  "engines": {
    "node": ">=16"
@@ -1,21 +0,0 @@
-param([Parameter(Mandatory=$true)][string]${VSN})
-
-$ErrorActionPreference="Stop"
-
-Set-Location ${Env:RUNNER_TEMP}
-
-$FILE_INPUT="${VSN}.zip"
-$FILE_OUTPUT="elixir.zip"
-$DIR_FOR_BIN=".setup-beam/elixir"
-
-$ProgressPreference="SilentlyContinue"
-Invoke-WebRequest "https://repo.hex.pm/builds/elixir/${FILE_INPUT}" -OutFile "${FILE_OUTPUT}"
-$ProgressPreference="Continue"
-New-Item "${DIR_FOR_BIN}" -ItemType Directory | Out-Null
-$ProgressPreference="SilentlyContinue"
-Expand-Archive -DestinationPath "${DIR_FOR_BIN}" -Path "${FILE_OUTPUT}"
-$ProgressPreference="Continue"
-Write-Output "Installed Elixir version follows"
-& "${DIR_FOR_BIN}/bin/elixir" "-v" | Write-Output
-
-"INSTALL_DIR_FOR_ELIXIR=${Env:RUNNER_TEMP}/${DIR_FOR_BIN}" | Out-File -FilePath ${Env:GITHUB_ENV} -Encoding utf8 -Append
@@ -1,18 +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
-
-wget -q -O "${FILE_OUTPUT}" "https://repo.hex.pm/builds/elixir/${FILE_INPUT}"
-mkdir -p "${DIR_FOR_BIN}"
-unzip -q -o -d "${DIR_FOR_BIN}" "${FILE_OUTPUT}"
-echo "Installed Elixir version follows"
-${DIR_FOR_BIN}/bin/elixir -v
-
-echo "INSTALL_DIR_FOR_ELIXIR=${RUNNER_TEMP}/${DIR_FOR_BIN}" >> "${GITHUB_ENV}"
@@ -4,10 +4,26 @@ $ErrorActionPreference="Stop"

 Set-Location ${Env:RUNNER_TEMP}

-$FILE_INPUT="gleam-${VSN}-windows-64bit.zip"
 $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"
@@ -4,11 +4,27 @@ set -eo pipefail

 cd "${RUNNER_TEMP}"

-VSN=${1}
-FILE_INPUT=gleam-${VSN}-linux-amd64.tar.gz
+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"
@@ -1,22 +0,0 @@
-param([Parameter(Mandatory=$true)][string]${VSN})
-
-$ErrorActionPreference="Stop"
-
-Set-Location ${Env:RUNNER_TEMP}
-
-$FILE_OUTPUT="otp.exe"
-$DIR_FOR_BIN=".setup-beam/otp"
-
-$ProgressPreference="SilentlyContinue"
-Invoke-WebRequest "https://github.com/erlang/otp/releases/download/OTP-${VSN}/otp_win64_${VSN}.exe" -OutFile "${FILE_OUTPUT}"
-$ProgressPreference="Continue"
-New-Item "${DIR_FOR_BIN}" -ItemType Directory | Out-Null
-Move-Item "${FILE_OUTPUT}" "${DIR_FOR_BIN}"
-Start-Process "./${DIR_FOR_BIN}/${FILE_OUTPUT}" /S -Wait
-$ErlExec = Get-ChildItem -Path "C:/Program Files/" -Recurse -Depth 2 -Filter 'erl.exe' -Name | ForEach-Object { Write-Output "C:/Program Files/$_" }
-$ErlPath = Split-Path -Path "${ErlExec}"
-Write-Output "${ErlPath}" | Out-File -FilePath otp_path.txt -Encoding utf8 -NoNewline
-Write-Output "Installed Erlang/OTP version follows"
-& "${ErlPath}/erl.exe" "+V" | Write-Output
-
-"INSTALL_DIR_FOR_OTP="+(Get-Item ${ErlPath}).parent.FullName | Out-File -FilePath ${Env:GITHUB_ENV} -Encoding utf8 -Append
@@ -1,20 +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
-
-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
-"${DIR_FOR_BIN}/Install" -minimal "$(pwd)/${DIR_FOR_BIN}"
-echo "Installed Erlang/OTP version follows"
-${DIR_FOR_BIN}/bin/erl -version
-
-echo "INSTALL_DIR_FOR_OTP=${RUNNER_TEMP}/${DIR_FOR_BIN}" >> "${GITHUB_ENV}"
@@ -7,6 +7,7 @@ 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"
@@ -22,9 +23,10 @@ $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
-type ${FILE_OUTPUT_PS1}
+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" "version" | Write-Output
+& "${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
@@ -1,19 +1,76 @@
+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) {
+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
-  if (OS === 'linux') {
-    await exec(path.join(__dirname, 'install-otp.sh'), [osVersion, otpVersion])
-  } else if (OS === 'win32') {
-    const script = path.join(__dirname, 'install-otp.ps1')
-    await exec(`pwsh.exe ${script} -VSN:${otpVersion}`)
+
+  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)
  }
 }

@@ -21,14 +78,42 @@ async function installOTP(osVersion, otpVersion) {
 * Install Elixir.
 *
 * @param {string} elixirVersion
+ * @param {string[]} hexMirrors
 */
-async function installElixir(elixirVersion) {
-  const OS = process.platform
-  if (OS === 'linux') {
-    await exec(path.join(__dirname, 'install-elixir.sh'), [elixirVersion])
-  } else if (OS === 'win32') {
-    const script = path.join(__dirname, 'install-elixir.ps1')
-    await exec(`pwsh.exe ${script} -VSN:${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)
  }
 }

@@ -1,8 +1,8 @@
 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')

@@ -13,25 +13,39 @@ main().catch((err) => {
 async function main() {
  installer.checkPlatform()

+  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 osVersion = getRunnerOSVersion()
-  const otpSpec = core.getInput('otp-version', { required: true })
-  const elixirSpec = core.getInput('elixir-version', { required: false })
-  const gleamSpec = core.getInput('gleam-version', { required: false })
-  const rebar3Spec = core.getInput('rebar3-version', { required: false })
+  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') {
-    const otpVersion = await installOTP(otpSpec, osVersion)
-    const elixirInstalled = await maybeInstallElixir(elixirSpec, otpVersion)
+    await installOTP(otpSpec, osVersion, hexMirrors)
+    const elixirInstalled = await maybeInstallElixir(
+      elixirSpec,
+      otpSpec,
+      hexMirrors,
+    )

    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 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')
@@ -41,46 +55,39 @@ async function main() {
  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)
-  if (process.platform === 'linux') {
-    core.addPath(`${process.env.RUNNER_TEMP}/.setup-beam/otp/bin`)
-  } else if (process.platform === 'win32') {
-    const otpPath = fs.readFileSync(`${process.env.RUNNER_TEMP}/otp_path.txt`, {
-      encoding: 'utf8',
-      flag: 'r',
-    })
-    core.addPath(otpPath)
-  }
-  console.log('##[endgroup]')
+  core.endGroup()

  return otpVersion
 }

-async function maybeInstallElixir(elixirSpec, otpVersion) {
+async function maybeInstallElixir(elixirSpec, otpSpec, hexMirrors) {
  let installed = false

  if (elixirSpec) {
-    const elixirVersion = await getElixirVersion(elixirSpec, otpVersion)
-    console.log(`##[group]Installing Elixir ${elixirVersion}`)
-    await installer.installElixir(elixirVersion)
+    const elixirVersion = await getElixirVersion(
+      elixirSpec,
+      otpSpec,
+      hexMirrors,
+    )
+    core.startGroup(`Installing Elixir ${elixirVersion}`)
+    await installer.installElixir(elixirVersion, hexMirrors)
    core.setOutput('elixir-version', elixirVersion)
-    const disableProblemMatchers = core.getInput('disable_problem_matchers', {
-      required: false,
-    })
+    const disableProblemMatchers = getInput('disable_problem_matchers', false)
    if (disableProblemMatchers === 'false') {
-      const matchersPath = path.join(__dirname, '..', '.github')
-      console.log(
-        `##[add-matcher]${path.join(matchersPath, 'elixir-matchers.json')}`,
+      const elixirMatchers = path.join(
+        __dirname,
+        '..',
+        'matchers',
+        'elixir-matchers.json',
      )
+      core.info(`##[add-matcher]${elixirMatchers}`)
    }
-    core.addPath(`${process.env.RUNNER_TEMP}/.setup-beam/elixir/bin`)
-    console.log('##[endgroup]')
+    core.endGroup()

    installed = true
  }
@@ -88,13 +95,29 @@ async function maybeInstallElixir(elixirSpec, otpVersion) {
  return installed
 }

-async function mix(shouldMix, what) {
+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()
  }
 }

@@ -103,11 +126,11 @@ async function maybeInstallGleam(gleamSpec) {

  if (gleamSpec) {
    const gleamVersion = await getGleamVersion(gleamSpec)
-    console.log(`##[group]Installing Gleam ${gleamVersion}`)
+    core.startGroup(`Installing Gleam ${gleamVersion}`)
    await installer.installGleam(gleamVersion)
    core.setOutput('gleam-version', gleamVersion)
    core.addPath(`${process.env.RUNNER_TEMP}/.setup-beam/gleam/bin`)
-    console.log('##[endgroup]')
+    core.endGroup()

    installed = true
  }
@@ -125,11 +148,11 @@ async function maybeInstallRebar3(rebar3Spec) {
    } else {
      rebar3Version = await getRebar3Version(rebar3Spec)
    }
-    console.log(`##[group]Installing rebar3 ${rebar3Version}`)
+    core.startGroup(`Installing rebar3 ${rebar3Version}`)
    await installer.installRebar3(rebar3Version)
    core.setOutput('rebar3-version', rebar3Version)
    core.addPath(`${process.env.RUNNER_TEMP}/.setup-beam/rebar3/bin`)
-    console.log('##[endgroup]')
+    core.endGroup()

    installed = true
  }
@@ -137,21 +160,15 @@ async function maybeInstallRebar3(rebar3Spec) {
  return installed
 }

-async function getOTPVersion(otpSpec0, osVersion) {
-  const otpVersions = await getOTPVersions(osVersion)
-  const otpSpec = otpSpec0.match(/^(OTP-|maint-)?([^ ]+)/)
-  let otpVersion
-  if (otpSpec[1] && !isStrictVersion()) {
-    throw new Error(
-      `Requested Erlang/OTP version (${otpSpec0}) ` +
-        "should not contain 'OTP-, or maint-'",
-    )
-  }
-  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(
@@ -163,58 +180,48 @@ async function getOTPVersion(otpSpec0, osVersion) {
  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(/^v?(.+)(-otp-.+)/) || exSpec0.match(/^v?(.+)/)
-  let elixirVersion
-  if (exSpec[2] && !isStrictVersion()) {
-    throw new Error(
-      `Requested Elixir / Erlang/OTP version (${exSpec0} / ${otpVersion}) ` +
-        "should not contain '-otp-...'",
-    )
+  const exSpec = exSpec0.replace(/-otp-.*$/, '')
+  const elixirVersionFromSpec = getVersionFromSpec(exSpec, semverVersions, true)
+  let elixirVersionForDownload = elixirVersionFromSpec
+  if (isVersion(otpVersionMajor)) {
+    elixirVersionForDownload = `${elixirVersionFromSpec}-otp-${otpVersionMajor}`
  }
-  if (exSpec) {
-    elixirVersion = getVersionFromSpec(exSpec[1], semverVersions)
-  }
-  if (!exSpec || elixirVersion === null) {
+  if (elixirVersionFromSpec === null) {
    throw new Error(
      `Requested Elixir version (${exSpec0}) not found in version list ` +
        "(should you be using option 'version-type': 'strict'?)",
    )
  }
-  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 ${elixirVersion} (built for OTP ${otpVersionMajor})`,
-      )
-    } else {
-      // ... and it's not available: fallback to the 'generic' version (v1.4.5 only).
-      elixirVersionWithOTP = elixirVersion
-      core.info(`Using Elixir ${elixirVersion}`)
-    }
+  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 (${exSpec0} / ${otpVersion}) not ` +
-        "found in version list (should you be using option 'version-type': 'strict'?)",
+      `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 maybePrependWithV(elixirVersionWithOTP, elixirVersion)
+  return maybePrependWithV(elixirVersionForDownload)
 }

 async function getGleamVersion(gleamSpec0) {
-  const gleamSpec = gleamSpec0.match(/^v?(.+)/)
+  const gleamSpec = gleamSpec0.match(/^v?(.+)$/)
  const gleamVersions = await getGleamVersions()
-  const gleamVersion = getVersionFromSpec(gleamSpec[1], gleamVersions)
+  const gleamVersion = getVersionFromSpec(gleamSpec[1], gleamVersions, true)
  if (gleamVersion === null) {
    throw new Error(
      `Requested Gleam version (${gleamSpec0}) not found in version list ` +
@@ -238,19 +245,19 @@ async function getRebar3Version(r3Spec) {
  return rebar3Version
 }

-async function getOTPVersions(osVersion) {
+async function getOTPVersions(osVersion, hexMirrors) {
+  let otpVersionsListings
  let originListing
-  let pageIdxs
  if (process.platform === 'linux') {
-    originListing = `https://repo.hex.pm/builds/otp/${osVersion}/builds.txt`
-    pageIdxs = [null]
+    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'
-    pageIdxs = [1, 2, 3]
+    otpVersionsListings = await get(originListing, [1, 2, 3])
  }
+  debugLog(`OTP versions listings from ${originListing}`, otpVersionsListings)

-  const otpVersionsListings = await get(originListing, pageIdxs)
  const otpVersions = new Map()

  if (process.platform === 'linux') {
@@ -258,13 +265,15 @@ async function getOTPVersions(osVersion) {
      .trim()
      .split('\n')
      .forEach((line) => {
-        const otpMatch = line.match(/^(OTP-|maint-)?([^ ]+)/)
+        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) => {
-      JSON.parse(otpVersionsListing)
+      jsonParseAsList(otpVersionsListing)
        .map((x) => x.assets)
        .flat()
        .filter((x) => x.name.match(/^otp_win64_.*.exe$/))
@@ -275,14 +284,13 @@ async function getOTPVersions(osVersion) {
        })
    })
  }
-
  return otpVersions
 }

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

@@ -292,7 +300,7 @@ async function getElixirVersions() {
    .forEach((line) => {
      const elixirMatch =
        line.match(/^v?(.+)-otp-([^ ]+)/) || line.match(/^v?([^ ]+)/)
-      const elixirVersion = elixirMatch[1]
+      const elixirVersion = maybePrependWithV(elixirMatch[1])
      const otpVersion = elixirMatch[2]
      const otpVersions = otpVersionsForElixirMap.get(elixirVersion) || []
      if (otpVersion) {
@@ -312,7 +320,7 @@ async function getGleamVersions() {
  )
  const gleamVersionsListing = []
  resultJSONs.forEach((resultJSON) => {
-    JSON.parse(resultJSON)
+    jsonParseAsList(resultJSON)
      .map((x) => x.tag_name)
      .sort()
      .forEach((v) => gleamVersionsListing.push(v))
@@ -327,7 +335,7 @@ async function getRebar3Versions() {
  )
  const rebar3VersionsListing = []
  resultJSONs.forEach((resultJSON) => {
-    JSON.parse(resultJSON)
+    jsonParseAsList(resultJSON)
      .map((x) => x.tag_name)
      .sort()
      .forEach((v) => rebar3VersionsListing.push(v))
@@ -336,10 +344,10 @@ async function getRebar3Versions() {
 }

 function isStrictVersion() {
-  return core.getInput('version-type', { required: false }) === 'strict'
+  return getInput('version-type', false) === 'strict'
 }

-function getVersionFromSpec(spec, versions) {
+function getVersionFromSpec(spec, versions, maybePrependWithV0) {
  let version = null

  if (spec.match(/rc/) || isStrictVersion()) {
@@ -364,7 +372,16 @@ function getVersionFromSpec(spec, versions) {
    }
  }

-  return version === null || version === undefined ? null : version
+  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) {
@@ -427,63 +444,147 @@ function getRunnerOSVersion() {
 }

 async function get(url0, pageIdxs) {
-  function getPage(pageIdx) {
-    return new Promise((resolve, reject) => {
-      const url = new URL(url0)
-      if (pageIdx !== null) {
-        url.searchParams.append('page', pageIdx)
-      }
-      https
-        .get(
-          url,
-          {
-            headers: { 'user-agent': 'setup-beam' },
-          },
-          (res) => {
-            let data = ''
-            res.on('data', (chunk) => {
-              data += chunk
-            })
-            res.on('end', () => {
-              if (res.statusCode >= 400 && res.statusCode <= 599) {
-                reject(
-                  new Error(
-                    `Got ${res.statusCode} from ${url}. Exiting with error`,
-                  ),
-                )
-              } else {
-                resolve(data)
-              }
-            })
-          },
-        )
-        .on('error', (err) => {
-          reject(err)
-        })
+  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`,
+      )
+    }
+
+    return response.readBody()
  }
-  let ret
+
  if (pageIdxs[0] === null) {
-    ret = getPage(null)
-  } else {
-    ret = Promise.all(pageIdxs.map((pageIdx) => getPage(pageIdx)))
+    return getPage(null)
  }
-  return ret
+  return Promise.all(pageIdxs.map(getPage))
 }

-function maybePrependWithV(versionToPrepend, specVersion) {
-  const digitStart = /^\d+/
-  let v = versionToPrepend
-  if (digitStart.test(specVersion)) {
-    v = `v${versionToPrepend}`
+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,
 }
@@ -1,11 +0,0 @@
-# This file was generated by Gleam
-# You typically do not need to edit this file
-
-packages = [
-  { name = "gleam_stdlib", version = "0.19.2", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "FFA79EA12369F122B68885E694E097D6810402A2F86BFF48AAE9E40ACE654F4C" },
-  { name = "gleeunit", version = "0.6.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "77701A5E5A565727E1EEAC9196FB878D544049B6331CD0305B5A69699135EA1C" },
-]
-
-[requirements]
-gleam_stdlib = "~> 0.18"
-gleeunit = "~> 0.5"
@@ -1,23 +0,0 @@
-name: test
-
-on:
-  push:
-    branches:
-      - master
-      - main
-  pull_request:
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2.0.0
-      - uses: gleam-lang/setup-erlang@v1.1.2
-        with:
-          otp-version: 23.2
-      - uses: gleam-lang/setup-gleam@v1.0.2
-        with:
-          gleam-version: 0.16.1
-      - run: rebar3 install_deps
-      - run: rebar3 eunit
-      - run: gleam format --check src test
@@ -1,21 +0,0 @@
-*.beam
-*.iml
-*.o
-*.plt
-*.swo
-*.swp
-*~
-.erlang.cookie
-.eunit
-.idea
-.rebar
-.rebar3
-_*
-_build
-docs
-ebin
-erl_crash.dump
-gen
-log
-logs
-rebar3.crashdump
@@ -1,24 +0,0 @@
-# gleam_rebar3
-
-A Gleam project
-
-## Quick start
-
-```sh
-# Run the eunit tests
-rebar3 eunit
-
-# Run the Erlang REPL
-rebar3 shell
-```
-
-## Installation
-
-If [available in Hex](https://rebar3.org/docs/configuration/dependencies/#declaring-dependencies)
-this package can be installed by adding `gleam_rebar3` to your `rebar.config` dependencies:
-
-```erlang
-{deps, [
-    gleam_rebar3
-]}.
-```
@@ -1,3 +0,0 @@
-name = "gleam_rebar3"
-
-# repository = { type = "github", user = "my-user", repo = "gleam_rebar3" }
@@ -1,12 +0,0 @@
-{erl_opts, [debug_info]}.
-{src_dirs, ["src", "gen/src"]}.
-
-{profiles, [
-    {test, [{src_dirs, ["src", "test", "gen/src", "gen/test"]}]}
-]}.
-
-{project_plugins, [rebar_gleam]}.
-
-{deps, [
-    {gleam_stdlib, "0.16.0"}
-]}.
@@ -1,15 +0,0 @@
-{application, gleam_rebar3,
- [{description, "A Gleam project"},
-  {vsn, "0.1.0"},
-  {registered, []},
-  {applications,
-   [kernel,
-    stdlib,
-    gleam_stdlib
-   ]},
-  {env,[]},
-  {modules, []},
-
-  {include_files, ["gleam.toml", "gen"]},
-  {links, []}
-]}.
@@ -1,3 +0,0 @@
-pub fn hello_world() -> String {
-  "Hello, from gleam_rebar3!"
-}
@@ -1,7 +0,0 @@
-import gleam_rebar3
-import gleam/should
-
-pub fn hello_world_test() {
-  gleam_rebar3.hello_world()
-  |> should.equal("Hello, from gleam_rebar3!")
-}
@@ -1,12 +1,12 @@
 const assert = require('assert')
-const { problemMatcher } = require('../.github/elixir-matchers.json')
+const core = require('@actions/core')
+const { problemMatcher } = require('../matchers/elixir-matchers.json')

 async function all() {
  await testElixirMixCompileError()
  await testElixirMixCompileWarning()
  await testElixirMixTestFailure()
  await testElixirCredoOutputDefault()
-  await testElixirDialyzerOutputDefault()
 }

 async function testElixirMixCompileError() {
@@ -74,27 +74,9 @@ async function testElixirCredoOutputDefault() {
  assert.equal(column, '7')
 }

-async function testElixirDialyzerOutputDefault() {
-  const [messagePattern, filePattern] = problemMatcher.find(
-    ({ owner }) => owner === 'elixir-dialyzerOutputDefault',
-  ).pattern
-
-  const firstOutput = 'lib/test.ex:15:invalid_contract'
-  const secondOutput =
-    'The @spec for the function does not match the success typing of the function.'
-
-  const [, file, line, code] = firstOutput.match(messagePattern.regexp)
-  assert.equal(file, 'lib/test.ex')
-  assert.equal(line, '15')
-  assert.equal(code, 'invalid_contract')
-
-  const [, message] = secondOutput.match(filePattern.regexp)
-  assert.equal(message, secondOutput)
-}
-
 all()
  .then(() => process.exit(0))
  .catch((err) => {
-    console.error(err)
+    core.error(err)
    process.exit(1)
  })
@@ -15,7 +15,7 @@ jobs:
      - uses: erlef/setup-beam@v1.9.0
        with:
          otp-version: "23.2"
-          gleam-version: "0.19.0-rc3"
+          gleam-version: "0.23.0-rc1"
      - run: gleam format --check src test
      - run: gleam deps download
      - run: gleam test
@@ -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,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();
+    }
+}
@@ -1,10 +1,14 @@
-simulateInput('otp-version', '23.2')
-simulateInput('elixir-version', '1.11')
-simulateInput('rebar3-version', '3.14')
+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')

@@ -20,6 +24,8 @@ async function all() {
  await testRebar3Versions()

  await testGetVersionFromSpec()
+
+  await testParseVersionFile()
 }

 async function testFailInstallOTP() {
@@ -98,48 +104,49 @@ async function testOTPVersions() {
  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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    got = await setupBeam.getOTPVersion(spec, osVersion, hexMirrors)
    assert.deepStrictEqual(got, expected)
  }

@@ -147,19 +154,19 @@ async function testOTPVersions() {
    spec = '24.0.1'
    osVersion = 'windows-latest'
    expected = '24.0.1'
-    got = await setupBeam.getOTPVersion(spec, osVersion)
+    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)
+    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)
+    got = await setupBeam.getOTPVersion(spec, osVersion, hexMirrors)
    assert.deepStrictEqual(got, expected)
  }
 }
@@ -169,48 +176,58 @@ async function testElixirVersions() {
  let expected
  let spec
  let otpVersion
+  let before
+  const hexMirrors = ['https://repo.hex.pm']

  spec = '1.1.x'
-  otpVersion = 'OTP-23'
-  expected = 'v1.1.1'
-  got = await setupBeam.getElixirVersion(spec, otpVersion)
+  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)
+  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)
+  got = await setupBeam.getElixirVersion(spec, otpVersion, hexMirrors)
  assert.deepStrictEqual(got, expected)

-  simulateInput('version-type', 'strict')
+  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)
+  got = await setupBeam.getElixirVersion(spec, otpVersion, hexMirrors)
  assert.deepStrictEqual(got, expected)
-  simulateInput('version-type', 'loose')
+  simulateInput('version-type', before)

-  simulateInput('version-type', 'strict')
+  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)
+  got = await setupBeam.getElixirVersion(spec, otpVersion, hexMirrors)
  assert.deepStrictEqual(got, expected)
-  simulateInput('version-type', 'loose')
+  simulateInput('version-type', before)

-  simulateInput('version-type', 'strict')
-  spec = 'master'
+  before = simulateInput('version-type', 'strict')
+  spec = 'main'
  otpVersion = '23.1'
-  expected = 'master-otp-23'
-  got = await setupBeam.getElixirVersion(spec, otpVersion)
+  expected = 'main-otp-23'
+  got = await setupBeam.getElixirVersion(spec, otpVersion, hexMirrors)
  assert.deepStrictEqual(got, expected)
-  simulateInput('version-type', 'loose')
+  simulateInput('version-type', before)
 }

 async function testGleamVersions() {
@@ -231,13 +248,13 @@ async function testGleamVersions() {
  got = await setupBeam.getGleamVersion(spec, otpVersion)
  assert.deepStrictEqual(got, expected)

-  simulateInput('version-type', 'strict')
+  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', 'loose')
+  simulateInput('version-type', before)
 }

 async function testRebar3Versions() {
@@ -265,6 +282,7 @@ async function testGetVersionFromSpec() {
  let got
  let expected
  let spec
+  let before
  const versions = [
    '3.2.30.5',
    '3.2.3.5',
@@ -306,19 +324,19 @@ async function testGetVersionFromSpec() {
  got = setupBeam.getVersionFromSpec(spec, versions)
  assert.deepStrictEqual(got, expected)

-  simulateInput('version-type', 'strict')
+  before = simulateInput('version-type', 'strict')
  spec = '1'
  expected = '1'
  got = setupBeam.getVersionFromSpec(spec, versions)
  assert.deepStrictEqual(got, expected)
-  simulateInput('version-type', 'loose')
+  simulateInput('version-type', before)

-  simulateInput('version-type', 'strict')
+  before = simulateInput('version-type', 'strict')
  spec = '1.0'
  expected = '1.0'
  got = setupBeam.getVersionFromSpec(spec, versions)
  assert.deepStrictEqual(got, expected)
-  simulateInput('version-type', 'loose')
+  simulateInput('version-type', before)

  spec = '2'
  expected = '2.10'
@@ -345,12 +363,12 @@ async function testGetVersionFromSpec() {
  got = setupBeam.getVersionFromSpec(spec, versions)
  assert.deepStrictEqual(got, expected)

-  simulateInput('version-type', 'strict')
+  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', 'loose')
+  simulateInput('version-type', before)

  spec = '24.0-rc2'
  expected = '24.0-rc2'
@@ -377,33 +395,92 @@ async function testGetVersionFromSpec() {
  got = setupBeam.getVersionFromSpec(spec, versions)
  assert.deepStrictEqual(got, expected)

-  simulateInput('version-type', 'strict')
+  before = simulateInput('version-type', 'strict')
  spec = 'master'
  expected = 'master'
  got = setupBeam.getVersionFromSpec(spec, versions)
  assert.deepStrictEqual(got, expected)
-  simulateInput('version-type', 'loose')
+  simulateInput('version-type', before)

  spec = 'master'
  expected = 'master'
  got = setupBeam.getVersionFromSpec(spec, versions)
  assert.deepStrictEqual(got, expected)

-  simulateInput('version-type', 'strict')
+  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', 'loose')
+  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) {
-  process.env[`INPUT_${key.replace(/ /g, '_').toUpperCase()}`] = 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) => {
-    console.error(err)
+    core.error(err)
    process.exit(1)
  })
Author	SHA1	Message	Date
Paulo F. Oliveira	61e01a43a5	Fix post -main-merge issue (#213 )	2023-06-21 15:08:08 -05:00
Christoph Grothaus	df9a60921b	🐛 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	2023-06-15 14:45:56 +01:00
Jason Axelson	54d4f15c75	Link to the Elixir/Erlang compatibility page (#209 ) * Link to the elixir/erlang compatibility page Currently when a user encounters an incompatibility between the requested elixir and erlang versions it isn't clear how to figure out what the compatible versions are. This is the current error as shown to users: > Error: Requested Elixir / Erlang/OTP version (1.11.3 / 24.2) not found in version list (did you check Compatibility between Elixir and Erlang/OTP?) Example failure: https://github.com/ScenicFramework/scenic/pull/318/checks This PR adds a link to https://hexdocs.pm/elixir/compatibility-and-deprecations.html so user's can easily see what versions are compatible. * Update dist/index.js * Act on review comment: on > at --------- Co-authored-by: Paulo F. Oliveira <paulo.ferraz.oliveira@gmail.com>	2023-06-15 14:45:32 +01:00
Kian-Meng Ang	ea13066252	Match the right Ubuntu version to Erlang/OTP-20 in readme (#212 )	2023-06-15 14:08:54 +01:00
github-actions[bot]	53bf0a5069	Update 3rd party licenses (#207 ) Co-authored-by: GitHub Actions <actions@user.noreply.github.com>	2023-05-17 13:07:48 +01:00
Paulo F. Oliveira	977eee5f6e	Fix 3rd party licenses updater (action) (#202 ) * Act on CI results: fix as per what GitHub Actions is requesting Seems to have worked up until recently, but then it started breaking :shrug * Name the workflow a little better	2023-05-08 19:42:25 -05:00
Eric Meadows-Jönsson	51905b8795	Use @actions/tool-cache (#196 )	2023-05-08 12:40:34 +02:00
Paulo F. Oliveira	b9783cdeea	Ease debugging, fix some CI issues, tweak folder structure (#200 ) * Enable debug for OTP versions' listings * Make it easier to detect * Prevent error annotation on expected error The fact that one mirror fails in the above test and others follow working is test enough for me A single failing mirror should fail, but it's confusing to have an error annotation for a success (via continue-on-error) while not being able to suppress it via GitHub Actions * Trying to figure out why we have a rebar_core exception Might simply be that the bug is already fixed and we need to bump rebar3 * Try to debug into non-JSON input * Prevent error in rebar_core We're getting Access Denied for Fetching registry from "https://repo.hex.pm:443/registry.ets.gz?" * Try to figure out what's breaking tests * Make jsonParse(...).map failure more understandable * Ease test maintenance * Tweak folder structure while moving console._ to core._	2023-05-08 09:31:17 +01:00
Paul Guyot	cf692c3264	New option to work with one or more hex.pm mirrors (#197 ) * New option to work with one or more hex.pm mirrors Add a new option called `hexpm-mirrors` for one or more hex.pm mirrors. Default list is `builds.hex.pm`, so behavior is unaffected unless option is used. Signed-off-by: Paul Guyot <pguyot@kallisys.net> * Implement suggested rewording changes from @paulo-ferraz-oliveira Co-authored-by: Paulo F. Oliveira <paulo.ferraz.oliveira@gmail.com> Signed-off-by: Paul Guyot <pguyot@kallisys.net> --------- Signed-off-by: Paul Guyot <pguyot@kallisys.net> Co-authored-by: Paulo F. Oliveira <paulo.ferraz.oliveira@gmail.com>	2023-05-04 07:27:05 +01:00
Luke Bakken	9641cb96c1	Be explicit about which file (.bat / .cm) is executed in the Windows installation flow (#198 ) In my Windows 11 test environment, using Powershell Core 7.3.4, I get the following message while running similar code to what this github action uses: ``` Installed Elixir version follows InvalidOperation: C:\Users\vagrant\setup-beam\src\test.ps1:4 Line \| 4 \| & "${DIR_FOR_BIN}/bin/elixir" "-v" \| Write-Output \| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ \| Cannot run a document in the middle of a pipeline: C:\elixir\bin\elixir. ``` Adding `.bat` fixes the issue. This is probably not the root cause of erlef/setup-beam#189, however.	2023-05-03 10:50:24 +01:00
Eric Meadows-Jönsson	94b8820fed	Use @actions/http-client (#195 )	2023-05-02 18:40:11 +02:00
Eric Meadows-Jönsson	c2e02f777c	Use new domain repo.hex.pm => builds.hex.pm (#192 )	2023-05-01 15:59:28 +02:00
Paulo F. Oliveira	2595a954a1	Fix tests (#184 ) * Fix licenses * Be less hopeful * Prevent remote breakage from breaking our CI	2023-03-29 22:54:51 -05:00
Blake Kostner	a255120a82	Remove Dialyzer-specific problem matcher (#182 ) * fix: remove dialyzer problem matcher * remove dialyzer problem matcher test * remove dist problem matcher	2023-03-29 14:43:12 +01:00
Bryan Paxton	ffd9affe89	Update examples in readme to reference actions/checkout@v3 (#181 )	2023-02-13 18:35:35 -06:00
Paulo F. Oliveira	049962787b	Test rebar3 being installed after OTP via .tool-versions (#180 )	2023-01-27 21:57:09 -06:00
Paulo F. Oliveira	1f06ac36d3	Simulate input `github-token` to fix unit tests (#174 ) * Simulate input to fix unit tests	2023-01-07 13:51:47 -06:00
Bryan Paxton	e3f6ffe287	Provide an input for github tokens (#172 ) * Provide an input for github tokens - By providing an input for github tokens with a default users no longer have to pass the github token via their environment across workflows. - Remove GITHUB_TOKEN from our environment in all workflows * Don't run workflows on main on pull requests Co-authored-by: Paulo F. Oliveira <paulo.ferraz.oliveira@gmail.com>	2023-01-06 10:14:27 -06:00
github-actions[bot]	81d8403713	Update 3rd party licenses (#171 ) Co-authored-by: GitHub Actions <actions@user.noreply.github.com>	2023-01-05 13:49:43 +00:00
dependabot[bot]	c10774ce0f	Bump json5 from 1.0.1 to 1.0.2 (#170 ) Bumps [json5](https://github.com/json5/json5) from 1.0.1 to 1.0.2. - [Release notes](https://github.com/json5/json5/releases) - [Changelog](https://github.com/json5/json5/blob/main/CHANGELOG.md) - [Commits](https://github.com/json5/json5/compare/v1.0.1...v1.0.2) --- updated-dependencies: - dependency-name: json5 dependency-type: indirect ... Signed-off-by: dependabot[bot] <support@github.com> Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2023-01-04 07:35:12 +00:00
Paulo F. Oliveira	37ac1c5116	Try to prevent 403 when accessing the GitHub API (#168 ) * Repeat request on error (while logging it) * Test one change at a time * Conditionally authorize requests This seems to affect Windows builds, so might not be the best solution, but we're trying to isolate the issue to move forward * Act on CI results * Ease consumption via a JSON.parse wrapper We still throw the error, but in a more controlled manner * Act on CI results	2023-01-04 07:27:57 +00:00
Paulo F. Oliveira	2d314bc413	Check behaviour on Windows pre- Gleam 0.23 (#166 ) * Check behaviour on Windows pre- Gleam 0.23 * Increase consistency with .sh counterpart * Support older versions (pre 0.22.1) on Windows * Increase inter-script consistency * Run `npm run build-dist` * React to CI results	2022-12-14 09:25:50 -06:00
Paulo F. Oliveira	aee3f52e58	Update versions as to not have CI fail (while fixing "non-failing" CI) (#164 ) * Make README links usable * Update versions under test Otherwise it silently fails with "Error: Requested Erlang/OTP version (23.2) not found in version list (should you be using option 'version-type': 'strict'?)", which is not too important since this happens when setup-beam.js is included (which happens in the test environment only) * Fix failing Gleam test I think `gleam check` requires OTP (execution complains about missing `escript`) where `gleam format` does not	2022-12-11 18:33:12 -06:00
github-actions[bot]	96fce952fd	Update 3rd party licenses (#162 ) Co-authored-by: GitHub Actions <actions@user.noreply.github.com>	2022-12-08 07:51:51 -06:00
Paulo F. Oliveira	35850967ef	Have rebar3.cmd work on a Windows CMD shell (#151 ) * Provide a working rebar.cmd for system that need it (Windows on non-PowerShell) * Add tests for recent changes If the "run" were to fail the job would too * Check if Rust can find it	2022-12-01 19:16:40 +00:00
Blake Kostner	b980a5ac9b	Ease Elixir escripts execution by adding ${HOME}/.mix/escripts to path (#153 ) * feat: add escripts to path * Update src/install-elixir.ps1 Co-authored-by: Paulo F. Oliveira <paulo.ferraz.oliveira@gmail.com> * add github action combo to test escript * force install * use os homedir for escript install path Co-authored-by: Paulo F. Oliveira <paulo.ferraz.oliveira@gmail.com>	2022-11-22 22:39:36 +00:00
Paulo F. Oliveira	c373088147	Ease consumption by means of .tool-versions (#159 ) * Ease consumption by means of .tool-versions * Update as per self-review * Update as per self-review * Act on CI results * Act on CI results * Act on CI results This value is check by code, in any case * Act on CI results * Act on CI results * Act on CI results It appears we can't install Elixir twice on Windows, but can on Ubuntu; this is outside the scope of this branch's context so I won't fix it now * Tweak visual consumption elements * Ease potential future maintenance and/or update	2022-11-22 22:34:21 +00:00
github-actions[bot]	529221db21	Update 3rd party licenses (#158 ) Co-authored-by: GitHub Actions <actions@user.noreply.github.com>	2022-11-18 22:47:54 +00:00
github-actions[bot]	f19acc5287	Update 3rd party licenses (#157 ) Co-authored-by: GitHub Actions <actions@user.noreply.github.com>	2022-11-18 18:17:34 +00:00
github-actions[bot]	00a8fc1243	Update 3rd party licenses (#150 ) Co-authored-by: GitHub Actions <actions@user.noreply.github.com>	2022-10-20 21:37:52 +01:00
Paulo F. Oliveira	713cc2ffe3	Move away from set-output (while updating all deps) (#148 ) * Update all our deps Get rid of warnings such as: * `save-state` will be deprecated * `set-output` will be deprecated * nodejs 12 is being deprecated ... Rely on tests to make sure the actions still works * Fix as per CI results * Get rid of deprecated containers * Have a warningless run We're not testing rebar3 here, in any case	2022-10-19 21:51:01 +01:00
Paulo F. Oliveira	8d31e4db55	Allow version-type: strict + otp-version: master for Elixir -based builds (#144 ) * Check tests failing for something that should pass * Test with version-type: strict * Add more tests GitHub actions is refusing to run a given workflow :shrug * Try to fix new test that shouldn't be failing Which is exactly what we intended to originate by starting a new pull request. * Fix tests as per CI * Fix tests as per CI * Adapt to "latest" * Fix as per CI results Actions' window shows everything as Ok but then internals not Error when evaluating 'runs-on' for job 'integration_test'. .github/workflows/ubuntu.yml (Line: 19, Col: 14): Unexpected type of value '', expected type: OneOf. Strange one, this one! * Try to "help" for non-OTP declared input We do this for OTP-, but not for maint- as the former is hopefully more common than the latter * Introduce `latest` to signify `master` Semantically they're similar, but with `latest` we know: 1. to fetch Elixir's no-otp-... version 2. to fetch Erlang's master whereas with 25 (latest at this moment) we'd try to fetch elixirvsn-otp-25 which could fail with Elixir master and version-type strict * Fix as per CI Still not 100% convinced that `latest` should be separate from `master` but I want to know how tests run, in this case in particular * Fix as per CI * Fix as per CI * Revert potential wrong decision * Fix as per understand recent Elixir changes (namely master v. main) * Try to simplify it We introduce the concept of version v. branch (as per @ericmj) and we use that to find the most appropriate Erlang/Elixir combo.	2022-10-19 21:10:26 +01:00
github-actions[bot]	4c52669fda	Update 3rd party licenses (#145 ) Co-authored-by: GitHub Actions <actions@user.noreply.github.com>	2022-10-11 13:20:09 +01:00
github-actions[bot]	6a5f23a6f0	Update 3rd party licenses (#143 ) Co-authored-by: GitHub Actions <actions@user.noreply.github.com>	2022-09-23 13:40:49 +01:00
Wojtek Mach	8bfa104bdd	Test environment variables are set (#142 )	2022-09-16 20:01:17 +02:00
Wojtek Mach	d85df626dd	Fix setting INSTALL_DIR_FOR_OTP (#141 )	2022-09-16 10:28:57 +02:00
Paulo F. Oliveira	6b2f8153b4	Crash on invalid Elixir+OTP combo (#134 ) * Prevent "future" errors when choosing incompatible Elixir v. OTP versions * Fix tests as per GitHub Actions' output * Make test elixir `master` strict It has no -otp- in the name	2022-09-13 08:21:46 +01:00
Wojtek Mach	7dd0d763a8	Install OTP on Windows to a local directory (#139 )	2022-09-12 16:40:00 +02:00
Louis Pilfold	ee0fa0b672	Update for latest Gleam (#138 ) * Update for latest Gleam - Gleam releases now use LLVM triplets for platforms so the download URLs have been updated accordingly. - Gleam's rebar3 support has been removed. This change means that future versions of this action cannot download older versions of Gleam. I can make it backwards compatible, but I will need help from someone who can convert the shell script into PowerShell for Windows. * Support older Gleam versions * Remove rebar from Gleam	2022-09-12 15:35:29 +01:00
github-actions[bot]	4518ce17a4	Update 3rd party licenses (#135 ) Co-authored-by: GitHub Actions <actions@user.noreply.github.com>	2022-08-22 14:19:29 +01:00
dependabot[bot]	1fddfab461	Bump @actions/core from 1.6.0 to 1.9.1 (#133 ) * Bump @actions/core from 1.6.0 to 1.9.1 Bumps [@actions/core](https://github.com/actions/toolkit/tree/HEAD/packages/core) from 1.6.0 to 1.9.1. - [Release notes](https://github.com/actions/toolkit/releases) - [Changelog](https://github.com/actions/toolkit/blob/main/packages/core/RELEASES.md) - [Commits](https://github.com/actions/toolkit/commits/HEAD/packages/core) --- updated-dependencies: - dependency-name: "@actions/core" dependency-type: direct:production ... Signed-off-by: dependabot[bot] <support@github.com> * Update what dependabot didn't Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: Paulo F. Oliveira <paulo.ferraz.oliveira@gmail.com>	2022-08-22 11:20:01 +01:00
github-actions[bot]	6942ea249f	Update 3rd party licenses (#132 ) Co-authored-by: GitHub Actions <actions@user.noreply.github.com>	2022-08-22 11:11:31 +01:00