feat!: support installing multiple binaries

Please note the `repo` input has been renamed to `targets` to more
clearly describe the input's behavior in light of this new feature.

To install multiple binaries, pass a whitespace-separated list:

```yaml
- name: Install flux-capacitor
  uses: EricCrosson/install-github-release-binary@v1
  with:
    targets: |
      EricCrosson/flux-capacitor@v1
      EricCrosson/steam-locomotive@v7.5.3
```

Why the name `targets` and not `target`? Or maybe an alias from
`target` to `targets`?

If we accept multiple inputs, one of which has to be present,
the simple input metadata can no longer describe this contract.

Choose `targets` over `target` because a list of one is still a list!

BREAKING CHANGE: rename `repo` to `targets`

Author: EricCrosson

README.md

@@ -35,17 +35,28 @@ Use this action in a step:
 - name: Install flux-capacitor
   uses: EricCrosson/install-github-release-binary@v1
   with:
-    repo: EricCrosson/flux-capacitor@v1
+    targets: EricCrosson/flux-capacitor@v1
+```
+
+Install multiple binaries:
+
+```yaml
+- name: Install flux-capacitor
+  uses: EricCrosson/install-github-release-binary@v1
+  with:
+    targets: |
+      EricCrosson/flux-capacitor@v1
+      EricCrosson/steam-locomotive@v7.5.3
 ```
 
 ## Inputs
 
-| Input Parameter | Required | Description                                                                          |
-| :-------------: | :------: | ------------------------------------------------------------------------------------ |
-|      repo       |   true   | Target repository slug and tag. [Details](#repo)                                     |
-|      token      |  false   | GitHub token for REST requests. Defaults to `${{ github.token }}`. [Details](#token) |
+| Input Parameter | Required | Description                                                                                                     |
+| :-------------: | :------: | --------------------------------------------------------------------------------------------------------------- |
+|     targets     |   true   | Whitespace separated list of target GitHub Releases in format `{owner}/{repository}@{tag}`. [Details](#targets) |
+|      token      |  false   | GitHub token for REST requests. Defaults to `${{ github.token }}`. [Details](#token)                            |
 
-#### repo
+#### targets
 
 Target repository slug and tag.
 

action.yml

@@ -7,8 +7,8 @@ branding:
   color: green
 
 inputs:
-  repo:
-    description: Target GitHub repository slug and tag
+  targets:
+    description: Whitespace separated list of target GitHub Releases in format {owner}/{repository}@{tag}
     required: true
   token:
     description: GitHub access token or a Personal Access Token with 'repo' scope

src/either.ts

@@ -1,6 +1,6 @@
-export type Either<A> =
-  | { tag: "error"; errors: string[] }
-  | { tag: "ok"; value: A };
+export type Err = { tag: "error"; errors: string[] };
+export type Ok<A> = { tag: "ok"; value: A };
+export type Either<A> = Ok<A> | Err;
 
 export function error<A>(errors: string[]): Either<A> {
   return { tag: "error", errors };
@@ -10,6 +10,14 @@ export function ok<A>(value: A): Either<A> {
   return { tag: "ok", value };
 }
 
+export function isErr<A>(value: Either<A>): value is Err {
+  return value.tag === "error";
+}
+
+export function isOk<A>(value: Either<A>): value is Ok<A> {
+  return value.tag === "ok";
+}
+
 export function unwrap<A>(either: Either<A>): A {
   if (either.tag === "error") {
     throw new Error(

src/index.ts

@@ -10,7 +10,7 @@ import { getErrors, unwrap } from "./either";
 import { getOctokit, Octokit } from "./octokit";
 import {
   parseEnvironmentVariable,
-  parseTargetRelease,
+  parseTargetReleases,
   parseToken,
   TargetRelease,
 } from "./parse";
@@ -39,7 +39,7 @@ function getDestinationDirectory(
 
 async function installGitHubReleaseBinary(
   octokit: Octokit,
-  targetRelease: TargetRelease,
+  targetReleases: TargetRelease,
   storageDirectory: string,
   enableCache: boolean,
   token: string
@@ -48,18 +48,18 @@ async function installGitHubReleaseBinary(
 
   const releaseTag = await findExactSemanticVersionTag(
     octokit,
-    targetRelease.slug,
-    targetRelease.tag
+    targetReleases.slug,
+    targetReleases.tag
   );
 
   const destinationDirectory = getDestinationDirectory(
     storageDirectory,
-    targetRelease.slug,
+    targetReleases.slug,
     releaseTag,
     platform(),
     arch()
   );
-  const destinationBasename = targetRelease.slug.repository;
+  const destinationBasename = targetReleases.slug.repository;
   const destinationFilename = path.join(
     destinationDirectory,
     destinationBasename
@@ -70,8 +70,8 @@ async function installGitHubReleaseBinary(
   // so upstream updates are always pulled in.
   const cachePaths = [destinationFilename];
   const cacheKey = [
-    targetRelease.slug.owner.toLowerCase(),
-    targetRelease.slug.repository.toLowerCase(),
+    targetReleases.slug.owner.toLowerCase(),
+    targetReleases.slug.repository.toLowerCase(),
     releaseTag,
     targetTriple,
   ].join("-");
@@ -84,7 +84,7 @@ async function installGitHubReleaseBinary(
   if (restoreCache === undefined) {
     const releaseAsset = await fetchReleaseAssetMetadataFromTag(
       octokit,
-      targetRelease.slug,
+      targetReleases.slug,
       releaseTag,
       targetTriple
     );
@@ -112,10 +112,10 @@ async function main(): Promise<void> {
   const maybeToken = parseToken(
     process.env["GITHUB_TOKEN"] || core.getInput("token")
   );
-  const maybeTargetRelease = parseTargetRelease(core.getInput("repo"));
+  const maybeTargetReleases = parseTargetReleases(core.getInput("targets"));
   const maybeHomeDirectory = parseEnvironmentVariable("HOME");
 
-  const errors = [maybeToken, maybeTargetRelease, maybeHomeDirectory].flatMap(
+  const errors = [maybeToken, maybeTargetReleases, maybeHomeDirectory].flatMap(
     getErrors
   );
   if (errors.length > 0) {
@@ -124,7 +124,7 @@ async function main(): Promise<void> {
   }
 
   const token = unwrap(maybeToken);
-  const targetRelease = unwrap(maybeTargetRelease);
+  const targetReleases = unwrap(maybeTargetReleases);
   const homeDirectory = unwrap(maybeHomeDirectory);
   const enableCache = core.getInput("cache") === "true";
 
@@ -135,12 +135,16 @@ async function main(): Promise<void> {
   );
   const octokit = getOctokit(token);
 
-  await installGitHubReleaseBinary(
-    octokit,
-    targetRelease,
-    storageDirectory,
-    enableCache,
-    token
+  await Promise.all(
+    targetReleases.map((targetRelease) =>
+      installGitHubReleaseBinary(
+        octokit,
+        targetRelease,
+        storageDirectory,
+        enableCache,
+        token
+      )
+    )
   );
 }
 

src/parse.ts

@@ -1,6 +1,21 @@
-import { Either, error, ok } from "./either";
+import { Either, error, isOk, ok } from "./either";
 import type { RepositorySlug, SemanticVersion } from "./types";
 
+export function parseEnvironmentVariable(envVarName: string): Either<string> {
+  const value = process.env[envVarName];
+  if (value === undefined) {
+    return error([
+      `Expected environment variable '${envVarName}' to be defined`,
+    ]);
+  }
+  if (value.length === 0) {
+    return error([
+      `Expected environment variable '${envVarName}' to be non-empty`,
+    ]);
+  }
+  return ok(value);
+}
+
 export function parseToken(value: string): Either<string> {
   if (value.length === 0) {
     return error(["input.github expected to be non-empty"]);
@@ -13,10 +28,7 @@ export type TargetRelease = {
   tag: SemanticVersion;
 };
 
-export function parseTargetRelease(value: string): Either<TargetRelease> {
-  if (value.length === 0) {
-    return error(["input.repo not defined"]);
-  }
+function parseTargetRelease(value: string): Either<TargetRelease> {
   const errors: string[] = [];
   const repo_regex = /^(\S+)\/(\S+)$/;
   if (repo_regex.test(value) === null) {
@@ -54,17 +66,29 @@ export function parseTargetRelease(value: string): Either<TargetRelease> {
   return ok(target);
 }
 
-export function parseEnvironmentVariable(envVarName: string): Either<string> {
-  const value = process.env[envVarName];
-  if (value === undefined) {
-    return error([
-      `Expected environment variable '${envVarName}' to be defined`,
-    ]);
-  }
+export function parseTargetReleases(value: string): Either<TargetRelease[]> {
   if (value.length === 0) {
-    return error([
-      `Expected environment variable '${envVarName}' to be non-empty`,
-    ]);
+    return error(["input.targets not defined"]);
   }
-  return ok(value);
+  const tokens = value.trim().split(/\s+/);
+
+  const results: TargetRelease[] = [];
+  const errors: string[] = [];
+
+  for (const token of tokens) {
+    const release = parseTargetRelease(token);
+    if (isOk(release)) {
+      results.push(release.value);
+    } else {
+      const errorMessage =
+        `Encountered errors parsing target ${token}:` +
+        release.errors.map((error) => `\n  - ${error}`).join("\n");
+      errors.push(errorMessage);
+    }
+  }
+
+  if (errors.length > 0) {
+    return error(errors);
+  }
+  return ok(results);
 }

test/test-parse-target-release.ts

@@ -0,0 +1,123 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { parseTargetReleases, TargetRelease } from "../src/parse";
+import { Either, error, isErr, isOk, ok } from "../src/either";
+import type { SemanticVersion } from "../src/types";
+
+function err<A>(): Either<A> {
+  return error([""]);
+}
+
+function check(
+  input: string,
+  expectedOutput: Either<readonly TargetRelease[]>
+) {
+  // wrap in a thunk so we can pass it directly to `test`
+  const actualOutput = parseTargetReleases(input);
+  return function () {
+    if (isOk(expectedOutput)) {
+      assert.deepEqual(actualOutput, expectedOutput);
+    } else {
+      // I don't care too much right now what the error is
+      assert(isErr(actualOutput));
+    }
+  };
+}
+
+test("should not parse an empty string", check("", err()));
+
+test("should not parse a slug without a version", check("foo/bar", err()));
+
+test(
+  "should not parse a slug without a version starting with v",
+  check("foo/bar@1", err())
+);
+
+test(
+  "should parse a slug and version starting with v",
+  check(
+    "foo/bar@v1",
+    ok([
+      {
+        slug: {
+          owner: "foo",
+          repository: "bar",
+        },
+        tag: "v1" as SemanticVersion,
+      },
+    ])
+  )
+);
+
+test(
+  "should parse multiple targets separated with whitespace",
+  check(
+    "foo/bar@v1 qux/baz@v2.3.4",
+    ok([
+      {
+        slug: {
+          owner: "foo",
+          repository: "bar",
+        },
+        tag: "v1" as SemanticVersion,
+      },
+      {
+        slug: {
+          owner: "qux",
+          repository: "baz",
+        },
+        tag: "v2.3.4" as SemanticVersion,
+      },
+    ])
+  )
+);
+
+test(
+  "should parse multiple targets separated with whitespace with leading whitespace",
+  check(
+    `    
+   foo/bar@v1 qux/baz@v2.3.4`,
+    ok([
+      {
+        slug: {
+          owner: "foo",
+          repository: "bar",
+        },
+        tag: "v1" as SemanticVersion,
+      },
+      {
+        slug: {
+          owner: "qux",
+          repository: "baz",
+        },
+        tag: "v2.3.4" as SemanticVersion,
+      },
+    ])
+  )
+);
+
+test(
+  "should parse multiple targets separated with whitespace with trailing whitespace",
+  check(
+    `foo/bar@v1    
+  qux/baz@v2.3.4
+  `,
+    ok([
+      {
+        slug: {
+          owner: "foo",
+          repository: "bar",
+        },
+        tag: "v1" as SemanticVersion,
+      },
+      {
+        slug: {
+          owner: "qux",
+          repository: "baz",
+        },
+        tag: "v2.3.4" as SemanticVersion,
+      },
+    ])
+  )
+);