Support transparent usage of patch versions for GHC on Windows

Author: Jared Weakly

setup/.lintstagedrc.js

@@ -1,6 +1,9 @@
 module.exports = {
-  '!(*test).{js,ts}': 'eslint --cache --fix',
-  '!(*test).ts': () => ['ncc build', 'git add dist'],
+  '!(*test).{js,ts}': [
+    'eslint --cache --fix',
+    () => 'ncc build',
+    () => 'git add dist'
+  ],
   'src/**/*.ts': () => 'tsc -p tsconfig.json',
   '*.{js,ts,json,md}': 'prettier --write'
 };

setup/__tests__/find-haskell.test.ts

@@ -1,21 +1,32 @@
-import {getOpts, getDefaults, Tool} from '../src/opts';
+import {getOpts, getDefaults} from '../src/opts';
+import type {OS, Revisions, Tool} from '../src/opts';
 import {getInput} from '@actions/core';
 import * as supported_versions from '../src/versions.json';
+import * as rv from '../src/release-revisions.json';
 
-const def = getDefaults();
+const release_revisions = rv as Revisions;
+const def = (os: OS) => getDefaults(os);
 const latestVersions = {
   ghc: supported_versions.ghc[0],
   cabal: supported_versions.cabal[0],
   stack: supported_versions.stack[0]
 };
+const latestRevisions = (os: OS) => ({
+  ghc: release_revisions?.[os]?.ghc?.[0]?.to,
+  cabal: release_revisions?.[os]?.cabal?.[0]?.to,
+  stack: release_revisions?.[os]?.stack?.[0]?.to
+});
 
 const mkName = (s: string): string =>
   `INPUT_${s.replace(/ /g, '_').toUpperCase()}`;
 
 const setupEnv = (o: Record<string, unknown>): void =>
   Object.entries(o).forEach(([k, v]) => v && (process.env[mkName(k)] = `${v}`));
 
-const forAll = (fn: (t: Tool) => any) =>
+const forAllOS = (fn: (t: OS) => any) =>
+  (['win32', 'darwin', 'linux'] as const).forEach(fn);
+
+const forAllTools = (fn: (t: Tool) => any) =>
   (['ghc', 'cabal', 'stack'] as const).forEach(fn);
 
 describe('haskell/actions/setup', () => {
@@ -30,11 +41,19 @@ describe('haskell/actions/setup', () => {
   afterEach(() => (process.env = OLD_ENV));
 
   it('Parses action.yml to get correct default versions', () => {
-    forAll(t => expect(def[t].version).toBe(latestVersions[t]));
+    forAllOS(os =>
+      forAllTools(t =>
+        expect(def(os)[t].version).toBe(
+          latestRevisions(os)[t] ?? latestVersions[t]
+        )
+      )
+    );
   });
 
   it('Supported versions are parsed from JSON correctly', () =>
-    forAll(t => expect(def[t].supported).toBe(supported_versions[t])));
+    forAllOS(os =>
+      forAllTools(t => expect(def(os)[t].supported).toBe(supported_versions[t]))
+    ));
 
   it('[meta] Setup Env works', () => {
     setupEnv({input: 'value'});
@@ -44,8 +63,10 @@ describe('haskell/actions/setup', () => {
 
   it('getOpts grabs defaults correctly from environment', () => {
     setupEnv({});
-    const options = getOpts(def);
-    forAll(t => expect(options[t].raw).toBe(def[t].version));
+    forAllOS(os => {
+      const options = getOpts(def(os), os);
+      forAllTools(t => expect(options[t].raw).toBe(def(os)[t].version));
+    });
   });
 
   it('Versions resolve correctly', () => {
@@ -55,8 +76,10 @@ describe('haskell/actions/setup', () => {
       'ghc-version': '8.6',
       'cabal-version': '2.4'
     });
-    const options = getOpts(def);
-    forAll(t => expect(options[t].resolved).toBe(v[t]));
+    forAllOS(os => {
+      const options = getOpts(def(os), os);
+      forAllTools(t => expect(options[t].resolved).toBe(v[t]));
+    });
   });
 
   it('"latest" Versions resolve correctly', () => {
@@ -65,37 +88,47 @@ describe('haskell/actions/setup', () => {
       'ghc-version': 'latest',
       'cabal-version': 'latest'
     });
-    const options = getOpts(def);
-    forAll(t => expect(options[t].resolved).toBe(latestVersions[t]));
+    forAllOS(os => {
+      const options = getOpts(def(os), os);
+      forAllTools(t =>
+        expect(options[t].resolved).toBe(
+          latestRevisions(os)[t] ?? latestVersions[t]
+        )
+      );
+    });
   });
 
   it('Enabling stack does not disable GHC or Cabal', () => {
     setupEnv({'enable-stack': 'true'});
-    const {ghc, cabal, stack} = getOpts(def);
-    expect({
-      ghc: ghc.enable,
-      stack: stack.enable,
-      cabal: cabal.enable
-    }).toStrictEqual({ghc: true, cabal: true, stack: true});
+    forAllOS(os => {
+      const {ghc, cabal, stack} = getOpts(def(os), os);
+      expect({
+        ghc: ghc.enable,
+        stack: stack.enable,
+        cabal: cabal.enable
+      }).toStrictEqual({ghc: true, cabal: true, stack: true});
+    });
   });
 
   it('Enabling stack-no-global disables GHC and Cabal', () => {
     setupEnv({'enable-stack': 'true', 'stack-no-global': 'true'});
-    const {ghc, cabal, stack} = getOpts(def);
-    expect({
-      ghc: ghc.enable,
-      cabal: cabal.enable,
-      stack: stack.enable
-    }).toStrictEqual({ghc: false, cabal: false, stack: true});
+    forAllOS(os => {
+      const {ghc, cabal, stack} = getOpts(def(os), os);
+      expect({
+        ghc: ghc.enable,
+        cabal: cabal.enable,
+        stack: stack.enable
+      }).toStrictEqual({ghc: false, cabal: false, stack: true});
+    });
   });
 
   it('Enabling stack-no-global without setting enable-stack errors', () => {
     setupEnv({'stack-no-global': 'true'});
-    expect(() => getOpts(def)).toThrow();
+    forAllOS(os => expect(() => getOpts(def(os), os)).toThrow());
   });
 
   it('Enabling stack-setup-ghc without setting enable-stack errors', () => {
     setupEnv({'stack-setup-ghc': 'true'});
-    expect(() => getOpts(def)).toThrow();
+    forAllOS(os => expect(() => getOpts(def(os), os)).toThrow());
   });
 });