Support Linux and macOS

Author: oprypin

.eslintrc.json

@@ -28,7 +28,6 @@
         "no-self-compare": "error",
         "no-sequences": "error",
         "no-useless-return": "error",
-        "require-await": "error",
         "yoda": "error",
 
         "brace-style": "error",

.github/workflows/main.yml

@@ -1,17 +1,18 @@
 name: CI
 
 on:
-  pull_request:
   push:
-    branches:
-      - master
-      - v1
+  pull_request:
   schedule:
     - cron: '0 6 * * 6'
 
 jobs:
   test:
-    runs-on: windows-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v2
       - run: npm install

.github/workflows/release.yml

@@ -9,7 +9,11 @@ on:
 
 jobs:
   test:
-    runs-on: windows-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
     steps:
       - uses: oprypin/install-crystal@v1
       - run: crystal eval "puts 1337"

.util/sudo

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+sleep 10

README.md

@@ -3,7 +3,7 @@ install-crystal
 
 [GitHub Action][] to **install [Crystal][] programming language**
 
-Currently works only on Windows, always downloads the latest "nightly" build.
+Works on Ubuntu, macOS, Windows.
 
 ## Examples
 
@@ -17,14 +17,30 @@ steps:
 
 ### Inputs
 
-* **`token: ${{ github.token }}`**
+* **`crystal: 0.34.0`** (not supported on Windows)
 
-  Personal access token (auto-populated).
+  Install a particular release of Crystal.
+
+* **`crystal: latest`** (default; not supported on Windows)
+
+  Install the latest released version of Crystal.
+
+* **`crystal: nightly`** (default on Windows; not supported on other systems)
+
+  Install Crystal from the latest continuous build on [crystal.git][] master.
+
+* **`arch: x86_64`**, **`arch: x86`** (defaults to current OS arch)
+
+  The architecture of the build of Crystal to download.
 
 * **`destination: some/path`**
 
   The directory to store Crystal in, after extracting.
 
+* **`token: ${{ github.token }}`**
+
+  Personal access token (auto-populated).
+
 ### Outputs
 
 * **`crystal`** (`${{ steps.some_step_id.outputs.crystal }}`)

index.js

@@ -8,19 +8,149 @@ const FS = require("fs").promises;
 
 async function run() {
     try {
-        const path = await downloadCrystalForWindows();
-        await setupCrystalForWindows(path);
+        const params = {};
+        for (const key of ["crystal", "arch", "destination"]) {
+            let value;
+            if ((value = Core.getInput(key))) {
+                params[key] = value;
+            }
+        }
+        const func = {
+            [Linux]: installCrystalForLinux,
+            [Mac]: installCrystalForMac,
+            [Windows]: installCrystalForWindows,
+        }[getPlatform()];
+        if (!func) {
+            throw `Platform "${getPlatform()}" is not supported`;
+        }
+        await func(params);
     } catch (error) {
         Core.setFailed(error);
+        process.exit(1);
     }
 }
 
+const Linux = "Linux", Mac = "macOS", Windows = "Windows";
+
+function getPlatform() {
+    const platform = process.env["INSTALL_CRYSTAL_PLATFORM"] || process.platform;
+    return {"linux": Linux, "darwin": Mac, "win32": Windows}[platform] || platform;
+}
+
+function getArch() {
+    return {"ia32": "x86", "x64": "x86_64"}[process.arch] || process.arch;
+}
+
+function checkArch(arch, allowed) {
+    if (!allowed.includes(arch)) {
+        throw `Architecture "${arch}" is not supported on ${getPlatform()}`;
+    }
+}
+
+const Latest = "latest";
+const Nightly = "nightly";
+const NumericVersion = /^\d[.\d]+\d$/;
+
+function checkVersion(version, allowed) {
+    const numericVersion = version.match(NumericVersion) && version;
+    allowed[allowed.indexOf(NumericVersion)] = numericVersion;
+
+    if (allowed.includes(version)) {
+        return version;
+    }
+    if ([Latest, Nightly, numericVersion].includes(version)) {
+        throw `Version "${version}" is not supported on ${getPlatform()}`;
+    }
+    throw `Version "${version}" is invalid`;
+}
+
+async function installCrystalForLinux({
+    crystal = Latest,
+    arch = getArch(),
+    destination = null,
+}) {
+    checkVersion(crystal, [Latest, NumericVersion]);
+    const suffixes = {"x86_64": "linux-x86_64", "x86": "linux-i686"};
+    checkArch(arch, Object.keys(suffixes));
+
+    return Promise.all([
+        installAptPackages(
+            "libevent-dev libgmp-dev libpcre3-dev libssl-dev libxml2-dev libyaml-dev".split(" "),
+        ),
+        installBinaryRelease({crystal, suffix: suffixes[arch], destination}),
+    ]);
+}
+
+async function installCrystalForMac({
+    crystal = Latest,
+    arch = "x86_64",
+    destination = null,
+}) {
+    checkVersion(crystal, [Latest, NumericVersion]);
+    checkArch(arch, ["x86_64"]);
+    return installBinaryRelease({crystal, suffix: "darwin-x86_64", destination});
+}
+
+async function installAptPackages(packages) {
+    const execFile = Util.promisify(ChildProcess.execFile);
+    Core.info("Installing package dependencies");
+    const args = [
+        "-n", "apt-get", "install", "-qy", "--no-install-recommends", "--no-upgrade", "--",
+    ].concat(packages);
+    Core.info("[command]sudo " + args.join(" "));
+    const {stdout} = await execFile("sudo", args);
+    Core.startGroup("Finished installing package dependencies");
+    Core.info(stdout);
+    Core.endGroup();
+}
+
+async function installBinaryRelease({crystal, suffix, destination}) {
+    if (crystal === Latest) {
+        crystal = null;
+    }
+    const path = await downloadCrystalRelease({suffix, tag: crystal, destination});
+
+    Core.info("Setting up environment");
+    Core.addPath(Path.join(path, "bin"));
+}
+
+async function downloadCrystalRelease({suffix, tag = null, destination = null}) {
+    Core.info("Looking for latest Crystal release");
+
+    const releasesResp = await githubGet({
+        url: "/repos/crystal-lang/crystal/releases/" + (tag ? "tags/" + tag : "latest"),
+    });
+    const release = releasesResp.data;
+    Core.info("Found " + release["html_url"]);
+    Core.setOutput("crystal", release["tag_name"]);
+
+    const asset = release["assets"].find((a) => a["name"].endsWith([`-${suffix}.tar.gz`]));
+
+    Core.info("Downloading Crystal build");
+    const downloadedPath = await ToolCache.downloadTool(asset["browser_download_url"]);
+
+    Core.info("Extracting Crystal build");
+    return onlySubdir(await ToolCache.extractTar(downloadedPath, destination));
+}
+
+async function installCrystalForWindows({
+    crystal = Nightly,
+    arch = "x86_64",
+    destination = null,
+}) {
+    checkVersion(crystal, [Nightly]);
+    checkArch(arch, ["x86_64"]);
+    const path = await downloadCrystalForWindows(destination);
+    await setupCrystalForWindows(path);
+}
+
 async function setupCrystalForWindows(path) {
     Core.info("Setting up environment");
     const vars = await variablesForVCBuildTools();
     addPathToVars(vars, "PATH", path);
     addPathToVars(vars, "LIB", path);
     addPathToVars(vars, "CRYSTAL_PATH", Path.join(path, "src"));
+    addPathToVars(vars, "CRYSTAL_PATH", "lib");
     for (const [k, v] of vars.entries()) {
         Core.exportVariable(k, v);
     }
@@ -41,6 +171,7 @@ const vcvarsPath = String.raw`C:\Program Files (x86)\Microsoft Visual Studio\201
 async function variablesForVCBuildTools() {
     const exec = Util.promisify(ChildProcess.exec);
     const command = `set && echo ${outputSep} && "${vcvarsPath}" >nul && set`;
+    Core.info(`[command]cmd /c "${command}"`);
     const {stdout} = await exec(command, {shell: "cmd"});
     Core.debug(JSON.stringify(stdout));
     return new Map(getChangedVars(stdout.trimEnd().split(/\r?\n/)));
@@ -66,7 +197,7 @@ function* getChangedVars(lines) {
     }
 }
 
-async function downloadCrystalForWindows() {
+async function downloadCrystalForWindows(destination = null) {
     Core.info("Looking for latest Crystal build");
 
     const runsResp = await githubGet({
@@ -91,9 +222,7 @@ async function downloadCrystalForWindows() {
         const downloadedPath = await ToolCache.downloadTool(downloadUrl);
 
         Core.info("Extracting Crystal source");
-        const extractedPath = await ToolCache.extractZip(downloadedPath, destDir);
-        const [subDir] = await FS.readdir(extractedPath);
-        return Path.join(extractedPath, subDir);
+        return onlySubdir(await ToolCache.extractZip(downloadedPath, destDir));
     };
 
     const fetchExeTask = async () => {
@@ -106,7 +235,6 @@ async function downloadCrystalForWindows() {
         const artifactLinkResp = await githubGet({
             url: "/repos/crystal-lang/crystal/actions/artifacts/:artifact_id/zip",
             "artifact_id": artifact.id,
-            headers: {"authorization": "token " + Core.getInput("token")},
             request: {redirect: "manual"},
         });
         const downloadUrl = artifactLinkResp.headers["location"];
@@ -116,7 +244,7 @@ async function downloadCrystalForWindows() {
     };
 
     const [srcPath, exeDownloadedPath] = await Promise.all([
-        fetchSrcTask(Core.getInput("destination")),
+        fetchSrcTask(destination),
         fetchExeTask(),
     ]);
 
@@ -126,7 +254,14 @@ async function downloadCrystalForWindows() {
 
 function githubGet(request) {
     Core.debug(request);
-    return Octokit.request(request);
+    return Octokit.request.defaults({
+        headers: {"authorization": "token " + Core.getInput("token")},
+    })(request);
+}
+
+async function onlySubdir(path) {
+    const [subDir] = await FS.readdir(path);
+    return Path.join(path, subDir);
 }
 
 if (require.main === module) {