Fix failing CI (#87)

Otherwise it is difficult to know that the erlef/setup-beam matchers are
what is creating the warning/error annotations on PR's

.eslintrc.yml

@@ -6,14 +6,17 @@ extends:
   - airbnb
 parserOptions:
   ecmaVersion: 12
-rules: {
+rules:
-  indent: ["warn", 2],
+  indent: ["warn", 2]
-  max-len: ["warn", 100],
+  max-len: ["warn", 100]
-  no-console: 0,
+  no-console: 0
-  no-undef: "error",
+  no-undef: "error"
-  no-unused-vars: ["error", {"varsIgnorePattern": "^_"}],
+  no-unused-vars: ["error", {"varsIgnorePattern": "^_"}]
-  no-use-before-define: 0,
+  no-use-before-define: 0
-  operator-linebreak: 0,
+  operator-linebreak: 0
-  require-jsdoc: 0,
+  require-jsdoc: 0
   semi: 0
-}
+
+settings:
+  react:
+    version: 999.999.999

.github/elixir-matchers.json

@@ -41,6 +41,38 @@
           "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
+        }
+      ]
+    },
+    {
+      "owner": "elixir-dialyzerOutputDefault",
+      "severity": "warning",
+      "pattern": [
+        {
+          "regexp": "^(.*):(\\d+):(.*)",
+          "file": 1,
+          "line": 2,
+          "code": 3
+        },
+        {
+          "regexp": "^(.*)$",
+          "message": 1
+        }
+      ]
     }
   ]
 }

.github/workflows/action.yml

@@ -1,5 +1,5 @@
 ---
-name: ci
+name: action
 
 on:
   push:
@@ -11,22 +11,44 @@ on:
 
 jobs:
   check_integrity:
-    name: Make sure expected pre-release actions are performed
+    name: Expected local npm actions
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
       - uses: actions/setup-node@v1
         with:
-          node-version: '12'
+          node-version: '14'
       - run: npm install -g npm
       - run: npm install
       - run: npm run build
+      - run: npm run format
       - run: npm install -g markdownlint-cli
       - run: npm run markdownlint
       - run: npm run shellcheck
       - run: npm run yamllint
       - run: npm run jslint
       - run: npm run licenses
-      - run: npm run format
       - name: Check if build left artifacts
         run: git diff --exit-code
+
+  unit_tests_ubuntu:
+    name: Unit tests (Ubuntu)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v1
+        with:
+          node-version: '14'
+      - run: npm ci
+      - run: npm test
+
+  unit_tests_windows:
+    name: Unit tests (Windows)
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v1
+        with:
+          node-version: '14'
+      - run: npm install --production
+      - run: npm test

.github/workflows/ubuntu.yml

@@ -1,59 +1,39 @@
 ---
-name: test
+name: ubuntu
 
 on:
-  push: {branches: main}
+  push:
-  pull_request: {branches: main}
+    branches:
-  repository_dispatch:
+      - main
-  workflow_dispatch:
+  pull_request:
+    branches:
+      - main
 
 jobs:
-  unit_test:
-    name: Pre-release unit tests
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v1
-        with: {node-version: '12'}
-      - run: npm ci
-      - run: npm test
-
   integration_test:
     name: >
-      Pre-release integration tests
+      OTP ${{matrix.combo.otp-version}},
-      (Ubuntu ${{matrix.combo.os}},
+      Elixir ${{matrix.combo.elixir-version}},
-       Erlang/OTP ${{matrix.combo.otp-version}},
+      Gleam ${{matrix.combo.gleam-version}},
-       Elixir ${{matrix.combo.elixir-version}},
+      rebar3 ${{matrix.combo.rebar3-version}}
-       rebar3 ${{matrix.combo.rebar3-version}})
     runs-on: ${{matrix.combo.os}}
     strategy:
       fail-fast: false
       matrix:
         combo:
-          - elixir-version: 'v1.0'
+          - otp-version: '24'
-            otp-version: '17'
+            rebar3-version: 'nightly'
-            os: 'ubuntu-16.04'
+            os: 'ubuntu-latest'
           - elixir-version: 'v1.0'
             otp-version: '17'
             os: 'ubuntu-18.04'
-          - elixir-version: 'v1.1'
-            otp-version: '18'
-            os: 'ubuntu-16.04'
           - elixir-version: 'v1.1'
             otp-version: '18'
             os: 'ubuntu-18.04'
-          - elixir-version: 'v1.2'
-            otp-version: '19'
-            rebar3-version: '3.10'
-            os: 'ubuntu-16.04'
           - elixir-version: 'v1.2'
             otp-version: '19'
             rebar3-version: '3.10'
             os: 'ubuntu-18.04'
-          - elixir-version: 'v1.4'
-            otp-version: '20'
-            rebar3-version: '3.11'
-            os: 'ubuntu-16.04'
           - elixir-version: 'v1.4'
             otp-version: '20'
             rebar3-version: '3.6.0'
@@ -62,10 +42,6 @@ jobs:
             otp-version: '20'
             rebar3-version: '3.11'
             os: 'ubuntu-20.04'
-          - elixir-version: 'v1.6'
-            otp-version: '21'
-            rebar3-version: '3.12'
-            os: 'ubuntu-16.04'
           - elixir-version: 'v1.6'
             otp-version: '21'
             rebar3-version: '3.12'
@@ -74,10 +50,6 @@ jobs:
             otp-version: '21'
             rebar3-version: '3.12'
             os: 'ubuntu-20.04'
-          - elixir-version: 'v1.7'
-            otp-version: '22'
-            rebar3-version: '3.13'
-            os: 'ubuntu-16.04'
           - elixir-version: 'v1.7'
             otp-version: '22'
             rebar3-version: '3.13'
@@ -86,10 +58,6 @@ jobs:
             otp-version: '22'
             rebar3-version: '3.13'
             os: 'ubuntu-20.04'
-          - elixir-version: 'v1.10'
-            otp-version: '23'
-            rebar3-version: '3.14'
-            os: 'ubuntu-16.04'
           - elixir-version: 'v1.10'
             otp-version: '23'
             rebar3-version: '3.14'
@@ -102,6 +70,30 @@ jobs:
             otp-version: '24'
             rebar3-version: '3.15'
             os: 'ubuntu-20.04'
+          - elixir-version: 'v1.11.0'
+            otp-version: '22.3.4.2'
+            os: 'ubuntu-20.04'
+            version-type: 'strict'
+          - elixir-version: '1.10.3'
+            otp-version: '22.3.4.1'
+            os: 'ubuntu-20.04'
+            version-type: 'strict'
+          - elixir-version: '1.10.3'
+            otp-version: '22.3.4.1'
+            os: 'ubuntu-20.04'
+          - elixir-version: 'master'
+            otp-version: '23.1'
+            os:  'ubuntu-20.04'
+          - gleam-version: '0.16'
+            otp-version: '24'
+            rebar3-version: '3.16'
+            os: 'ubuntu-latest'
+          - gleam-version: '0.19.0-rc3'
+            otp-version: '24'
+            os: 'ubuntu-latest'
+          - gleam-version: '0.19.0-rc3'
+            otp-version: false
+            os: 'ubuntu-latest'
     steps:
       - uses: actions/checkout@v2
       - name: Use erlef/setup-beam
@@ -110,12 +102,18 @@ jobs:
         with:
           otp-version: ${{matrix.combo.otp-version}}
           elixir-version: ${{matrix.combo.elixir-version}}
+          gleam-version: ${{matrix.combo.gleam-version}}
           rebar3-version: ${{matrix.combo.rebar3-version}}
+          version-type: ${{matrix.combo.version-type}}
       - name: Erlang/OTP version (action)
         run: echo "Erlang/OTP ${{steps.setup-beam.outputs.otp-version}}"
+        if: ${{matrix.combo.otp-version}}
       - name: Elixir version (action)
         run: echo "Elixir ${{steps.setup-beam.outputs.elixir-version}}"
         if: ${{matrix.combo.elixir-version}}
+      - name: Gleam version (action)
+        run: echo "Gleam ${{steps.setup-beam.outputs.gleam-version}}"
+        if: ${{matrix.combo.gleam-version}}
       - name: rebar3 version (action)
         run: echo "rebar3 ${{steps.setup-beam.outputs.rebar3-version}}"
         if: ${{matrix.combo.rebar3-version}}
@@ -125,14 +123,29 @@ jobs:
           mix help local.rebar
           mix help local.hex
         if: ${{matrix.combo.elixir-version}}
-      - name: Run Mix project tests
+      - name: Run Elixir/Mix project tests
         run: |
-          cd test-projects/mix
+          cd test-projects/elixir_mix
           mix deps.get
           mix test
         if: ${{matrix.combo.elixir-version}}
-      - name: Run rebar3 project tests
+      - name: Run Erlang/rebar3 project tests
         run: |
-          cd test-projects/rebar3
+          cd test-projects/erlang_rebar3
           rebar3 ct
         if: ${{matrix.combo.rebar3-version}}
+      - name: Run Gleam/rebar3 project tests
+        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
+        if: ${{ matrix.combo.gleam-version && !matrix.combo.otp-version }}
+      - name: Run Gleam project tests (without `rebar3`)
+        run: |
+          cd test-projects/gleam_gleam
+          gleam test
+        if: ${{ matrix.combo.gleam-version && matrix.combo.otp-version && !matrix.combo.rebar3-version }}

.github/workflows/update_3rd_party_licenses.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+
+set -eux
+
+git config user.name "GitHub Actions"
+git config user.email "actions@user.noreply.github.com"
+git checkout main
+
+npm run licenses
+
+git add 3RD_PARTY_LICENSES
+git commit -m "Update 3rd party licenses" || true
+git push origin

.github/workflows/update_3rd_party_licenses.yml

@@ -0,0 +1,19 @@
+---
+name: update_3rd_party_licenses
+
+on:
+  schedule:
+    - cron: '0 12 * * *'
+  workflow_dispatch:
+
+jobs:
+  update:
+    name: Update 3rd party licenses
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v1
+        with:
+          node-version: '14'
+      - run:
+          ./.github/workflows/update_3rd_party_licenses.sh

.github/workflows/windows.yml

@@ -0,0 +1,86 @@
+---
+name: windows
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  integration_test:
+    name: >
+      OTP ${{matrix.combo.otp-version}},
+      Elixir ${{matrix.combo.elixir-version}},
+      Gleam ${{matrix.combo.gleam-version}},
+      rebar3 ${{matrix.combo.rebar3-version}}
+    runs-on: ${{matrix.combo.os}}
+    strategy:
+      fail-fast: false
+      matrix:
+        combo:
+          - otp-version: '24.0.2'
+            rebar3-version: '3.16'
+            os: 'windows-2019'
+          - otp-version: '24.0.2'
+            rebar3-version: 'nightly'
+            os: 'windows-2019'
+          - otp-version: '23.0'
+            rebar3-version: '3.15'
+            os: 'windows-2019'
+          - elixir-version: 'v1.10'
+            otp-version: '23'
+            rebar3-version: '3.14'
+            os: 'windows-latest'
+          - elixir-version: 'v1.11'
+            otp-version: '24'
+            rebar3-version: '3.15'
+            os: 'windows-latest'
+          - gleam-version: '0.16'
+            otp-version: '24'
+            rebar3-version: '3.16'
+            os: 'windows-latest'
+    steps:
+      - uses: actions/checkout@v2
+      - name: Use erlef/setup-beam
+        id: setup-beam
+        uses: ./
+        with:
+          otp-version: ${{matrix.combo.otp-version}}
+          elixir-version: ${{matrix.combo.elixir-version}}
+          gleam-version: ${{matrix.combo.gleam-version}}
+          rebar3-version: ${{matrix.combo.rebar3-version}}
+      - name: Erlang/OTP version (action)
+        run: echo "Erlang/OTP ${{steps.setup-beam.outputs.otp-version}}"
+      - name: Elixir version (action)
+        run: echo "Elixir ${{steps.setup-beam.outputs.elixir-version}}"
+        if: ${{matrix.combo.elixir-version}}
+      - name: Gleam version (action)
+        run: echo "Gleam ${{steps.setup-beam.outputs.gleam-version}}"
+        if: ${{matrix.combo.gleam-version}}
+      - name: rebar3 version (action)
+        run: echo "rebar3 ${{steps.setup-beam.outputs.rebar3-version}}"
+      - name: mix version and help (CLI)
+        run: |
+          mix -v
+          mix help local.rebar
+          mix help local.hex
+        if: ${{matrix.combo.elixir-version}}
+      - name: Run Elixir/Mix project tests
+        run: |
+          cd test-projects/elixir_mix
+          mix deps.get
+          mix test
+        if: ${{matrix.combo.elixir-version}}
+      - name: Run Erlang/rebar3 project tests
+        run: |
+          cd test-projects/erlang_rebar3
+          rebar3 ct
+        if: ${{matrix.combo.rebar3-version}}
+      - name: Run Gleam/rebar3 project tests
+        run: |
+          cd test-projects/gleam_rebar3
+          rebar3 eunit
+        if: ${{matrix.combo.gleam-version}}

README.md

@@ -1,88 +1,91 @@
 <!-- markdownlint-disable MD013 -->
-# setup-beam [![GitHub Actions Test][test-img]][test] [![GitHub Actions CI][ci-img]][ci]
+# setup-beam [![GitHub Actions][action-img]][action] [![GitHub Actions][ubuntu-img]][ubuntu] [![GitHub Actions][windows-img]][windows]
 
-[test]: https://github.com/erlef/setup-beam
+[action]: https://github.com/erlef/setup-beam
-[test-img]: https://github.com/erlef/setup-beam/workflows/test/badge.svg
+[action-img]: https://github.com/erlef/setup-beam/workflows/action/badge.svg
-[ci]: https://github.com/erlef/setup-beam
+[ubuntu]: https://github.com/erlef/setup-beam
-[ci-img]: https://github.com/erlef/setup-beam/workflows/ci/badge.svg
+[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
 
 This action sets up an Erlang/OTP environment for use in a GitHub Actions
 workflow by:
 
-- installing Erlang/OTP
+- installing [Erlang/OTP](https://www.erlang.org/)
-- optionally, installing Elixir
+- optionally, installing [Elixir](https://elixir-lang.org/)
-- optionally, installing `rebar3`
+- optionally, installing [Gleam](https://gleam.run/)
+- optionally, installing [`rebar3`](https://www.rebar3.org/)
+- optionally, installing [`hex`](https://hex.pm/)
+- optionally, having
+  [problem matchers](https://github.com/actions/toolkit/blob/main/docs/problem-matchers.md) show
+  warnings and errors on pull requestsotp-version: false)
 
-**Note** Currently, this action only supports Actions' `ubuntu-` runtimes.
+**Note**: currently, this action only supports Actions' `ubuntu-` and `windows-` runtimes.
 
 ## Usage
 
-See [action.yml](action.yml).
+See [action.yml](action.yml) for the action's specification.
 
-**Note** The Erlang/OTP release version specification is [relatively
+**Note**: the Erlang/OTP release version specification is [relatively
 complex](http://erlang.org/doc/system_principles/versions.html#version-scheme).
-For best results, we recommend specifying exact Erlang/OTP, Elixir versions, and
+For best results, we recommend specifying exact
-`rebar3` versions.
+versions, and setting option `version-type` to `strict`.
-However, values like `22.x` are also accepted, and we attempt to resolve them
+However, values like `22.x`, or even `>22`, are also accepted, and we attempt to resolve them
-according to semantic versioning rules.
+according to semantic versioning rules. This implicitly means `version-type` is `loose`,
+which is also the default value for this option.
 
-Additionally, it is recommended that one specifies Erlang/OTP, Elixir and `rebar3` versions
+Additionally, it is recommended that one specifies versions
 using YAML strings, as these examples do, so that numbers like `23.0` don't
 end up being parsed as `23`, which is not equivalent.
 
-For pre-release Elixir versions, such as `1.11.0-rc.0`, use the full version
+For pre-release versions, such as `v1.11.0-rc.0`, use the full version
-specifier (`1.11.0-rc.0`). Pre-release versions are opt-in, so `1.11.x` will
+specifier (`v1.11.0-rc.0`) and set option `version-type` to `strict`. Pre-release versions are
-not match a pre-release.
+opt-in, so `1.11.x` will not match a pre-release.
 
-### Compatibility between Ubuntu and Erlang/OTP
+### Compatibility between Operating System and Erlang/OTP
 
-This list presents the known working version combos between Ubuntu
+This list presents the known working version combos between the target operating system
 and Erlang/OTP.
 
-| Ubuntu       | Erlang/OTP | Status
+| Operating system | Erlang/OTP | Status
-|-             |-           |-
+|-                 |-           |-
-| ubuntu-16.04 | 17 - 23    | ✅
+| ubuntu-18.04     | 17 - 24    | ✅
-| ubuntu-18.04 | 17 - 23    | ✅
+| ubuntu-20.04     | 20 - 24    | ✅
-| ubuntu-20.04 | 20 - 23    | ✅
+| windows-2019     | 21* - 24   | ✅
 
-### Basic example (Elixir)
+**Note** *: prior to 23, Windows builds are only available for minor versions, e.g. 21.0, 21.3, 22.0, etc.
+
+### Self-hosted runners
+
+Self-hosted runners need to set env. variable `ImageOS` to one of the following, since the action
+uses that to download assets:
+
+| ImageOS  | Operating system
+|-         |-
+| ubuntu18 | ubuntu-18.04
+| ubuntu20 | ubuntu-20.04
+| win19    | windows-2019
+
+as per the following example:
 
 ```yaml
-on: push
+...
 
 jobs:
   test:
-    runs-on: ubuntu-latest
+    runs-on: self-hosted
+    env:
+      ImageOS: ubuntu20 # equivalent to runs-on ubuntu-20.04
     steps:
       - uses: actions/checkout@v2
       - uses: erlef/setup-beam@v1
-        with:
+        ...
-          otp-version: '22.2'
-          elixir-version: '1.9.4'
-      - run: mix deps.get
-      - run: mix test
 ```
 
-### Basic example (`rebar3`)
+### Example (Erlang/OTP + Elixir, on Ubuntu)
-
-```yaml
-on: push
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: erlef/setup-beam@v1
-        with:
-          otp-version: '22.2'
-          rebar3-version: '3.14.2'
-      - run: rebar3 ct
-```
-
-### Matrix example (Elixir)
 
 ```yaml
+# create this in .github/workflows/ci.yml
 on: push
 
 jobs:
@@ -103,9 +106,10 @@ jobs:
       - run: mix test
 ```
 
-### Matrix example (`rebar3`)
+### Example (Erlang/OTP + `rebar3`, on Ubuntu)
 
 ```yaml
+# create this in .github/workflows/ci.yml
 on: push
 
 jobs:
@@ -125,69 +129,79 @@ jobs:
       - run: rebar3 ct
 ```
 
-### Phoenix example
+### Example (Erlang/OTP + `rebar3`, on Windows)
 
 ```yaml
+# create this in .github/workflows/ci.yml
+on: push
+
+jobs:
+  test:
+    runs-on: windows-2019
+    steps:
+      - uses: actions/checkout@v2
+      - uses: erlef/setup-beam@v1
+        with:
+          otp-version: '24'
+          rebar3-version: '3.16.1'
+      - run: rebar3 ct
+```
+
+### Example (Gleam on Ubuntu)
+
+```yaml
+# create this in .github/workflows/ci.yml
 on: push
 
 jobs:
   test:
     runs-on: ubuntu-latest
-
-    services:
-      db:
-        image: postgres:11
-        ports: ['5432:5432']
-        env:
-          POSTGRES_PASSWORD: postgres
-        options: >-
-          --health-cmd pg_isready
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
-
     steps:
       - uses: actions/checkout@v2
       - uses: erlef/setup-beam@v1
         with:
-          otp-version: '22.2'
+          otp-version: '24'
-          elixir-version: '1.9.4'
+          gleam-version: '0.19.0-rc3'
-      - run: mix deps.get
+      - run: gleam test
-      - run: mix test
 ```
 
-#### Authenticating with Postgres in Phoenix
+### Example (Gleam on Ubuntu without OTP)
 
-When using the Phoenix example above, the `postgres` container has some
+```yaml
-default authentication set up. Specifically, it expects a username of
+# create this in .github/workflows/ci.yml
-"postgres", and a password of "postgres". It will be available at
+on: push
-`localhost:5432`.
 
-The simplest way of setting these auth values in CI is by checking for the
+jobs:
-`GITHUB_ACTIONS` environment variable that is set in all workflows:
+  test:
-
+    runs-on: ubuntu-latest
-```elixir
+    steps:
-# config/test.exs
+      - uses: actions/checkout@v2
-
+      - uses: erlef/setup-beam@v1
-use Mix.Config
+        with:
-
+          otp-version: false
-# Configure the database for local testing
+          gleam-version: '0.19.0-rc3'
-config :app, App.Repo,
+      - run: gleam check
-  database: "my_app_test",
-  hostname: "localhost",
-  pool: Ecto.Adapters.SQL.Sandbox
-
-# Configure the database for GitHub Actions
-if System.get_env("GITHUB_ACTIONS") do
-  config :app, App.Repo,
-    username: "postgres",
-    password: "postgres"
-end
 ```
 
+**Note**: the `otp-version: false` input is only applicable when installing Gleam.
+
 ## Elixir Problem Matchers
 
-The Elixir Problem Matchers in this repository are adapted from [here](https://github.com/fr1zle/vscode-elixir/blob/45eddb589acd7ac98e0c7305d1c2b24668ca709a/package.json#L70-L118). See [MATCHER_NOTICE](MATCHER_NOTICE.md) for license details.
+The Elixir Problem Matchers in this repository are adapted from
+[here](https://github.com/fr1zle/vscode-elixir/blob/45eddb589acd7ac98e0c7305d1c2b24668ca709a/package.json#L70-L118).
+See [MATCHER_NOTICE](MATCHER_NOTICE.md) for license details.
+
+## Action versioning
+
+`setup-beam` has three version paths, described below, for example version `1.8.0`:
+
+- `@v1`: the latest in the `1.y.z` series (this tag is movable),
+- `@v1.8`: the latest in the `1.8.z` series (this tag is movable),
+- `@v1.8.0`: release `1.8.0` (this tag is not movable).
+
+We make a real effort to not introduce incompatibilities without changing the major
+version number. To be extra safe against changes causing issues in your CI you should specify
+an exact version with `@vx.y.z`.
 
 ## License
 

__tests__/problem-matchers.test.js

@@ -0,0 +1,100 @@
+const assert = require('assert')
+const { problemMatcher } = require('../.github/elixir-matchers.json')
+
+async function all() {
+  await testElixirMixCompileError()
+  await testElixirMixCompileWarning()
+  await testElixirMixTestFailure()
+  await testElixirCredoOutputDefault()
+  await testElixirDialyzerOutputDefault()
+}
+
+async function testElixirMixCompileError() {
+  const [matcher] = problemMatcher.find(
+    ({ owner }) => owner === 'elixir-mixCompileError',
+  ).pattern
+
+  const output = '** (CompileError) lib/test.ex:16: undefined function err/0'
+  const [message, , file, line] = output.match(matcher.regexp)
+  assert.equal(file, 'lib/test.ex')
+  assert.equal(line, '16')
+  assert.equal(message, output)
+}
+
+async function testElixirMixCompileWarning() {
+  const [messagePattern, filePattern] = problemMatcher.find(
+    ({ owner }) => owner === 'elixir-mixCompileWarning',
+  ).pattern
+
+  const firstOutput =
+    'warning: variable "err" does not exist and is being expanded to "err()"'
+  const secondOutput = '  lib/test.ex:16: Test.hello/0'
+
+  const [, message] = firstOutput.match(messagePattern.regexp)
+  assert.equal(
+    message,
+    'variable "err" does not exist and is being expanded to "err()"',
+  )
+
+  const [, file, line] = secondOutput.match(filePattern.regexp)
+  assert.equal(file, 'lib/test.ex')
+  assert.equal(line, '16')
+}
+
+async function testElixirMixTestFailure() {
+  const [messagePattern, filePattern] = problemMatcher.find(
+    ({ owner }) => owner === 'elixir-mixTestFailure',
+  ).pattern
+
+  const firstOutput = '1) test throws (TestTest)'
+  const secondOutput = '  test/test_test.exs:9'
+
+  const [, message] = firstOutput.match(messagePattern.regexp)
+  assert.equal(message, 'test throws (TestTest)')
+
+  const [, file, line] = secondOutput.match(filePattern.regexp)
+  assert.equal(file, 'test/test_test.exs')
+  assert.equal(line, '9')
+}
+
+async function testElixirCredoOutputDefault() {
+  const [messagePattern, filePattern] = problemMatcher.find(
+    ({ owner }) => owner === 'elixir-credoOutputDefault',
+  ).pattern
+
+  const firstOutput = '┃ [F] → Function is too complex (CC is 29, max is 9).'
+  const secondOutput = '┃       lib/test.ex:15:7 #(Test.hello)'
+
+  const [, message] = firstOutput.match(messagePattern.regexp)
+  assert.equal(message, 'Function is too complex (CC is 29, max is 9).')
+
+  const [, file, line, column] = secondOutput.match(filePattern.regexp)
+  assert.equal(file, 'lib/test.ex')
+  assert.equal(line, '15')
+  assert.equal(column, '7')
+}
+
+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)
+    process.exit(1)
+  })

__tests__/setup-beam.test.js

@@ -5,17 +5,21 @@ simulateInput('install-rebar', 'true')
 simulateInput('install-hex', 'true')
 
 const assert = require('assert')
-const setupElixir = require('../src/setup-beam')
+const setupBeam = require('../src/setup-beam')
 const installer = require('../src/installer')
 
 async function all() {
   await testFailInstallOTP()
   await testFailInstallElixir()
+  await testFailInstallGleam()
   await testFailInstallRebar3()
 
   await testOTPVersions()
   await testElixirVersions()
+  await testGleamVersions()
   await testRebar3Versions()
+
+  await testGetVersionFromSpec()
 }
 
 async function testFailInstallOTP() {
@@ -61,6 +65,20 @@ async function testFailInstallElixir() {
   )
 }
 
+async function testFailInstallGleam() {
+  const gleamVersion = '0.1.3'
+  assert.rejects(
+    async () => {
+      await installer.installGleam(gleamVersion)
+    },
+    (err) => {
+      assert.ok(err instanceof Error)
+      return true
+    },
+    `Installing Gleam ${gleamVersion} is supposed to fail`,
+  )
+}
+
 async function testFailInstallRebar3() {
   const r3Version = '0.14.4'
   assert.rejects(
@@ -81,47 +99,69 @@ async function testOTPVersions() {
   let spec
   let osVersion
 
-  spec = '19.3.x'
+  if (process.platform === 'linux') {
-  osVersion = 'ubuntu-16.04'
+    spec = '19.3.x'
-  expected = 'OTP-19.3.6'
+    osVersion = 'ubuntu-16.04'
-  got = await setupElixir.getOTPVersion(spec, osVersion)
+    expected = 'OTP-19.3.6.13'
-  assert.deepStrictEqual(got, expected)
+    got = await setupBeam.getOTPVersion(spec, osVersion)
+    assert.deepStrictEqual(got, expected)
 
-  spec = '^19.3.6'
+    spec = '^19.3.6'
-  osVersion = 'ubuntu-16.04'
+    osVersion = 'ubuntu-16.04'
-  expected = 'OTP-19.3.6'
+    expected = 'OTP-19.3.6.13'
-  got = await setupElixir.getOTPVersion(spec, osVersion)
+    got = await setupBeam.getOTPVersion(spec, osVersion)
-  assert.deepStrictEqual(got, expected)
+    assert.deepStrictEqual(got, expected)
 
-  spec = '^19.3'
+    spec = '^19.3'
-  osVersion = 'ubuntu-18.04'
+    osVersion = 'ubuntu-18.04'
-  expected = 'OTP-19.3.6'
+    expected = 'OTP-19.3.6.13'
-  got = await setupElixir.getOTPVersion(spec, osVersion)
+    got = await setupBeam.getOTPVersion(spec, osVersion)
-  assert.deepStrictEqual(got, expected)
+    assert.deepStrictEqual(got, expected)
 
-  spec = '20'
+    spec = '20'
-  osVersion = 'ubuntu-20.04'
+    osVersion = 'ubuntu-20.04'
-  expected = 'OTP-20.3.8'
+    expected = 'OTP-20.3.8.26'
-  got = await setupElixir.getOTPVersion(spec, osVersion)
+    got = await setupBeam.getOTPVersion(spec, osVersion)
-  assert.deepStrictEqual(got, expected)
+    assert.deepStrictEqual(got, expected)
 
-  spec = '20.x'
+    spec = '20.x'
-  osVersion = 'ubuntu-20.04'
+    osVersion = 'ubuntu-20.04'
-  expected = 'OTP-20.3.8'
+    expected = 'OTP-20.3.8.26'
-  got = await setupElixir.getOTPVersion(spec, osVersion)
+    got = await setupBeam.getOTPVersion(spec, osVersion)
-  assert.deepStrictEqual(got, expected)
+    assert.deepStrictEqual(got, expected)
 
-  spec = '20.0'
+    spec = '20.0'
-  osVersion = 'ubuntu-20.04'
+    osVersion = 'ubuntu-20.04'
-  expected = 'OTP-20.0.5'
+    expected = 'OTP-20.0.5'
-  got = await setupElixir.getOTPVersion(spec, osVersion)
+    got = await setupBeam.getOTPVersion(spec, osVersion)
-  assert.deepStrictEqual(got, expected)
+    assert.deepStrictEqual(got, expected)
 
-  spec = '20.0.x'
+    spec = '20.0.x'
-  osVersion = 'ubuntu-20.04'
+    osVersion = 'ubuntu-20.04'
-  expected = 'OTP-20.0.5'
+    expected = 'OTP-20.0.5'
-  got = await setupElixir.getOTPVersion(spec, osVersion)
+    got = await setupBeam.getOTPVersion(spec, osVersion)
-  assert.deepStrictEqual(got, expected)
+    assert.deepStrictEqual(got, expected)
+  }
+
+  if (process.platform === 'win32') {
+    spec = '24.0.1'
+    osVersion = 'windows-latest'
+    expected = '24.0.1'
+    got = await setupBeam.getOTPVersion(spec, osVersion)
+    assert.deepStrictEqual(got, expected)
+
+    spec = '23.2.x'
+    osVersion = 'windows-2016'
+    expected = '23.2.7'
+    got = await setupBeam.getOTPVersion(spec, osVersion)
+    assert.deepStrictEqual(got, expected)
+
+    spec = '23.0'
+    osVersion = 'windows-2019'
+    expected = '23.0.4'
+    got = await setupBeam.getOTPVersion(spec, osVersion)
+    assert.deepStrictEqual(got, expected)
+  }
 }
 
 async function testElixirVersions() {
@@ -133,20 +173,71 @@ async function testElixirVersions() {
   spec = '1.1.x'
   otpVersion = 'OTP-23'
   expected = 'v1.1.1'
-  got = await setupElixir.getElixirVersion(spec, otpVersion)
+  got = await setupBeam.getElixirVersion(spec, otpVersion)
   assert.deepStrictEqual(got, expected)
 
   spec = '1.10.4'
   otpVersion = 'OTP-23'
   expected = 'v1.10.4-otp-23'
-  got = await setupElixir.getElixirVersion(spec, otpVersion)
+  got = await setupBeam.getElixirVersion(spec, otpVersion)
   assert.deepStrictEqual(got, expected)
 
-  spec = '1.11.0-rc.0'
+  spec = '1.12.1'
+  otpVersion = 'OTP-24.0.2'
+  expected = 'v1.12.1-otp-24'
+  got = await setupBeam.getElixirVersion(spec, otpVersion)
+  assert.deepStrictEqual(got, expected)
+
+  simulateInput('version-type', 'strict')
+  spec = 'v1.11.0-rc.0'
   otpVersion = 'OTP-23'
   expected = 'v1.11.0-rc.0-otp-23'
-  got = await setupElixir.getElixirVersion(spec, otpVersion)
+  got = await setupBeam.getElixirVersion(spec, otpVersion)
   assert.deepStrictEqual(got, expected)
+  simulateInput('version-type', 'loose')
+
+  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)
+  assert.deepStrictEqual(got, expected)
+  simulateInput('version-type', 'loose')
+
+  simulateInput('version-type', 'strict')
+  spec = 'master'
+  otpVersion = '23.1'
+  expected = 'master-otp-23'
+  got = await setupBeam.getElixirVersion(spec, otpVersion)
+  assert.deepStrictEqual(got, expected)
+  simulateInput('version-type', 'loose')
+}
+
+async function testGleamVersions() {
+  let got
+  let expected
+  let spec
+  let otpVersion
+
+  spec = 'v0.3.0'
+  otpVersion = 'OTP-23'
+  expected = 'v0.3.0'
+  got = await setupBeam.getGleamVersion(spec, otpVersion)
+  assert.deepStrictEqual(got, expected)
+
+  spec = '0.13.2'
+  otpVersion = 'OTP-24'
+  expected = 'v0.13.2'
+  got = await setupBeam.getGleamVersion(spec, otpVersion)
+  assert.deepStrictEqual(got, expected)
+
+  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')
 }
 
 async function testRebar3Versions() {
@@ -156,20 +247,156 @@ async function testRebar3Versions() {
 
   spec = '3.10.x'
   expected = '3.10.0'
-  got = await setupElixir.getRebar3Version(spec)
+  got = await setupBeam.getRebar3Version(spec)
   assert.deepStrictEqual(got, expected)
 
-  spec = '3.10.0'
+  spec = '3.11'
-  expected = '3.10.0'
+  expected = '3.11.1'
-  got = await setupElixir.getRebar3Version(spec)
+  got = await setupBeam.getRebar3Version(spec)
   assert.deepStrictEqual(got, expected)
 
   spec = '3.10'
   expected = '3.10.0'
-  got = await setupElixir.getRebar3Version(spec)
+  got = await setupBeam.getRebar3Version(spec)
   assert.deepStrictEqual(got, expected)
 }
 
+async function testGetVersionFromSpec() {
+  let got
+  let expected
+  let spec
+  const versions = [
+    '3.2.30.5',
+    '3.2.3.5',
+    '1',
+    '2',
+    '3.2.3.4.1',
+    '1.0.9',
+    '3.2.3.40.1',
+    '1.0.2',
+    '2.0',
+    '2.10',
+    '2.9',
+    '1.0',
+    '3.2.3.4.2',
+    '1.1.0',
+    '3.4.5.4',
+    '3.4.5.3',
+    '3.4.5.4.1',
+    '24.0-rc3',
+    '24.0-rc2',
+    '24.0',
+    '23.3.4',
+    '23.3.3',
+    '22.3.4.9.1',
+    '22.3.4.12.1',
+    '22.3.4.10.1',
+    'master',
+    'v11.11.0-rc.0-otp-23',
+    '22.3.4.2',
+  ]
+
+  spec = '1'
+  expected = '1.1.0'
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+
+  spec = '1.0'
+  expected = '1.0.9'
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+
+  simulateInput('version-type', 'strict')
+  spec = '1'
+  expected = '1'
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+  simulateInput('version-type', 'loose')
+
+  simulateInput('version-type', 'strict')
+  spec = '1.0'
+  expected = '1.0'
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+  simulateInput('version-type', 'loose')
+
+  spec = '2'
+  expected = '2.10'
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+
+  spec = '3'
+  expected = '3.4.5.4.1'
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+
+  spec = '3.2'
+  expected = '3.2.30.5'
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+
+  spec = '>20'
+  expected = '24.0'
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+
+  spec = '24.0'
+  expected = '24.0'
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+
+  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')
+
+  spec = '24.0-rc2'
+  expected = '24.0-rc2'
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+
+  spec = '22.3'
+  expected = '22.3.4.12.1'
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+
+  spec = '23.3.3'
+  expected = '23.3.3'
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+
+  spec = '24'
+  expected = '24.0'
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+
+  spec = '23.3'
+  expected = '23.3.4'
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+
+  simulateInput('version-type', 'strict')
+  spec = 'master'
+  expected = 'master'
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+  simulateInput('version-type', 'loose')
+
+  spec = 'master'
+  expected = 'master'
+  got = setupBeam.getVersionFromSpec(spec, versions)
+  assert.deepStrictEqual(got, expected)
+
+  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')
+}
+
 function simulateInput(key, value) {
   process.env[`INPUT_${key.replace(/ /g, '_').toUpperCase()}`] = value
 }

action.yml

@@ -1,5 +1,5 @@
 ---
-name: Setup Erlang/OTP with optional Elixir and/or rebar3
+name: Setup Erlang/OTP with optional Elixir (and mix) and/or rebar3
 description: >
   Set up a specific version of Erlang/OTP, Elixir, and/or rebar3
   and add the command-line tools to the PATH
@@ -8,23 +8,38 @@ branding:
   color: blue
   icon: code
 inputs:
+  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
-  otp-version:
+  gleam-version:
-    description: Version range or exact version of Erlang/OTP to use
+    description: Version range or exact version of Gleam to use
   install-hex:
-    description: Whether to install Hex
+    description: Whether to install Hex (with mix local.hex
+      when installing Elixir)
     default: true
   install-rebar:
-    description: Whether to install Rebar
+    description: Whether to install Rebar (with mix local.rebar
+      when installing Elixir)
     default: true
   rebar3-version:
-    description: Version range or exact version of rebar3 to use
+    description: Version range or exact version of rebar3 to use (or nightly)
+  version-type:
+    description: strict means the versions are take as-are; loose means we try
+      to guess versions based on semver rules
+    default: loose
+  disable_problem_matchers:
+    description: whether to have the problem matchers present in the results (or not)
+    default: false
 outputs:
   elixir-version:
     description: Exact version of Elixir that was installed
   otp-version:
     description: Exact version of Erlang/OTP that was installed
+  gleam-version:
+    description: Exact version of Gleam that was installed
   rebar3-version:
     description: Exact version of rebar3 that was installed
 runs:

dist/.github/elixir-matchers.json

@@ -41,6 +41,38 @@
           "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
+        }
+      ]
+    },
+    {
+      "owner": "elixir-dialyzerOutputDefault",
+      "severity": "warning",
+      "pattern": [
+        {
+          "regexp": "^(.*):(\\d+):(.*)",
+          "file": 1,
+          "line": 2,
+          "code": 3
+        },
+        {
+          "regexp": "^(.*)$",
+          "message": 1
+        }
+      ]
     }
   ]
 }

dist/index.js

@@ -4594,7 +4594,13 @@ const path = __nccwpck_require__(5622)
  * @param {string} otpVersion
  */
 async function installOTP(osVersion, otpVersion) {
-  await exec(__nccwpck_require__.ab + "install-otp", [osVersion, otpVersion])
+  const OS = process.platform
+  if (OS === 'linux') {
+    await exec(__nccwpck_require__.ab + "install-otp.sh", [osVersion, otpVersion])
+  } else if (OS === 'win32') {
+    const script = __nccwpck_require__.ab + "install-otp.ps1"
+    await exec(`pwsh.exe ${script} -VSN:${otpVersion}`)
+  }
 }
 
 /**
@@ -4603,7 +4609,28 @@ async function installOTP(osVersion, otpVersion) {
  * @param {string} elixirVersion
  */
 async function installElixir(elixirVersion) {
-  await exec(__nccwpck_require__.ab + "install-elixir", [elixirVersion])
+  const OS = process.platform
+  if (OS === 'linux') {
+    await exec(__nccwpck_require__.ab + "install-elixir.sh", [elixirVersion])
+  } else if (OS === 'win32') {
+    const script = __nccwpck_require__.ab + "install-elixir.ps1"
+    await exec(`pwsh.exe ${script} -VSN:${elixirVersion}`)
+  }
+}
+
+/**
+ * Install Gleam.
+ *
+ * @param {string} gleamVersion
+ */
+async function installGleam(gleamVersion) {
+  const OS = process.platform
+  if (OS === 'linux') {
+    await exec(__nccwpck_require__.ab + "install-gleam.sh", [gleamVersion])
+  } else if (OS === 'win32') {
+    const script = __nccwpck_require__.ab + "install-gleam.ps1"
+    await exec(`pwsh.exe ${script} -VSN:${gleamVersion}`)
+  }
 }
 
 /**
@@ -4612,18 +4639,27 @@ async function installElixir(elixirVersion) {
  * @param {string} rebar3Version
  */
 async function installRebar3(rebar3Version) {
-  await exec(__nccwpck_require__.ab + "install-rebar3", [rebar3Version])
+  const OS = process.platform
+  if (OS === 'linux') {
+    await exec(__nccwpck_require__.ab + "install-rebar3.sh", [rebar3Version])
+  } else if (OS === 'win32') {
+    const script = __nccwpck_require__.ab + "install-rebar3.ps1"
+    await exec(`pwsh.exe ${script} -VSN:${rebar3Version}`)
+  }
 }
 
 function checkPlatform() {
-  if (process.platform !== 'linux') {
+  if (process.platform !== 'linux' && process.platform !== 'win32') {
-    throw new Error('@erlef/setup-beam only supports Ubuntu Linux at this time')
+    throw new Error(
+      '@erlef/setup-beam only supports Ubuntu and Windows at this time',
+    )
   }
 }
 
 module.exports = {
   installOTP,
   installElixir,
+  installGleam,
   installRebar3,
   checkPlatform,
 }
@@ -4639,6 +4675,7 @@ const { exec } = __nccwpck_require__(1514)
 const path = __nccwpck_require__(5622)
 const semver = __nccwpck_require__(1383)
 const https = __nccwpck_require__(7211)
+const fs = __nccwpck_require__(5747)
 const installer = __nccwpck_require__(2127)
 
 main().catch((err) => {
@@ -4650,23 +4687,30 @@ async function main() {
 
   const osVersion = getRunnerOSVersion()
   const otpSpec = core.getInput('otp-version', { required: true })
-  const otpVersion = await installOTP(otpSpec, osVersion)
-
   const elixirSpec = core.getInput('elixir-version', { required: false })
-  const elixirInstalled = await maybeInstallElixir(elixirSpec, otpVersion)
+  const gleamSpec = core.getInput('gleam-version', { required: false })
-  if (elixirInstalled === true) {
+  const rebar3Spec = core.getInput('rebar3-version', { required: false })
-    const shouldMixRebar = core.getInput('install-rebar', {
+
-      required: false,
+  if (otpSpec !== 'false') {
-    })
+    const otpVersion = await installOTP(otpSpec, osVersion)
-    await mix(shouldMixRebar, 'rebar')
+    const elixirInstalled = await maybeInstallElixir(elixirSpec, otpVersion)
-    const shouldMixHex = core.getInput('install-hex', {
+
-      required: false,
+    if (elixirInstalled === true) {
-    })
+      const shouldMixRebar = core.getInput('install-rebar', {
-    await mix(shouldMixHex, 'hex')
+        required: false,
+      })
+      await mix(shouldMixRebar, 'rebar')
+      const shouldMixHex = core.getInput('install-hex', {
+        required: false,
+      })
+      await mix(shouldMixHex, 'hex')
+    }
+  } else if (!gleamSpec) {
+    throw new Error('otp-version=false is only available when installing Gleam')
   }
 
-  const rebar3Spec = core.getInput('rebar3-version', { required: false })
+  await maybeInstallGleam(gleamSpec)
-  maybeInstallRebar3(rebar3Spec)
+  await maybeInstallRebar3(rebar3Spec)
 }
 
 async function installOTP(otpSpec, osVersion) {
@@ -4676,29 +4720,44 @@ async function installOTP(otpSpec, osVersion) {
   )
   await installer.installOTP(osVersion, otpVersion)
   core.setOutput('otp-version', otpVersion)
-  prependToPath(`${process.env.RUNNER_TEMP}/.setup-beam/otp/bin`)
+  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]')
 
   return otpVersion
 }
 
 async function maybeInstallElixir(elixirSpec, otpVersion) {
+  let installed = false
+
   if (elixirSpec) {
     const elixirVersion = await getElixirVersion(elixirSpec, otpVersion)
     console.log(`##[group]Installing Elixir ${elixirVersion}`)
     await installer.installElixir(elixirVersion)
     core.setOutput('elixir-version', elixirVersion)
-    const matchersPath = __nccwpck_require__.ab + ".github"
+    const disableProblemMatchers = core.getInput('disable_problem_matchers', {
-    console.log(
+      required: false,
-      `##[add-matcher]${path.join(matchersPath, 'elixir-matchers.json')}`,
+    })
-    )
+    if (!disableProblemMatchers) {
-    prependToPath(`${process.env.RUNNER_TEMP}/.setup-beam/elixir/bin`)
+      const matchersPath = __nccwpck_require__.ab + ".github"
+      console.log(
+        `##[add-matcher]${path.join(matchersPath, 'elixir-matchers.json')}`,
+      )
+    }
+    core.addPath(`${process.env.RUNNER_TEMP}/.setup-beam/elixir/bin`)
     console.log('##[endgroup]')
 
-    return true
+    installed = true
   }
 
-  return false
+  return installed
 }
 
 async function mix(shouldMix, what) {
@@ -4711,19 +4770,43 @@ async function mix(shouldMix, what) {
   }
 }
 
+async function maybeInstallGleam(gleamSpec) {
+  let installed = false
+
+  if (gleamSpec) {
+    const gleamVersion = await getGleamVersion(gleamSpec)
+    console.log(`##[group]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]')
+
+    installed = true
+  }
+
+  return installed
+}
+
 async function maybeInstallRebar3(rebar3Spec) {
+  let installed = false
+  let rebar3Version
+
   if (rebar3Spec) {
-    const rebar3Version = await getRebar3Version(rebar3Spec)
+    if (rebar3Spec === 'nightly') {
+      rebar3Version = 'nightly'
+    } else {
+      rebar3Version = await getRebar3Version(rebar3Spec)
+    }
     console.log(`##[group]Installing rebar3 ${rebar3Version}`)
     await installer.installRebar3(rebar3Version)
     core.setOutput('rebar3-version', rebar3Version)
-    prependToPath(`${process.env.RUNNER_TEMP}/.setup-beam/rebar3/bin`)
+    core.addPath(`${process.env.RUNNER_TEMP}/.setup-beam/rebar3/bin`)
     console.log('##[endgroup]')
 
-    return true
+    installed = true
   }
 
-  return false
+  return installed
 }
 
 async function getOTPVersion(otpSpec0, osVersion) {
@@ -4732,7 +4815,7 @@ async function getOTPVersion(otpSpec0, osVersion) {
   let otpVersion
   if (otpSpec[1]) {
     throw new Error(
-      `Requested Erlang/OTP version (from spec ${otpSpec0}) ` +
+      `Requested Erlang/OTP version (${otpSpec0}) ` +
         "should not contain 'OTP-'",
     )
   }
@@ -4744,7 +4827,8 @@ async function getOTPVersion(otpSpec0, osVersion) {
   }
   if (otpVersion === null) {
     throw new Error(
-      `Requested Erlang/OTP version (from spec ${otpSpec0}) not found in build listing`,
+      `Requested Erlang/OTP version (${otpSpec0}) not found in version list ` +
+        "(should you be using option 'version-type': 'strict'?)",
     )
   }
 
@@ -4755,11 +4839,11 @@ async function getElixirVersion(exSpec0, otpVersion) {
   const elixirVersions = await getElixirVersions()
   const semverVersions = Array.from(elixirVersions.keys()).sort()
 
-  const exSpec = exSpec0.match(/^(.+)(-otp-.+)/) || exSpec0.match(/^(.+)/)
+  const exSpec = exSpec0.match(/^v?(.+)(-otp-.+)/) || exSpec0.match(/^v?(.+)/)
   let elixirVersion
   if (exSpec[2]) {
     throw new Error(
-      `Requested Elixir / Erlang/OTP version (from spec ${exSpec0} / ${otpVersion}) ` +
+      `Requested Elixir / Erlang/OTP version (${exSpec0} / ${otpVersion}) ` +
         "should not contain '-otp-...'",
     )
   }
@@ -4768,7 +4852,8 @@ async function getElixirVersion(exSpec0, otpVersion) {
   }
   if (!exSpec || elixirVersion === null) {
     throw new Error(
-      `Requested Elixir version (from spec ${exSpec0}) not found in build listing`,
+      `Requested Elixir version (${exSpec0}) not found in version list ` +
+        "(should you be using option 'version-type': 'strict'?)",
     )
   }
   const otpMatch = otpVersion.match(/^(?:OTP-)?([^.]+)/)
@@ -4784,18 +4869,32 @@ async function getElixirVersion(exSpec0, otpVersion) {
         `Using Elixir ${elixirVersion} (built for OTP ${otpVersionMajor})`,
       )
     } else {
-      // ... and it's not available: fallback to the "generic" version (v1.4.5 only).
+      // ... and it's not available: fallback to the 'generic' version (v1.4.5 only).
       elixirVersionWithOTP = elixirVersion
       core.info(`Using Elixir ${elixirVersion}`)
     }
   } else {
     throw new Error(
-      `Requested Elixir / Erlang/OTP version (from spec ${exSpec0} / ${otpVersion}) not ` +
+      `Requested Elixir / Erlang/OTP version (${exSpec0} / ${otpVersion}) not ` +
-        'found in build listing',
+        "found in version list (should you be using option 'version-type': 'strict'?)",
     )
   }
 
-  return elixirVersionWithOTP
+  return maybePrependWithV(elixirVersionWithOTP, elixirVersion)
+}
+
+async function getGleamVersion(gleamSpec0) {
+  const gleamSpec = gleamSpec0.match(/^v?(.+)/)
+  const gleamVersions = await getGleamVersions()
+  const gleamVersion = getVersionFromSpec(gleamSpec[1], gleamVersions)
+  if (gleamVersion === null) {
+    throw new Error(
+      `Requested Gleam version (${gleamSpec0}) not found in version list ` +
+        "(should you be using option 'version-type': 'strict'?)",
+    )
+  }
+
+  return maybePrependWithV(gleamVersion, gleamVersion)
 }
 
 async function getRebar3Version(r3Spec) {
@@ -4803,7 +4902,8 @@ async function getRebar3Version(r3Spec) {
   const rebar3Version = getVersionFromSpec(r3Spec, rebar3Versions)
   if (rebar3Version === null) {
     throw new Error(
-      `Requested rebar3 version (from spec ${r3Spec}) not found in build listing`,
+      `Requested rebar3 version (${r3Spec}) not found in version list ` +
+        "(should you be using option 'version-type': 'strict'?)",
     )
   }
 
@@ -4811,39 +4911,59 @@ async function getRebar3Version(r3Spec) {
 }
 
 async function getOTPVersions(osVersion) {
-  const otpVersionsListing = await get(
+  let originListing
-    `https://repo.hex.pm/builds/otp/${osVersion}/builds.txt`,
+  let pageIdxs
-  )
+  if (process.platform === 'linux') {
+    originListing = `https://repo.hex.pm/builds/otp/${osVersion}/builds.txt`
+    pageIdxs = [null]
+  } else if (process.platform === 'win32') {
+    originListing =
+      'https://api.github.com/repos/erlang/otp/releases?per_page=100'
+    pageIdxs = [1, 2, 3]
+  }
+
+  const otpVersionsListings = await get(originListing, pageIdxs)
   const otpVersions = new Map()
 
-  otpVersionsListing
+  if (process.platform === 'linux') {
-    .trim()
+    otpVersionsListings
-    .split('\n')
+      .trim()
-    .forEach((line) => {
+      .split('\n')
-      const otpMatch = line.match(/^(OTP-)?([^ ]+)/)
+      .forEach((line) => {
-
+        const otpMatch = line.match(/^(OTP-)?([^ ]+)/)
-      let otpVersion = otpMatch[2]
+        const otpVersion = otpMatch[2]
-      if (semver.validRange(otpVersion)) {
+        otpVersions.set(otpVersion, otpMatch[0]) // we keep the original for later reference
-        otpVersion = semver.minVersion(otpVersion).version
+      })
-      }
+  } else if (process.platform === 'win32') {
-      otpVersions.set(otpVersion, otpMatch[0]) // we keep the original for later reference
+    otpVersionsListings.forEach((otpVersionsListing) => {
+      JSON.parse(otpVersionsListing)
+        .map((x) => x.assets)
+        .flat()
+        .filter((x) => x.name.match(/^otp_win64_.*.exe$/))
+        .forEach((x) => {
+          const otpMatch = x.name.match(/^otp_win64_(.*).exe$/)
+          const otpVersion = otpMatch[1]
+          otpVersions.set(otpVersion, otpVersion)
+        })
     })
+  }
 
   return otpVersions
 }
 
 async function getElixirVersions() {
-  const elixirVersionsListing = await get(
+  const elixirVersionsListings = await get(
     'https://repo.hex.pm/builds/elixir/builds.txt',
+    [null],
   )
   const otpVersionsForElixirMap = new Map()
 
-  elixirVersionsListing
+  elixirVersionsListings
     .trim()
     .split('\n')
     .forEach((line) => {
       const elixirMatch =
-        line.match(/^(.+)-otp-([^ ]+)/) || line.match(/^([^ ]+)/)
+        line.match(/^v?(.+)-otp-([^ ]+)/) || line.match(/^v?([^ ]+)/)
       const elixirVersion = elixirMatch[1]
       const otpVersion = elixirMatch[2]
       const otpVersions = otpVersionsForElixirMap.get(elixirVersion) || []
@@ -4857,67 +4977,182 @@ async function getElixirVersions() {
   return otpVersionsForElixirMap
 }
 
-async function getRebar3Versions() {
+async function getGleamVersions() {
-  const resultJSON = await get(
+  const resultJSONs = await get(
-    'https://api.github.com/repos/erlang/rebar3/releases?per_page=100',
+    'https://api.github.com/repos/gleam-lang/gleam/releases?per_page=100',
+    [1, 2, 3],
   )
-  const rebar3VersionsListing = JSON.parse(resultJSON)
+  const gleamVersionsListing = []
-    .map((x) => x.tag_name)
+  resultJSONs.forEach((resultJSON) => {
-    .sort()
+    JSON.parse(resultJSON)
+      .map((x) => x.tag_name)
+      .sort()
+      .forEach((v) => gleamVersionsListing.push(v))
+  })
+  return gleamVersionsListing
+}
 
+async function getRebar3Versions() {
+  const resultJSONs = await get(
+    'https://api.github.com/repos/erlang/rebar3/releases?per_page=100',
+    [1, 2, 3],
+  )
+  const rebar3VersionsListing = []
+  resultJSONs.forEach((resultJSON) => {
+    JSON.parse(resultJSON)
+      .map((x) => x.tag_name)
+      .sort()
+      .forEach((v) => rebar3VersionsListing.push(v))
+  })
   return rebar3VersionsListing
 }
 
 function getVersionFromSpec(spec, versions) {
-  if (versions.includes(spec)) {
+  let version = null
-    return spec
+
+  if (
+    spec.match(/rc/) ||
+    core.getInput('version-type', { required: false }) === 'strict'
+  ) {
+    version = spec
   }
 
-  return semver.maxSatisfying(versions, semver.validRange(spec))
+  if (version === null) {
+    // We keep a map of semver => "spec" in order to use semver ranges to find appropriate versions
+    const versionsMap = versions.sort(sortVersions).reduce((acc, v) => {
+      if (!v.match(/rc/)) {
+        // release candidates are opt-in
+        acc[maybeCoerced(v)] = v
+      }
+      return acc
+    }, {})
+    const rangeForMax = semver.validRange(spec)
+    if (rangeForMax) {
+      version =
+        versionsMap[semver.maxSatisfying(Object.keys(versionsMap), rangeForMax)]
+    } else {
+      version = versionsMap[maybeCoerced(spec)]
+    }
+  }
+
+  return version === null || version === undefined ? null : version
+}
+
+function maybeCoerced(v) {
+  let ret
+
+  try {
+    ret = semver.coerce(v).version
+  } catch {
+    // some stuff can't be coerced, like 'master'
+    ret = v
+  }
+
+  return ret
+}
+
+function sortVersions(left, right) {
+  let ret = 0
+  const newL = verAsComparableStr(left)
+  const newR = verAsComparableStr(right)
+
+  function verAsComparableStr(ver) {
+    const matchGroups = 5
+    const verSpec = /([^.]+)?\.?([^.]+)?\.?([^.]+)?\.?([^.]+)?\.?([^.]+)?/
+    const matches = ver.match(verSpec).splice(1, matchGroups)
+    return matches.reduce((acc, v) => acc + (v || '0').padStart(3, '0'), '')
+  }
+
+  if (newL < newR) {
+    ret = -1
+  } else if (newL > newR) {
+    ret = 1
+  }
+
+  return ret
 }
 
 function getRunnerOSVersion() {
-  const mapToUbuntuVersion = {
+  const ImageOSToContainer = {
-    ubuntu16: 'ubuntu-16.04',
     ubuntu18: 'ubuntu-18.04',
     ubuntu20: 'ubuntu-20.04',
+    win19: 'windows-2019',
+  }
+  const containerFromEnvImageOS = ImageOSToContainer[process.env.ImageOS]
+
+  if (!containerFromEnvImageOS) {
+    throw new Error(
+      "Tried to map a target OS from env. variable 'ImageOS' (got " +
+        `${process.env.ImageOS}` +
+        "), but failed. If you're using a " +
+        "self-hosted runner, you should set 'env': 'ImageOS': ... to one of the following: " +
+        "['" +
+        `${Object.keys(ImageOSToContainer).join("', '")}` +
+        "']",
+    )
   }
 
-  return mapToUbuntuVersion[process.env.ImageOS] || 'ubuntu-18.04'
+  return containerFromEnvImageOS
 }
 
-function get(url) {
+async function get(url0, pageIdxs) {
-  return new Promise((resolve, reject) => {
+  function getPage(pageIdx) {
-    https
+    return new Promise((resolve, reject) => {
-      .get(
+      const url = new URL(url0)
-        url,
+      if (pageIdx !== null) {
-        {
+        url.searchParams.append('page', pageIdx)
-          headers: { 'user-agent': 'setup-beam' },
+      }
-        },
+      https
-        (res) => {
+        .get(
-          let data = ''
+          url,
-          res.on('data', (chunk) => {
+          {
-            data += chunk
+            headers: { 'user-agent': 'setup-beam' },
-          })
+          },
-          res.on('end', () => {
+          (res) => {
-            resolve(data)
+            let data = ''
-          })
+            res.on('data', (chunk) => {
-        },
+              data += chunk
-      )
+            })
-      .on('error', (err) => {
+            res.on('end', () => {
-        reject(err)
+              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)
+        })
+    })
+  }
+  let ret
+  if (pageIdxs[0] === null) {
+    ret = getPage(null)
+  } else {
+    ret = Promise.all(pageIdxs.map((pageIdx) => getPage(pageIdx)))
+  }
+  return ret
 }
 
-function prependToPath(what) {
+function maybePrependWithV(versionToPrepend, specVersion) {
-  process.env.PATH = `${what}:${process.env.PATH}`
+  const digitStart = new RegExp('^\\d+')
+  return digitStart.test(specVersion)
+    ? `v${versionToPrepend}`
+    : versionToPrepend
 }
 
 module.exports = {
   getOTPVersion,
   getElixirVersion,
+  getGleamVersion,
   getRebar3Version,
+  getVersionFromSpec,
 }
 
 

dist/install-elixir.ps1

@@ -0,0 +1,19 @@
+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

dist/install-elixir.sh

@@ -9,12 +9,8 @@ FILE_INPUT="${VSN}.zip"
 FILE_OUTPUT=elixir.zip
 DIR_FOR_BIN=.setup-beam/elixir
 
-rm -f "${FILE_OUTPUT}"
-rm -rf "${DIR_FOR_BIN}"
 wget -q -O "${FILE_OUTPUT}" "https://repo.hex.pm/builds/elixir/${FILE_INPUT}"
 mkdir -p "${DIR_FOR_BIN}"
 unzip -q -d "${DIR_FOR_BIN}" "${FILE_OUTPUT}"
-rm -f "${FILE_OUTPUT}"
-echo "$(pwd)/${DIR_FOR_BIN}/bin" >> "$GITHUB_PATH"
 echo "Installed Elixir version follows"
-${DIR_FOR_BIN}/bin/iex -v
+${DIR_FOR_BIN}/bin/elixir -v

dist/install-gleam.ps1

@@ -0,0 +1,19 @@
+param([Parameter(Mandatory=$true)][string]$VSN)
+
+$ErrorActionPreference="Stop"
+
+Set-Location $Env:RUNNER_TEMP
+
+$FILE_INPUT="gleam-${VSN}-windows-64bit.zip"
+$FILE_OUTPUT="gleam.zip"
+$DIR_FOR_BIN=".setup-beam/gleam/bin"
+
+$ProgressPreference="SilentlyContinue"
+Invoke-WebRequest "https://github.com/gleam-lang/gleam/releases/download/${VSN}/${FILE_INPUT}" -OutFile "$FILE_OUTPUT"
+$ProgressPreference="Continue"
+New-Item "$DIR_FOR_BIN" -ItemType Directory | Out-Null
+$ProgressPreference="SilentlyContinue"
+Expand-Archive -DestinationPath "${DIR_FOR_BIN}" -Path "${FILE_OUTPUT}"
+$ProgressPreference="Continue"
+Write-Output "Installed Gleam version follows"
+& "$DIR_FOR_BIN/gleam" "--version" | Write-Output

dist/install-gleam.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+
+set -eo pipefail
+
+cd "$RUNNER_TEMP"
+
+VSN=${1}
+FILE_INPUT=gleam-${VSN}-linux-amd64.tar.gz
+FILE_OUTPUT=gleam.tar.gz
+DIR_FOR_BIN=.setup-beam/gleam/bin
+
+wget -q -O "${FILE_OUTPUT}" "https://github.com/gleam-lang/gleam/releases/download/${VSN}/${FILE_INPUT}"
+mkdir -p "${DIR_FOR_BIN}"
+tar zxf "${FILE_OUTPUT}" -C "${DIR_FOR_BIN}"
+
+echo "Installed Gleam version follows"
+${DIR_FOR_BIN}/gleam --version

dist/install-otp.ps1

@@ -0,0 +1,20 @@
+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

dist/install-otp.sh

@@ -10,13 +10,9 @@ FILE_INPUT="${VSN}.tar.gz"
 FILE_OUTPUT=otp.tar.gz
 DIR_FOR_BIN=.setup-beam/otp
 
-rm -f "${FILE_OUTPUT}"
-rm -rf "${DIR_FOR_BIN}"
 wget -q -O "${FILE_OUTPUT}" "https://repo.hex.pm/builds/otp/${OS}/${FILE_INPUT}"
 mkdir -p "${DIR_FOR_BIN}"
 tar zxf "${FILE_OUTPUT}" -C "${DIR_FOR_BIN}" --strip-components=1
-rm -f "${FILE_OUTPUT}"
 "${DIR_FOR_BIN}/Install" -minimal "$(pwd)/${DIR_FOR_BIN}"
-echo "$(pwd)/${DIR_FOR_BIN}/bin" >> "$GITHUB_PATH"
 echo "Installed Erlang/OTP version follows"
 ${DIR_FOR_BIN}/bin/erl -version

dist/install-rebar3

@@ -1,20 +0,0 @@
-#!/bin/bash
-
-set -eo pipefail
-
-cd "$RUNNER_TEMP"
-
-VSN=${1}
-FILE_INPUT=rebar3
-FILE_OUTPUT=rebar3
-DIR_FOR_BIN=.setup-beam/rebar3
-
-rm -f "${FILE_OUTPUT}"
-rm -rf "${DIR_FOR_BIN}"
-wget -q -O "${FILE_OUTPUT}" "https://github.com/erlang/rebar3/releases/download/${VSN}/${FILE_INPUT}"
-mkdir -p "${DIR_FOR_BIN}/bin"
-chmod +x "${FILE_OUTPUT}"
-mv "${FILE_OUTPUT}" "${DIR_FOR_BIN}/bin"
-echo "$(pwd)/${DIR_FOR_BIN}/bin" >> "$GITHUB_PATH"
-echo "Installed rebar3 version follows"
-${DIR_FOR_BIN}/bin/rebar3 version

dist/install-rebar3.ps1

@@ -0,0 +1,28 @@
+param([Parameter(Mandatory=$true)][string]$VSN)
+
+$ErrorActionPreference="Stop"
+
+Set-Location $Env:RUNNER_TEMP
+
+$FILE_INPUT="rebar3"
+$FILE_OUTPUT="rebar3"
+$FILE_OUTPUT_PS1="rebar3.ps1"
+$DIR_FOR_BIN=".setup-beam/rebar3"
+
+$ProgressPreference="SilentlyContinue"
+$REBAR3_TARGET="https://github.com/erlang/rebar3/releases/download/${VSN}/${FILE_INPUT}"
+$REBAR3_NIGHTLY=""
+If ( $VSN -eq "nightly" )
+{
+    $REBAR3_TARGET="https://s3.amazonaws.com/rebar3-nightly/rebar3"
+    $REBAR3_NIGHTLY=" (from nightly build)"
+}
+Invoke-WebRequest "$REBAR3_TARGET" -OutFile "$FILE_OUTPUT"
+$ProgressPreference="Continue"
+New-Item "$DIR_FOR_BIN/bin" -ItemType Directory | Out-Null
+Move-Item "$FILE_OUTPUT" "$DIR_FOR_BIN/bin"
+Write-Output "& escript.exe $PWD/$DIR_FOR_BIN/bin/$FILE_OUTPUT `$args" | Out-File -FilePath "$FILE_OUTPUT_PS1" -Encoding utf8 -Append
+type $FILE_OUTPUT_PS1
+Move-Item "$FILE_OUTPUT_PS1" "$DIR_FOR_BIN/bin"
+Write-Output "Installed rebar3 version$REBAR3_NIGHTLY follows"
+& "$DIR_FOR_BIN/bin/rebar3" "version" | Write-Output

dist/install-rebar3.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+
+set -eo pipefail
+
+cd "$RUNNER_TEMP"
+
+VSN=${1}
+FILE_INPUT=rebar3
+FILE_OUTPUT=rebar3
+DIR_FOR_BIN=.setup-beam/rebar3
+
+REBAR3_TARGET="https://github.com/erlang/rebar3/releases/download/${VSN}/${FILE_INPUT}"
+REBAR3_NIGHTLY=""
+if [ "${VSN}" == "nightly" ]; then
+    REBAR3_TARGET="https://s3.amazonaws.com/rebar3-nightly/rebar3"
+    REBAR3_NIGHTLY=" (from nightly build)"
+fi
+wget -q -O "${FILE_OUTPUT}" "${REBAR3_TARGET}"
+mkdir -p "${DIR_FOR_BIN}/bin"
+chmod +x "${FILE_OUTPUT}"
+mv "${FILE_OUTPUT}" "${DIR_FOR_BIN}/bin"
+echo "Installed rebar3 version$REBAR3_NIGHTLY follows"
+${DIR_FOR_BIN}/bin/rebar3 version

package.json

@@ -1,6 +1,5 @@
 {
   "name": "setup-beam",
-  "version": "1.7.1",
   "license": "MIT",
   "private": true,
   "scripts": {
@@ -9,8 +8,8 @@
     "jslint": "eslint src/**/*.js && eslint __tests__/**/*.js",
     "licenses": "yarn licenses generate-disclaimer > 3RD_PARTY_LICENSES",
     "markdownlint": "markdownlint *.md",
-    "shellcheck": "shellcheck src/install-*",
+    "shellcheck": "shellcheck src/install-*.sh .github/workflows/*.sh",
-    "test": "node __tests__/setup-beam.test.js",
+    "test": "node __tests__/setup-beam.test.js && node ./__tests__/problem-matchers.test.js",
     "yamllint": "yamllint .github/workflows/**.yml && yamllint .*.yml && yamllint *.yml"
   },
   "husky": {
@@ -27,6 +26,9 @@
     "@vercel/ncc": "0.27.0",
     "eslint": "7.22.0",
     "eslint-config-airbnb": "v18.2.1",
+    "eslint-plugin-import": "^2.24.2",
+    "eslint-plugin-jsx-a11y": "^6.4.1",
+    "eslint-plugin-react": "^7.25.1",
     "husky": "5.2.0",
     "markdownlint": "0.23.1",
     "prettier": "2.2.1",

src/install-elixir.ps1

@@ -0,0 +1,19 @@
+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

src/install-elixir.sh

@@ -9,12 +9,8 @@ FILE_INPUT="${VSN}.zip"
 FILE_OUTPUT=elixir.zip
 DIR_FOR_BIN=.setup-beam/elixir
 
-rm -f "${FILE_OUTPUT}"
-rm -rf "${DIR_FOR_BIN}"
 wget -q -O "${FILE_OUTPUT}" "https://repo.hex.pm/builds/elixir/${FILE_INPUT}"
 mkdir -p "${DIR_FOR_BIN}"
 unzip -q -d "${DIR_FOR_BIN}" "${FILE_OUTPUT}"
-rm -f "${FILE_OUTPUT}"
-echo "$(pwd)/${DIR_FOR_BIN}/bin" >> "$GITHUB_PATH"
 echo "Installed Elixir version follows"
-${DIR_FOR_BIN}/bin/iex -v
+${DIR_FOR_BIN}/bin/elixir -v

src/install-gleam.ps1

@@ -0,0 +1,19 @@
+param([Parameter(Mandatory=$true)][string]$VSN)
+
+$ErrorActionPreference="Stop"
+
+Set-Location $Env:RUNNER_TEMP
+
+$FILE_INPUT="gleam-${VSN}-windows-64bit.zip"
+$FILE_OUTPUT="gleam.zip"
+$DIR_FOR_BIN=".setup-beam/gleam/bin"
+
+$ProgressPreference="SilentlyContinue"
+Invoke-WebRequest "https://github.com/gleam-lang/gleam/releases/download/${VSN}/${FILE_INPUT}" -OutFile "$FILE_OUTPUT"
+$ProgressPreference="Continue"
+New-Item "$DIR_FOR_BIN" -ItemType Directory | Out-Null
+$ProgressPreference="SilentlyContinue"
+Expand-Archive -DestinationPath "${DIR_FOR_BIN}" -Path "${FILE_OUTPUT}"
+$ProgressPreference="Continue"
+Write-Output "Installed Gleam version follows"
+& "$DIR_FOR_BIN/gleam" "--version" | Write-Output

src/install-gleam.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+
+set -eo pipefail
+
+cd "$RUNNER_TEMP"
+
+VSN=${1}
+FILE_INPUT=gleam-${VSN}-linux-amd64.tar.gz
+FILE_OUTPUT=gleam.tar.gz
+DIR_FOR_BIN=.setup-beam/gleam/bin
+
+wget -q -O "${FILE_OUTPUT}" "https://github.com/gleam-lang/gleam/releases/download/${VSN}/${FILE_INPUT}"
+mkdir -p "${DIR_FOR_BIN}"
+tar zxf "${FILE_OUTPUT}" -C "${DIR_FOR_BIN}"
+
+echo "Installed Gleam version follows"
+${DIR_FOR_BIN}/gleam --version

src/install-otp.ps1

@@ -0,0 +1,20 @@
+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

src/install-otp.sh

@@ -10,13 +10,9 @@ FILE_INPUT="${VSN}.tar.gz"
 FILE_OUTPUT=otp.tar.gz
 DIR_FOR_BIN=.setup-beam/otp
 
-rm -f "${FILE_OUTPUT}"
-rm -rf "${DIR_FOR_BIN}"
 wget -q -O "${FILE_OUTPUT}" "https://repo.hex.pm/builds/otp/${OS}/${FILE_INPUT}"
 mkdir -p "${DIR_FOR_BIN}"
 tar zxf "${FILE_OUTPUT}" -C "${DIR_FOR_BIN}" --strip-components=1
-rm -f "${FILE_OUTPUT}"
 "${DIR_FOR_BIN}/Install" -minimal "$(pwd)/${DIR_FOR_BIN}"
-echo "$(pwd)/${DIR_FOR_BIN}/bin" >> "$GITHUB_PATH"
 echo "Installed Erlang/OTP version follows"
 ${DIR_FOR_BIN}/bin/erl -version

src/install-rebar3

@@ -1,20 +0,0 @@
-#!/bin/bash
-
-set -eo pipefail
-
-cd "$RUNNER_TEMP"
-
-VSN=${1}
-FILE_INPUT=rebar3
-FILE_OUTPUT=rebar3
-DIR_FOR_BIN=.setup-beam/rebar3
-
-rm -f "${FILE_OUTPUT}"
-rm -rf "${DIR_FOR_BIN}"
-wget -q -O "${FILE_OUTPUT}" "https://github.com/erlang/rebar3/releases/download/${VSN}/${FILE_INPUT}"
-mkdir -p "${DIR_FOR_BIN}/bin"
-chmod +x "${FILE_OUTPUT}"
-mv "${FILE_OUTPUT}" "${DIR_FOR_BIN}/bin"
-echo "$(pwd)/${DIR_FOR_BIN}/bin" >> "$GITHUB_PATH"
-echo "Installed rebar3 version follows"
-${DIR_FOR_BIN}/bin/rebar3 version

src/install-rebar3.ps1

@@ -0,0 +1,28 @@
+param([Parameter(Mandatory=$true)][string]$VSN)
+
+$ErrorActionPreference="Stop"
+
+Set-Location $Env:RUNNER_TEMP
+
+$FILE_INPUT="rebar3"
+$FILE_OUTPUT="rebar3"
+$FILE_OUTPUT_PS1="rebar3.ps1"
+$DIR_FOR_BIN=".setup-beam/rebar3"
+
+$ProgressPreference="SilentlyContinue"
+$REBAR3_TARGET="https://github.com/erlang/rebar3/releases/download/${VSN}/${FILE_INPUT}"
+$REBAR3_NIGHTLY=""
+If ( $VSN -eq "nightly" )
+{
+    $REBAR3_TARGET="https://s3.amazonaws.com/rebar3-nightly/rebar3"
+    $REBAR3_NIGHTLY=" (from nightly build)"
+}
+Invoke-WebRequest "$REBAR3_TARGET" -OutFile "$FILE_OUTPUT"
+$ProgressPreference="Continue"
+New-Item "$DIR_FOR_BIN/bin" -ItemType Directory | Out-Null
+Move-Item "$FILE_OUTPUT" "$DIR_FOR_BIN/bin"
+Write-Output "& escript.exe $PWD/$DIR_FOR_BIN/bin/$FILE_OUTPUT `$args" | Out-File -FilePath "$FILE_OUTPUT_PS1" -Encoding utf8 -Append
+type $FILE_OUTPUT_PS1
+Move-Item "$FILE_OUTPUT_PS1" "$DIR_FOR_BIN/bin"
+Write-Output "Installed rebar3 version$REBAR3_NIGHTLY follows"
+& "$DIR_FOR_BIN/bin/rebar3" "version" | Write-Output

src/install-rebar3.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+
+set -eo pipefail
+
+cd "$RUNNER_TEMP"
+
+VSN=${1}
+FILE_INPUT=rebar3
+FILE_OUTPUT=rebar3
+DIR_FOR_BIN=.setup-beam/rebar3
+
+REBAR3_TARGET="https://github.com/erlang/rebar3/releases/download/${VSN}/${FILE_INPUT}"
+REBAR3_NIGHTLY=""
+if [ "${VSN}" == "nightly" ]; then
+    REBAR3_TARGET="https://s3.amazonaws.com/rebar3-nightly/rebar3"
+    REBAR3_NIGHTLY=" (from nightly build)"
+fi
+wget -q -O "${FILE_OUTPUT}" "${REBAR3_TARGET}"
+mkdir -p "${DIR_FOR_BIN}/bin"
+chmod +x "${FILE_OUTPUT}"
+mv "${FILE_OUTPUT}" "${DIR_FOR_BIN}/bin"
+echo "Installed rebar3 version$REBAR3_NIGHTLY follows"
+${DIR_FOR_BIN}/bin/rebar3 version

src/installer.js

@@ -8,7 +8,13 @@ const path = require('path')
  * @param {string} otpVersion
  */
 async function installOTP(osVersion, otpVersion) {
-  await exec(path.join(__dirname, 'install-otp'), [osVersion, otpVersion])
+  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}`)
+  }
 }
 
 /**
@@ -17,7 +23,28 @@ async function installOTP(osVersion, otpVersion) {
  * @param {string} elixirVersion
  */
 async function installElixir(elixirVersion) {
-  await exec(path.join(__dirname, 'install-elixir'), [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}`)
+  }
+}
+
+/**
+ * Install Gleam.
+ *
+ * @param {string} gleamVersion
+ */
+async function installGleam(gleamVersion) {
+  const OS = process.platform
+  if (OS === 'linux') {
+    await exec(path.join(__dirname, 'install-gleam.sh'), [gleamVersion])
+  } else if (OS === 'win32') {
+    const script = path.join(__dirname, 'install-gleam.ps1')
+    await exec(`pwsh.exe ${script} -VSN:${gleamVersion}`)
+  }
 }
 
 /**
@@ -26,18 +53,27 @@ async function installElixir(elixirVersion) {
  * @param {string} rebar3Version
  */
 async function installRebar3(rebar3Version) {
-  await exec(path.join(__dirname, 'install-rebar3'), [rebar3Version])
+  const OS = process.platform
+  if (OS === 'linux') {
+    await exec(path.join(__dirname, 'install-rebar3.sh'), [rebar3Version])
+  } else if (OS === 'win32') {
+    const script = path.join(__dirname, 'install-rebar3.ps1')
+    await exec(`pwsh.exe ${script} -VSN:${rebar3Version}`)
+  }
 }
 
 function checkPlatform() {
-  if (process.platform !== 'linux') {
+  if (process.platform !== 'linux' && process.platform !== 'win32') {
-    throw new Error('@erlef/setup-beam only supports Ubuntu Linux at this time')
+    throw new Error(
+      '@erlef/setup-beam only supports Ubuntu and Windows at this time',
+    )
   }
 }
 
 module.exports = {
   installOTP,
   installElixir,
+  installGleam,
   installRebar3,
   checkPlatform,
 }

src/setup-beam.js

@@ -3,6 +3,7 @@ const { exec } = require('@actions/exec')
 const path = require('path')
 const semver = require('semver')
 const https = require('https')
+const fs = require('fs')
 const installer = require('./installer')
 
 main().catch((err) => {
@@ -14,23 +15,30 @@ async function main() {
 
   const osVersion = getRunnerOSVersion()
   const otpSpec = core.getInput('otp-version', { required: true })
-  const otpVersion = await installOTP(otpSpec, osVersion)
-
   const elixirSpec = core.getInput('elixir-version', { required: false })
-  const elixirInstalled = await maybeInstallElixir(elixirSpec, otpVersion)
+  const gleamSpec = core.getInput('gleam-version', { required: false })
-  if (elixirInstalled === true) {
+  const rebar3Spec = core.getInput('rebar3-version', { required: false })
-    const shouldMixRebar = core.getInput('install-rebar', {
+
-      required: false,
+  if (otpSpec !== 'false') {
-    })
+    const otpVersion = await installOTP(otpSpec, osVersion)
-    await mix(shouldMixRebar, 'rebar')
+    const elixirInstalled = await maybeInstallElixir(elixirSpec, otpVersion)
-    const shouldMixHex = core.getInput('install-hex', {
+
-      required: false,
+    if (elixirInstalled === true) {
-    })
+      const shouldMixRebar = core.getInput('install-rebar', {
-    await mix(shouldMixHex, 'hex')
+        required: false,
+      })
+      await mix(shouldMixRebar, 'rebar')
+      const shouldMixHex = core.getInput('install-hex', {
+        required: false,
+      })
+      await mix(shouldMixHex, 'hex')
+    }
+  } else if (!gleamSpec) {
+    throw new Error('otp-version=false is only available when installing Gleam')
   }
 
-  const rebar3Spec = core.getInput('rebar3-version', { required: false })
+  await maybeInstallGleam(gleamSpec)
-  maybeInstallRebar3(rebar3Spec)
+  await maybeInstallRebar3(rebar3Spec)
 }
 
 async function installOTP(otpSpec, osVersion) {
@@ -40,29 +48,44 @@ async function installOTP(otpSpec, osVersion) {
   )
   await installer.installOTP(osVersion, otpVersion)
   core.setOutput('otp-version', otpVersion)
-  prependToPath(`${process.env.RUNNER_TEMP}/.setup-beam/otp/bin`)
+  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]')
 
   return otpVersion
 }
 
 async function maybeInstallElixir(elixirSpec, otpVersion) {
+  let installed = false
+
   if (elixirSpec) {
     const elixirVersion = await getElixirVersion(elixirSpec, otpVersion)
     console.log(`##[group]Installing Elixir ${elixirVersion}`)
     await installer.installElixir(elixirVersion)
     core.setOutput('elixir-version', elixirVersion)
-    const matchersPath = path.join(__dirname, '..', '.github')
+    const disableProblemMatchers = core.getInput('disable_problem_matchers', {
-    console.log(
+      required: false,
-      `##[add-matcher]${path.join(matchersPath, 'elixir-matchers.json')}`,
+    })
-    )
+    if (!disableProblemMatchers) {
-    prependToPath(`${process.env.RUNNER_TEMP}/.setup-beam/elixir/bin`)
+      const matchersPath = path.join(__dirname, '..', '.github')
+      console.log(
+        `##[add-matcher]${path.join(matchersPath, 'elixir-matchers.json')}`,
+      )
+    }
+    core.addPath(`${process.env.RUNNER_TEMP}/.setup-beam/elixir/bin`)
     console.log('##[endgroup]')
 
-    return true
+    installed = true
   }
 
-  return false
+  return installed
 }
 
 async function mix(shouldMix, what) {
@@ -75,19 +98,43 @@ async function mix(shouldMix, what) {
   }
 }
 
+async function maybeInstallGleam(gleamSpec) {
+  let installed = false
+
+  if (gleamSpec) {
+    const gleamVersion = await getGleamVersion(gleamSpec)
+    console.log(`##[group]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]')
+
+    installed = true
+  }
+
+  return installed
+}
+
 async function maybeInstallRebar3(rebar3Spec) {
+  let installed = false
+  let rebar3Version
+
   if (rebar3Spec) {
-    const rebar3Version = await getRebar3Version(rebar3Spec)
+    if (rebar3Spec === 'nightly') {
+      rebar3Version = 'nightly'
+    } else {
+      rebar3Version = await getRebar3Version(rebar3Spec)
+    }
     console.log(`##[group]Installing rebar3 ${rebar3Version}`)
     await installer.installRebar3(rebar3Version)
     core.setOutput('rebar3-version', rebar3Version)
-    prependToPath(`${process.env.RUNNER_TEMP}/.setup-beam/rebar3/bin`)
+    core.addPath(`${process.env.RUNNER_TEMP}/.setup-beam/rebar3/bin`)
     console.log('##[endgroup]')
 
-    return true
+    installed = true
   }
 
-  return false
+  return installed
 }
 
 async function getOTPVersion(otpSpec0, osVersion) {
@@ -96,7 +143,7 @@ async function getOTPVersion(otpSpec0, osVersion) {
   let otpVersion
   if (otpSpec[1]) {
     throw new Error(
-      `Requested Erlang/OTP version (from spec ${otpSpec0}) ` +
+      `Requested Erlang/OTP version (${otpSpec0}) ` +
         "should not contain 'OTP-'",
     )
   }
@@ -108,7 +155,8 @@ async function getOTPVersion(otpSpec0, osVersion) {
   }
   if (otpVersion === null) {
     throw new Error(
-      `Requested Erlang/OTP version (from spec ${otpSpec0}) not found in build listing`,
+      `Requested Erlang/OTP version (${otpSpec0}) not found in version list ` +
+        "(should you be using option 'version-type': 'strict'?)",
     )
   }
 
@@ -119,11 +167,11 @@ async function getElixirVersion(exSpec0, otpVersion) {
   const elixirVersions = await getElixirVersions()
   const semverVersions = Array.from(elixirVersions.keys()).sort()
 
-  const exSpec = exSpec0.match(/^(.+)(-otp-.+)/) || exSpec0.match(/^(.+)/)
+  const exSpec = exSpec0.match(/^v?(.+)(-otp-.+)/) || exSpec0.match(/^v?(.+)/)
   let elixirVersion
   if (exSpec[2]) {
     throw new Error(
-      `Requested Elixir / Erlang/OTP version (from spec ${exSpec0} / ${otpVersion}) ` +
+      `Requested Elixir / Erlang/OTP version (${exSpec0} / ${otpVersion}) ` +
         "should not contain '-otp-...'",
     )
   }
@@ -132,7 +180,8 @@ async function getElixirVersion(exSpec0, otpVersion) {
   }
   if (!exSpec || elixirVersion === null) {
     throw new Error(
-      `Requested Elixir version (from spec ${exSpec0}) not found in build listing`,
+      `Requested Elixir version (${exSpec0}) not found in version list ` +
+        "(should you be using option 'version-type': 'strict'?)",
     )
   }
   const otpMatch = otpVersion.match(/^(?:OTP-)?([^.]+)/)
@@ -148,18 +197,32 @@ async function getElixirVersion(exSpec0, otpVersion) {
         `Using Elixir ${elixirVersion} (built for OTP ${otpVersionMajor})`,
       )
     } else {
-      // ... and it's not available: fallback to the "generic" version (v1.4.5 only).
+      // ... and it's not available: fallback to the 'generic' version (v1.4.5 only).
       elixirVersionWithOTP = elixirVersion
       core.info(`Using Elixir ${elixirVersion}`)
     }
   } else {
     throw new Error(
-      `Requested Elixir / Erlang/OTP version (from spec ${exSpec0} / ${otpVersion}) not ` +
+      `Requested Elixir / Erlang/OTP version (${exSpec0} / ${otpVersion}) not ` +
-        'found in build listing',
+        "found in version list (should you be using option 'version-type': 'strict'?)",
     )
   }
 
-  return elixirVersionWithOTP
+  return maybePrependWithV(elixirVersionWithOTP, elixirVersion)
+}
+
+async function getGleamVersion(gleamSpec0) {
+  const gleamSpec = gleamSpec0.match(/^v?(.+)/)
+  const gleamVersions = await getGleamVersions()
+  const gleamVersion = getVersionFromSpec(gleamSpec[1], gleamVersions)
+  if (gleamVersion === null) {
+    throw new Error(
+      `Requested Gleam version (${gleamSpec0}) not found in version list ` +
+        "(should you be using option 'version-type': 'strict'?)",
+    )
+  }
+
+  return maybePrependWithV(gleamVersion, gleamVersion)
 }
 
 async function getRebar3Version(r3Spec) {
@@ -167,7 +230,8 @@ async function getRebar3Version(r3Spec) {
   const rebar3Version = getVersionFromSpec(r3Spec, rebar3Versions)
   if (rebar3Version === null) {
     throw new Error(
-      `Requested rebar3 version (from spec ${r3Spec}) not found in build listing`,
+      `Requested rebar3 version (${r3Spec}) not found in version list ` +
+        "(should you be using option 'version-type': 'strict'?)",
     )
   }
 
@@ -175,39 +239,59 @@ async function getRebar3Version(r3Spec) {
 }
 
 async function getOTPVersions(osVersion) {
-  const otpVersionsListing = await get(
+  let originListing
-    `https://repo.hex.pm/builds/otp/${osVersion}/builds.txt`,
+  let pageIdxs
-  )
+  if (process.platform === 'linux') {
+    originListing = `https://repo.hex.pm/builds/otp/${osVersion}/builds.txt`
+    pageIdxs = [null]
+  } else if (process.platform === 'win32') {
+    originListing =
+      'https://api.github.com/repos/erlang/otp/releases?per_page=100'
+    pageIdxs = [1, 2, 3]
+  }
+
+  const otpVersionsListings = await get(originListing, pageIdxs)
   const otpVersions = new Map()
 
-  otpVersionsListing
+  if (process.platform === 'linux') {
-    .trim()
+    otpVersionsListings
-    .split('\n')
+      .trim()
-    .forEach((line) => {
+      .split('\n')
-      const otpMatch = line.match(/^(OTP-)?([^ ]+)/)
+      .forEach((line) => {
-
+        const otpMatch = line.match(/^(OTP-)?([^ ]+)/)
-      let otpVersion = otpMatch[2]
+        const otpVersion = otpMatch[2]
-      if (semver.validRange(otpVersion)) {
+        otpVersions.set(otpVersion, otpMatch[0]) // we keep the original for later reference
-        otpVersion = semver.minVersion(otpVersion).version
+      })
-      }
+  } else if (process.platform === 'win32') {
-      otpVersions.set(otpVersion, otpMatch[0]) // we keep the original for later reference
+    otpVersionsListings.forEach((otpVersionsListing) => {
+      JSON.parse(otpVersionsListing)
+        .map((x) => x.assets)
+        .flat()
+        .filter((x) => x.name.match(/^otp_win64_.*.exe$/))
+        .forEach((x) => {
+          const otpMatch = x.name.match(/^otp_win64_(.*).exe$/)
+          const otpVersion = otpMatch[1]
+          otpVersions.set(otpVersion, otpVersion)
+        })
     })
+  }
 
   return otpVersions
 }
 
 async function getElixirVersions() {
-  const elixirVersionsListing = await get(
+  const elixirVersionsListings = await get(
     'https://repo.hex.pm/builds/elixir/builds.txt',
+    [null],
   )
   const otpVersionsForElixirMap = new Map()
 
-  elixirVersionsListing
+  elixirVersionsListings
     .trim()
     .split('\n')
     .forEach((line) => {
       const elixirMatch =
-        line.match(/^(.+)-otp-([^ ]+)/) || line.match(/^([^ ]+)/)
+        line.match(/^v?(.+)-otp-([^ ]+)/) || line.match(/^v?([^ ]+)/)
       const elixirVersion = elixirMatch[1]
       const otpVersion = elixirMatch[2]
       const otpVersions = otpVersionsForElixirMap.get(elixirVersion) || []
@@ -221,65 +305,180 @@ async function getElixirVersions() {
   return otpVersionsForElixirMap
 }
 
-async function getRebar3Versions() {
+async function getGleamVersions() {
-  const resultJSON = await get(
+  const resultJSONs = await get(
-    'https://api.github.com/repos/erlang/rebar3/releases?per_page=100',
+    'https://api.github.com/repos/gleam-lang/gleam/releases?per_page=100',
+    [1, 2, 3],
   )
-  const rebar3VersionsListing = JSON.parse(resultJSON)
+  const gleamVersionsListing = []
-    .map((x) => x.tag_name)
+  resultJSONs.forEach((resultJSON) => {
-    .sort()
+    JSON.parse(resultJSON)
+      .map((x) => x.tag_name)
+      .sort()
+      .forEach((v) => gleamVersionsListing.push(v))
+  })
+  return gleamVersionsListing
+}
 
+async function getRebar3Versions() {
+  const resultJSONs = await get(
+    'https://api.github.com/repos/erlang/rebar3/releases?per_page=100',
+    [1, 2, 3],
+  )
+  const rebar3VersionsListing = []
+  resultJSONs.forEach((resultJSON) => {
+    JSON.parse(resultJSON)
+      .map((x) => x.tag_name)
+      .sort()
+      .forEach((v) => rebar3VersionsListing.push(v))
+  })
   return rebar3VersionsListing
 }
 
 function getVersionFromSpec(spec, versions) {
-  if (versions.includes(spec)) {
+  let version = null
-    return spec
+
+  if (
+    spec.match(/rc/) ||
+    core.getInput('version-type', { required: false }) === 'strict'
+  ) {
+    version = spec
   }
 
-  return semver.maxSatisfying(versions, semver.validRange(spec))
+  if (version === null) {
+    // We keep a map of semver => "spec" in order to use semver ranges to find appropriate versions
+    const versionsMap = versions.sort(sortVersions).reduce((acc, v) => {
+      if (!v.match(/rc/)) {
+        // release candidates are opt-in
+        acc[maybeCoerced(v)] = v
+      }
+      return acc
+    }, {})
+    const rangeForMax = semver.validRange(spec)
+    if (rangeForMax) {
+      version =
+        versionsMap[semver.maxSatisfying(Object.keys(versionsMap), rangeForMax)]
+    } else {
+      version = versionsMap[maybeCoerced(spec)]
+    }
+  }
+
+  return version === null || version === undefined ? null : version
+}
+
+function maybeCoerced(v) {
+  let ret
+
+  try {
+    ret = semver.coerce(v).version
+  } catch {
+    // some stuff can't be coerced, like 'master'
+    ret = v
+  }
+
+  return ret
+}
+
+function sortVersions(left, right) {
+  let ret = 0
+  const newL = verAsComparableStr(left)
+  const newR = verAsComparableStr(right)
+
+  function verAsComparableStr(ver) {
+    const matchGroups = 5
+    const verSpec = /([^.]+)?\.?([^.]+)?\.?([^.]+)?\.?([^.]+)?\.?([^.]+)?/
+    const matches = ver.match(verSpec).splice(1, matchGroups)
+    return matches.reduce((acc, v) => acc + (v || '0').padStart(3, '0'), '')
+  }
+
+  if (newL < newR) {
+    ret = -1
+  } else if (newL > newR) {
+    ret = 1
+  }
+
+  return ret
 }
 
 function getRunnerOSVersion() {
-  const mapToUbuntuVersion = {
+  const ImageOSToContainer = {
-    ubuntu16: 'ubuntu-16.04',
     ubuntu18: 'ubuntu-18.04',
     ubuntu20: 'ubuntu-20.04',
+    win19: 'windows-2019',
+  }
+  const containerFromEnvImageOS = ImageOSToContainer[process.env.ImageOS]
+
+  if (!containerFromEnvImageOS) {
+    throw new Error(
+      "Tried to map a target OS from env. variable 'ImageOS' (got " +
+        `${process.env.ImageOS}` +
+        "), but failed. If you're using a " +
+        "self-hosted runner, you should set 'env': 'ImageOS': ... to one of the following: " +
+        "['" +
+        `${Object.keys(ImageOSToContainer).join("', '")}` +
+        "']",
+    )
   }
 
-  return mapToUbuntuVersion[process.env.ImageOS] || 'ubuntu-18.04'
+  return containerFromEnvImageOS
 }
 
-function get(url) {
+async function get(url0, pageIdxs) {
-  return new Promise((resolve, reject) => {
+  function getPage(pageIdx) {
-    https
+    return new Promise((resolve, reject) => {
-      .get(
+      const url = new URL(url0)
-        url,
+      if (pageIdx !== null) {
-        {
+        url.searchParams.append('page', pageIdx)
-          headers: { 'user-agent': 'setup-beam' },
+      }
-        },
+      https
-        (res) => {
+        .get(
-          let data = ''
+          url,
-          res.on('data', (chunk) => {
+          {
-            data += chunk
+            headers: { 'user-agent': 'setup-beam' },
-          })
+          },
-          res.on('end', () => {
+          (res) => {
-            resolve(data)
+            let data = ''
-          })
+            res.on('data', (chunk) => {
-        },
+              data += chunk
-      )
+            })
-      .on('error', (err) => {
+            res.on('end', () => {
-        reject(err)
+              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)
+        })
+    })
+  }
+  let ret
+  if (pageIdxs[0] === null) {
+    ret = getPage(null)
+  } else {
+    ret = Promise.all(pageIdxs.map((pageIdx) => getPage(pageIdx)))
+  }
+  return ret
 }
 
-function prependToPath(what) {
+function maybePrependWithV(versionToPrepend, specVersion) {
-  process.env.PATH = `${what}:${process.env.PATH}`
+  const digitStart = new RegExp('^\\d+')
+  return digitStart.test(specVersion)
+    ? `v${versionToPrepend}`
+    : versionToPrepend
 }
 
 module.exports = {
   getOTPVersion,
   getElixirVersion,
+  getGleamVersion,
   getRebar3Version,
+  getVersionFromSpec,
 }

test-projects/gleam_gleam/.github/workflows/test.yml

@@ -0,0 +1,21 @@
+name: test
+
+on:
+  push:
+    branches:
+      - master
+      - main
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2.0.0
+      - uses: erlef/setup-beam@v1.9.0
+        with:
+          otp-version: "23.2"
+          gleam-version: "0.19.0-rc3"
+      - run: gleam format --check src test
+      - run: gleam deps download
+      - run: gleam test

test-projects/gleam_gleam/.gitignore

@@ -0,0 +1,4 @@
+*.beam
+*.ez
+build
+erl_crash.dump

test-projects/gleam_gleam/README.md

@@ -0,0 +1,19 @@
+# gleam_gleam
+
+A Gleam project
+
+## Quick start
+
+```sh
+gleam run   # Run the project
+gleam test  # Run the tests
+gleam shell # Run an Erlang shell
+```
+
+## Installation
+
+If available on Hex this package can be added to your Gleam project.
+
+```sh
+gleam add gleam_gleam
+```

test-projects/gleam_gleam/gleam.toml

@@ -0,0 +1,16 @@
+name = "gleam_gleam"
+version = "0.1.0"
+
+# Fill out these fields if you intend to generate HTML documentation or publish
+# your project to the Hex package manager.
+#
+# licences = ["Apache-2.0"]
+# description = "A Gleam library..."
+# repository = { type = "github", user = "username", repo = "project" }
+# links = [{ title = "Website", href = "https://gleam.run" }]
+
+[dependencies]
+gleam_stdlib = "~> 0.18"
+
+[dev-dependencies]
+gleeunit = "~> 0.5"

test-projects/gleam_gleam/manifest.toml

@@ -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.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"

test-projects/gleam_gleam/src/gleam_gleam.gleam

@@ -0,0 +1,5 @@
+import gleam/io
+
+pub fn main() {
+  io.println("Hello from gleam_gleam!")
+}

test-projects/gleam_gleam/test/gleam_gleam_test.gleam

@@ -0,0 +1,12 @@
+import gleeunit
+import gleeunit/should
+
+pub fn main() {
+  gleeunit.main()
+}
+
+// gleeunit test functions end in `_test`
+pub fn hello_world_test() {
+  1
+  |> should.equal(1)
+}

test-projects/gleam_rebar3/.github/workflows/test.yml

@@ -0,0 +1,23 @@
+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

test-projects/gleam_rebar3/.gitignore

@@ -0,0 +1,21 @@
+*.beam
+*.iml
+*.o
+*.plt
+*.swo
+*.swp
+*~
+.erlang.cookie
+.eunit
+.idea
+.rebar
+.rebar3
+_*
+_build
+docs
+ebin
+erl_crash.dump
+gen
+log
+logs
+rebar3.crashdump

test-projects/gleam_rebar3/README.md

@@ -0,0 +1,24 @@
+# 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
+]}.
+```

test-projects/gleam_rebar3/gleam.toml

@@ -0,0 +1,3 @@
+name = "gleam_rebar3"
+
+# repository = { type = "github", user = "my-user", repo = "gleam_rebar3" }

test-projects/gleam_rebar3/rebar.config

@@ -0,0 +1,12 @@
+{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"}
+]}.

test-projects/gleam_rebar3/src/gleam_rebar3.app.src

@@ -0,0 +1,15 @@
+{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, []}
+]}.

test-projects/gleam_rebar3/src/gleam_rebar3.gleam

@@ -0,0 +1,3 @@
+pub fn hello_world() -> String {
+  "Hello, from gleam_rebar3!"
+}

test-projects/gleam_rebar3/test/gleam_rebar3_test.gleam

@@ -0,0 +1,7 @@
+import gleam_rebar3
+import gleam/should
+
+pub fn hello_world_test() {
+  gleam_rebar3.hello_world()
+  |> should.equal("Hello, from gleam_rebar3!")
+}