Implement fallback install and outputs (#2)

* Add better version support. Restructure code. Implement OS agnostic fallback

* Support latest for cabal and stack. Add enable-stack option.

* Add outputs

* Update documentation. Change default for GHC to latest.

__tests__/find-haskell.test.ts

@@ -1,23 +1,18 @@
-import {getOpts, getDefaults} from '../src/installer';
+import {getOpts, getDefaults, Tool} from '../src/opts';
 import {getInput} from '@actions/core';
+import * as supported_versions from '../src/versions.json';
 
 const def = getDefaults();
 
-const environments = {
-  empty: {'ghc-version': null, 'cabal-version': null},
-  stack: {'stack-version': '2.1.3'},
-  stacklatest: {'stack-version': 'latest'},
-  stackOnly: {'stack-version': 'latest', 'stack-no-global': 'true'},
-  stackOnlyWrong: {'stack-no-global': 'true'},
-  stackOnlyWrong2: {'stack-setup-ghc': 'true'}
-};
-
 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) =>
+  (['ghc', 'cabal', 'stack'] as const).forEach(fn);
+
 describe('actions/setup-haskell', () => {
   const OLD_ENV = process.env;
 
@@ -29,13 +24,13 @@ describe('actions/setup-haskell', () => {
 
   afterEach(() => (process.env = OLD_ENV));
 
-  it('Parses action.yml to get correct default GHC', () => {
-    expect(def.ghc.version).toBe('8.8.3');
+  it('Parses action.yml to get correct default versions', () => {
+    const defs = {ghc: '8.10.1', cabal: '3.2.0.0', stack: '2.1.3'};
+    forAll(t => expect(def[t].version).toBe(defs[t]));
   });
 
-  it('Parses action.yml to get correct default Cabal', () => {
-    expect(def.cabal.version).toBe('3.0.0.0');
-  });
+  it('Supported versions are parsed from JSON correctly', () =>
+    forAll(t => expect(def[t].supported).toBe(supported_versions[t])));
 
   it('[meta] Setup Env works', () => {
     setupEnv({input: 'value'});
@@ -44,36 +39,60 @@ describe('actions/setup-haskell', () => {
   });
 
   it('getOpts grabs defaults correctly from environment', () => {
-    setupEnv(environments.empty);
+    setupEnv({});
     const options = getOpts(def);
-    expect(options.ghc.version).toBe(def.ghc.version);
+    forAll(t => expect(options[t].raw).toBe(def[t].version));
   });
 
-  it('Enabling stack does not disable GHC', () => {
-    setupEnv(environments.stack);
-    const {ghc, stack} = getOpts(def);
-    expect({
-      ghc: ghc.enable,
-      stack: stack.enable
-    }).toStrictEqual({ghc: true, stack: true});
+  it('Versions resolve correctly', () => {
+    const v = {ghc: '8.6.5', cabal: '2.4.1.0', stack: '2.1.3'};
+    setupEnv({
+      'stack-version': '2.1',
+      'ghc-version': '8.6',
+      'cabal-version': '2.4'
+    });
+    const options = getOpts(def);
+    forAll(t => expect(options[t].resolved).toBe(v[t]));
   });
 
-  it('Enabling stack-no-global does disable GHC and Cabal', () => {
-    setupEnv(environments.stackOnly);
-    const {ghc, cabal} = getOpts(def);
+  it('"latest" Versions resolve correctly', () => {
+    const v = {ghc: '8.6.5', cabal: '2.4.1.0', stack: '2.1.3'};
+    setupEnv({
+      'stack-version': '2.1',
+      'ghc-version': '8.6',
+      'cabal-version': '2.4'
+    });
+    const options = getOpts(def);
+    forAll(t => expect(options[t].resolved).toBe(v[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: false, cabal: false});
+    }).toStrictEqual({ghc: true, cabal: true, stack: true});
   });
 
-  it('Enabling stack-no-global without setting stack-version errors', () => {
-    setupEnv(environments.stackOnlyWrong);
+  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});
+  });
+
+  it('Enabling stack-no-global without setting enable-stack errors', () => {
+    setupEnv({'stack-no-global': 'true'});
     expect(() => getOpts(def)).toThrow();
   });
 
-  it('Enabling stack-setup-ghc without setting stack-version errors', () => {
-    setupEnv(environments.stackOnlyWrong2);
+  it('Enabling stack-setup-ghc without setting enable-stack errors', () => {
+    setupEnv({'stack-setup-ghc': 'true'});
     expect(() => getOpts(def)).toThrow();
   });
 });