refactore, using inversify for dependency injection

src/github/GitVersion.ts

@@ -1,15 +0,0 @@
-import * as core from '@actions/core';
-import { ToolInstaller } from '../ToolInstaller';
-import { Proxy as utils }  from './Proxy';
-try {
-    let toolInstaller = new ToolInstaller(utils);
-    toolInstaller.downloadAndInstall('GitVersion.Tool', '5.1.2', false, false);
-    // `who-to-greet` input defined in action metadata file
-    const nameToGreet = core.getInput('who-to-greet');
-    console.log(`Hello ${nameToGreet}!`);
-    const time = (new Date()).toTimeString();
-    core.setOutput("time", time);
-    // Get the JSON webhook payload for the event that triggered the workflow
-} catch (error) {
-    core.setFailed(error.message);
-}

src/github/Proxy.ts

@@ -1,20 +0,0 @@
-import { find, cacheDir } from '@actions/tool-cache';
-import { debug, exportVariable, addPath } from '@actions/core';
-import { which } from '@actions/io';
-
-import { isExplicitVersion, evaluateVersions, createTempDir, cleanVersion, executeDotNet } from './ToolLib';
-import { IProxy } from '../Interfaces';
-
-export const Proxy: IProxy = {
-    find : find,
-    debug: debug,
-    exportVariable: exportVariable,
-    addPath: addPath,
-    which: which,
-    cacheDir: cacheDir,
-    isExplicitVersion: isExplicitVersion,
-    evaluateVersions: evaluateVersions,
-    cleanVersion: cleanVersion,
-    createTempDir: createTempDir,
-    executeDotNet: executeDotNet
-}

src/github/ToolLib.ts

@@ -1,114 +0,0 @@
-import * as path from 'path';
-import * as semver from 'semver';
-import * as uuidV4 from "uuid/v4";
-
-import * as io from '@actions/io';
-import * as core from '@actions/core';
-import * as exec from '@actions/exec';
-import { IExecSyncResult } from '../Interfaces';
-
-const cmp = require('semver-compare');
-
-export async function createTempDir(): Promise<string> {
-    const IS_WINDOWS = process.platform === "win32";
-
-    let tempDirectory: string = process.env["RUNNER_TEMP"] || "";
-
-    if (!tempDirectory) {
-        let baseLocation: string;
-        if (IS_WINDOWS) {
-            // On Windows use the USERPROFILE env variable
-            baseLocation = process.env["USERPROFILE"] || "C:\\";
-        } else {
-            if (process.platform === "darwin") {
-                baseLocation = "/Users";
-            } else {
-                baseLocation = "/home";
-            }
-        }
-        tempDirectory = path.join(baseLocation, "actions", "temp");
-    }
-    const dest = path.join(tempDirectory, uuidV4());
-    await io.mkdirP(dest);
-    return dest;
-}
-
-/**
- * Checks if a version spec is an explicit version (e.g. 1.0.1 or v1.0.1)
- * As opposed to a version spec like 1.x
- *
- * @param versionSpec
- */
-export function isExplicitVersion(versionSpec: string): boolean {
-    let c = semver.clean(versionSpec);
-    core.debug('isExplicit: ' + c);
-
-    let valid = semver.valid(c) != null;
-    core.debug('explicit? ' + valid);
-
-    return valid;
-}
-
-/**
- * Returns cleaned (removed leading/trailing whitespace, remove '=v' prefix)
- * and parsed version, or null if version is invalid.
- */
-export function cleanVersion(version: string): string {
-    core.debug('cleaning: ' + version);
-    return semver.clean(version);
-}
-
-/**
- * evaluates a list of versions and returns the latest version matching the version spec
- *
- * @param versions      an array of versions to evaluate
- * @param versionSpec   a version spec (e.g. 1.x)
- */
-export function evaluateVersions(versions: string[], versionSpec: string): string {
-    let version: string;
-    core.debug('evaluating ' + versions.length + ' versions');
-    versions = versions.sort(cmp);
-    for (let i = versions.length - 1; i >= 0; i--) {
-        let potential: string = versions[i];
-        let satisfied: boolean = semver.satisfies(potential, versionSpec);
-        if (satisfied) {
-            version = potential;
-            break;
-        }
-    }
-
-    if (version) {
-        core.debug('matched: ' + version);
-    }
-    else {
-        core.debug('match not found');
-    }
-
-    return version;
-}
-
-export async function executeDotNet(args: string[]) : Promise<IExecSyncResult> {
-    let dotnetPath = await io.which("dotnet", true);
-    let resultCode = 0;
-    let stdout = '';
-    let stderr = '';
-    resultCode = await exec.exec(
-        `"${dotnetPath}"`,
-        args,
-        {
-            listeners: {
-                stdout: (data: Buffer) => {
-                  stdout += data.toString();
-                },
-                stderr: (data: Buffer) => {
-                    stderr += data.toString();
-                }
-              }
-        });
-    return {
-        code: resultCode,
-        stdout: stdout,
-        stderr: stderr,
-        error: null
-    }
-}

src/github/build-agent.ts

@@ -0,0 +1,101 @@
+import * as path from "path";
+import * as uuidV4 from "uuid/v4";
+
+import * as core from "@actions/core";
+import * as exe from "@actions/exec";
+import * as io from "@actions/io";
+import * as toolCache from "@actions/tool-cache";
+
+import { injectable } from "inversify";
+
+import { IBuildAgent, IExecResult } from "../interfaces";
+
+@injectable()
+class BuildAgent implements IBuildAgent {
+
+    public find(toolName: string, versionSpec: string, arch?: string): string {
+        return toolCache.find(toolName, versionSpec, arch);
+    }
+
+    public cacheDir(sourceDir: string, tool: string, version: string, arch?: string): Promise<string> {
+        return toolCache.cacheDir(sourceDir, tool, version, arch);
+    }
+
+    public async createTempDir(): Promise<string> {
+        const IS_WINDOWS = process.platform === "win32";
+
+        let tempDirectory: string = process.env.RUNNER_TEMP || "";
+
+        if (!tempDirectory) {
+            let baseLocation: string;
+            if (IS_WINDOWS) {
+                // On Windows use the USERPROFILE env variable
+                baseLocation = process.env.USERPROFILE || "C:\\";
+            } else {
+                if (process.platform === "darwin") {
+                    baseLocation = "/Users";
+                } else {
+                    baseLocation = "/home";
+                }
+            }
+            tempDirectory = path.join(baseLocation, "actions", "temp");
+        }
+        const dest = path.join(tempDirectory, uuidV4());
+        await io.mkdirP(dest);
+        return dest;
+    }
+
+    public debug(message: string): void {
+        core.debug(message);
+    }
+
+    public setFailed(message: string, done?: boolean): void {
+        core.setFailed(message);
+    }
+
+    public setSucceeded(message: string, done?: boolean): void {
+        //
+    }
+
+    public exportVariable(name: string, val: string): void {
+        core.exportVariable(name, val);
+    }
+
+    public addPath(inputPath: string): void {
+        core.addPath(inputPath);
+    }
+
+    public which(tool: string, check?: boolean): Promise<string> {
+        return io.which(tool, check);
+    }
+
+    public async exec(exec: string, args: string[]): Promise<IExecResult> {
+        const dotnetPath = await io.which(exec, true);
+        let resultCode = 0;
+        let stdout = "";
+        let stderr = "";
+        resultCode = await exe.exec(
+            `"${dotnetPath}"`,
+            args,
+            {
+                listeners: {
+                    stderr: (data: Buffer) => {
+                        stderr += data.toString();
+                    },
+                    stdout: (data: Buffer) => {
+                        stdout += data.toString();
+                    },
+                },
+            });
+        return {
+            code: resultCode,
+            error: null,
+            stderr,
+            stdout,
+        };
+    }
+}
+
+export {
+    BuildAgent,
+};

src/github/ioc.ts

@@ -0,0 +1,15 @@
+import { Container } from "inversify";
+
+import { DotnetTool, GitVersionTool, VersionManager } from "../common";
+import { IBuildAgent, IDotnetTool, IGitVersionTool, IVersionManager } from "../interfaces";
+import { TYPES } from "../types";
+import { BuildAgent } from "./build-agent";
+
+const ioc = new Container();
+
+ioc.bind<IVersionManager>(TYPES.IVersionManager).to(VersionManager);
+ioc.bind<IBuildAgent>(TYPES.IBuildAgent).to(BuildAgent);
+ioc.bind<IDotnetTool>(TYPES.IDotnetTool).to(DotnetTool);
+ioc.bind<IGitVersionTool>(TYPES.IGitVersionTool).to(GitVersionTool);
+
+export { ioc };

src/github/main.ts

@@ -0,0 +1,24 @@
+import "reflect-metadata";
+
+import { IBuildAgent, IGitVersionTool } from "../interfaces";
+import { TYPES } from "../types";
+import { ioc } from "./ioc";
+
+const gitVersionTool = ioc.get<IGitVersionTool>(TYPES.IGitVersionTool);
+const buildAgent = ioc.get<IBuildAgent>(TYPES.IBuildAgent);
+
+export async function run() {
+    try {
+
+        const version = "5.1.2";
+        const includePrerelease = false;
+
+        await gitVersionTool.install(version, includePrerelease);
+
+        buildAgent.setSucceeded("GitVersion executed successfully", true);
+    } catch (error) {
+        buildAgent.setFailed(error.message, true);
+    }
+}
+
+run();

src/github/tsconfig.json

@@ -1,13 +1,3 @@
 {
-    "compilerOptions": {
-        "module": "commonjs",
-        "moduleResolution": "node",
-        "noImplicitAny": true,
-        "removeComments": true,
-        "preserveConstEnums": true,
-        "target": "es6",
-        "sourceMap": false,
-        "inlineSourceMap": true,
-        "declaration": false
-    }
-}
+    "extends": "../tsconfig.json"
+}