Format

.prettierrc.json

@@ -1,6 +1,6 @@
 {
     "printWidth": 80,
-    "tabWidth": 2,
+    "tabWidth": 4,
     "useTabs": false,
     "semi": false,
     "singleQuote": true,

__tests__/main.test.ts

@@ -1,3 +1,3 @@
 describe('TODO - Add a test suite', () => {
-  it('TODO - Add a test', async () => {});
+    it('TODO - Add a test', async () => {})
-});
+})

package.json

@@ -9,7 +9,7 @@
     "lint": "eslint src/**/*.ts",
     "build": "ncc build src/main.ts --out dist/main --minify && ncc build src/post.ts --out dist/post --minify",
     "test": "jest",
-    "all": "npm run build && npm test"
+    "all": "npm run format && npm run build && npm test"
   },
   "repository": {
     "type": "git",

src/execution.ts

@@ -1,31 +1,33 @@
-import * as exec from "@actions/exec";
+import * as exec from '@actions/exec'
 
-
+export async function execute(
-export async function execute(executable: string, root: string, argv: string[]): Promise<BuildResult> {
+    executable: string,
-
+    root: string,
-    let publishing = false;
+    argv: string[]
-    let buildScanUrl: string | undefined;
+): Promise<BuildResult> {
+    let publishing = false
+    let buildScanUrl: string | undefined
 
     const status: number = await exec.exec(executable, argv, {
         cwd: root,
         ignoreReturnCode: true,
         listeners: {
             stdline: (line: string) => {
-                if (line.startsWith("Publishing build scan...")) {
+                if (line.startsWith('Publishing build scan...')) {
-                    publishing = true;
+                    publishing = true
                 }
                 if (publishing && line.length == 0) {
                     publishing = false
                 }
-                if (publishing && line.startsWith("http")) {
+                if (publishing && line.startsWith('http')) {
-                    buildScanUrl = line.trim();
+                    buildScanUrl = line.trim()
                     publishing = false
                 }
             }
         }
-    });
+    })
 
-    return new BuildResultImpl(status, buildScanUrl);
+    return new BuildResultImpl(status, buildScanUrl)
 }
 
 export interface BuildResult {
@@ -34,9 +36,5 @@ export interface BuildResult {
 }
 
 class BuildResultImpl implements BuildResult {
-    constructor(
+    constructor(readonly status: number, readonly buildScanUrl?: string) {}
-        readonly status: number,
-        readonly buildScanUrl?: string
-    ) {
-    }
 }

src/gradlew.ts

@@ -1,11 +1,9 @@
-const IS_WINDOWS = process.platform === "win32";
+const IS_WINDOWS = process.platform === 'win32'
-
 
 export function wrapperFilename(): string {
-    return IS_WINDOWS ? "gradlew.bat" : "gradlew";
+    return IS_WINDOWS ? 'gradlew.bat' : 'gradlew'
 }
 
-
 export function installScriptFilename(): string {
-    return IS_WINDOWS ? "gradle.bat" : "gradle";
+    return IS_WINDOWS ? 'gradle.bat' : 'gradle'
 }

src/main.ts

@@ -1,80 +1,72 @@
-import * as core from "@actions/core";
+import * as core from '@actions/core'
-import * as path from "path";
+import * as path from 'path'
-import {parseArgsStringToArgv} from "string-argv";
+import {parseArgsStringToArgv} from 'string-argv'
-
-import * as execution from "./execution";
-import * as gradlew from "./gradlew";
-import * as provision from "./provision";
 
+import * as execution from './execution'
+import * as gradlew from './gradlew'
+import * as provision from './provision'
 
 // Invoked by GitHub Actions
 export async function run() {
     try {
-
+        const baseDirectory = process.env[`GITHUB_WORKSPACE`] || ''
-        const baseDirectory = process.env[`GITHUB_WORKSPACE`] || "";
 
         let result = await execution.execute(
             await resolveGradleExecutable(baseDirectory),
             resolveBuildRootDirectory(baseDirectory),
             parseCommandLineArguments()
-        );
+        )
 
         if (result.buildScanUrl) {
-            core.setOutput("build-scan-url", result.buildScanUrl);
+            core.setOutput('build-scan-url', result.buildScanUrl)
         }
 
         if (result.status != 0) {
             core.setFailed(`Gradle process exited with status ${result.status}`)
         }
-
     } catch (error) {
-        core.setFailed(error.message);
+        core.setFailed(error.message)
     }
 }
 
-
+run()
-run();
-
 
 async function resolveGradleExecutable(baseDirectory: string): Promise<string> {
-
+    const gradleVersion = inputOrNull('gradle-version')
-    const gradleVersion = inputOrNull("gradle-version");
+    if (gradleVersion != null && gradleVersion != 'wrapper') {
-    if (gradleVersion != null && gradleVersion != "wrapper") {
         return path.resolve(await provision.gradleVersion(gradleVersion))
     }
 
-    const gradleExecutable = inputOrNull("gradle-executable");
+    const gradleExecutable = inputOrNull('gradle-executable')
     if (gradleExecutable != null) {
         return path.resolve(baseDirectory, gradleExecutable)
     }
 
-    const wrapperDirectory = inputOrNull("wrapper-directory");
+    const wrapperDirectory = inputOrNull('wrapper-directory')
-    const executableDirectory = wrapperDirectory != null
+    const executableDirectory =
-        ? path.join(baseDirectory, wrapperDirectory)
+        wrapperDirectory != null
-        : baseDirectory;
+            ? path.join(baseDirectory, wrapperDirectory)
+            : baseDirectory
 
-    return path.resolve(executableDirectory, gradlew.wrapperFilename());
+    return path.resolve(executableDirectory, gradlew.wrapperFilename())
 }
 
-
 function resolveBuildRootDirectory(baseDirectory: string): string {
-    let buildRootDirectory = inputOrNull("build-root-directory");
+    let buildRootDirectory = inputOrNull('build-root-directory')
     return buildRootDirectory == null
         ? path.resolve(baseDirectory)
-        : path.resolve(baseDirectory, buildRootDirectory);
+        : path.resolve(baseDirectory, buildRootDirectory)
 }
 
-
 function parseCommandLineArguments(): string[] {
-    const input = inputOrNull("arguments");
+    const input = inputOrNull('arguments')
     return input == null ? [] : parseArgsStringToArgv(input)
 }
 
-
 function inputOrNull(name: string): string | null {
-    const inputString = core.getInput(name);
+    const inputString = core.getInput(name)
     if (inputString.length == 0) {
-        return null;
+        return null
     }
     return inputString
 }

src/post.ts

@@ -1,8 +1,8 @@
-import * as core from "@actions/core";
+import * as core from '@actions/core'
 
 // Invoked by GitHub Actions
 export async function run() {
-    core.info("POST Gradle Command Action")
+    core.info('POST Gradle Command Action')
 }
 
-run();
+run()

src/provision.ts

@@ -1,163 +1,164 @@
-import * as fs from "fs";
+import * as fs from 'fs'
-import * as path from "path";
+import * as path from 'path'
-import * as httpm from 'typed-rest-client/HttpClient';
+import * as httpm from 'typed-rest-client/HttpClient'
-import * as unzip from "unzipper"
+import * as unzip from 'unzipper'
-import * as core from "@actions/core";
+import * as core from '@actions/core'
-import * as io from '@actions/io';
+import * as io from '@actions/io'
-import * as toolCache from "@actions/tool-cache";
+import * as toolCache from '@actions/tool-cache'
 
-import * as gradlew from "./gradlew";
+import * as gradlew from './gradlew'
-
-
-const httpc = new httpm.HttpClient("eskatos/gradle-command-action");
-const gradleVersionsBaseUrl = "https://services.gradle.org/versions";
 
+const httpc = new httpm.HttpClient('eskatos/gradle-command-action')
+const gradleVersionsBaseUrl = 'https://services.gradle.org/versions'
 
 /**
  * @return Gradle executable path
  */
 export async function gradleVersion(gradleVersion: string): Promise<string> {
     switch (gradleVersion) {
-        case "current":
+        case 'current':
-            return gradleCurrent();
+            return gradleCurrent()
-        case "rc":
+        case 'rc':
-            return gradleReleaseCandidate();
+            return gradleReleaseCandidate()
-        case "nightly":
+        case 'nightly':
-            return gradleNightly();
+            return gradleNightly()
-        case "release-nightly":
+        case 'release-nightly':
-            return gradleReleaseNightly();
+            return gradleReleaseNightly()
         default:
-            return gradle(gradleVersion);
+            return gradle(gradleVersion)
     }
 }
 
-
 async function gradleCurrent(): Promise<string> {
-    const json = await gradleVersionDeclaration(`${gradleVersionsBaseUrl}/current`);
+    const json = await gradleVersionDeclaration(
-    return provisionGradle(json.version, json.downloadUrl);
+        `${gradleVersionsBaseUrl}/current`
+    )
+    return provisionGradle(json.version, json.downloadUrl)
 }
 
-
 async function gradleReleaseCandidate(): Promise<string> {
-    const json = await gradleVersionDeclaration(`${gradleVersionsBaseUrl}/release-candidate`);
+    const json = await gradleVersionDeclaration(
+        `${gradleVersionsBaseUrl}/release-candidate`
+    )
     if (json) {
-        return provisionGradle(json.version, json.downloadUrl);
+        return provisionGradle(json.version, json.downloadUrl)
     }
-    return gradleCurrent();
+    return gradleCurrent()
 }
 
-
 async function gradleNightly(): Promise<string> {
-    const json = await gradleVersionDeclaration(`${gradleVersionsBaseUrl}/nightly`);
+    const json = await gradleVersionDeclaration(
-    return provisionGradle(json.version, json.downloadUrl);
+        `${gradleVersionsBaseUrl}/nightly`
+    )
+    return provisionGradle(json.version, json.downloadUrl)
 }
 
-
 async function gradleReleaseNightly(): Promise<string> {
-    const json = await gradleVersionDeclaration(`${gradleVersionsBaseUrl}/release-nightly`);
+    const json = await gradleVersionDeclaration(
-    return provisionGradle(json.version, json.downloadUrl);
+        `${gradleVersionsBaseUrl}/release-nightly`
+    )
+    return provisionGradle(json.version, json.downloadUrl)
 }
 
-
 async function gradle(version: string): Promise<string> {
-    const declaration = await findGradleVersionDeclaration(version);
+    const declaration = await findGradleVersionDeclaration(version)
     if (!declaration) {
-        throw new Error(`Gradle version ${version} does not exists`);
+        throw new Error(`Gradle version ${version} does not exists`)
     }
-    return provisionGradle(declaration.version, declaration.downloadUrl);
+    return provisionGradle(declaration.version, declaration.downloadUrl)
 }
 
-
 async function gradleVersionDeclaration(url: string): Promise<any | undefined> {
-    const json: any = await httpGetJson(url);
+    const json: any = await httpGetJson(url)
-    return (json.version && json.version.length > 0) ? json : undefined
+    return json.version && json.version.length > 0 ? json : undefined
 }
 
-
+async function findGradleVersionDeclaration(
-async function findGradleVersionDeclaration(version: string): Promise<any | undefined> {
+    version: string
-    const json: any = await httpGetJson(`${gradleVersionsBaseUrl}/all`);
+): Promise<any | undefined> {
+    const json: any = await httpGetJson(`${gradleVersionsBaseUrl}/all`)
     const found: any = json.find((entry: any) => {
-        return entry.version === version;
+        return entry.version === version
-    });
+    })
     return found ? found : undefined
 }
 
-
 async function provisionGradle(version: string, url: string): Promise<string> {
-
+    const cachedInstall: string = toolCache.find('gradle', version)
-    const cachedInstall: string = toolCache.find("gradle", version);
     if (cachedInstall.length > 0) {
-        const cachedExecutable = executableFrom(cachedInstall);
+        const cachedExecutable = executableFrom(cachedInstall)
-        core.info(`Provisioned Gradle executable ${cachedExecutable}`);
+        core.info(`Provisioned Gradle executable ${cachedExecutable}`)
-        return cachedExecutable;
+        return cachedExecutable
     }
 
-    const home = process.env["HOME"] || "";
+    const home = process.env['HOME'] || ''
-    const tmpdir = path.join(home, "gradle-provision-tmpdir");
+    const tmpdir = path.join(home, 'gradle-provision-tmpdir')
-    const downloadsDir = path.join(tmpdir, "downloads");
+    const downloadsDir = path.join(tmpdir, 'downloads')
-    const installsDir = path.join(tmpdir, "installs");
+    const installsDir = path.join(tmpdir, 'installs')
-    await io.mkdirP(downloadsDir);
+    await io.mkdirP(downloadsDir)
-    await io.mkdirP(installsDir);
+    await io.mkdirP(installsDir)
 
-    core.info(`Downloading ${url}`);
+    core.info(`Downloading ${url}`)
 
-    const downloadPath = path.join(downloadsDir, `gradle-${version}-bin.zip`);
+    const downloadPath = path.join(downloadsDir, `gradle-${version}-bin.zip`)
-    await httpDownload(url, downloadPath);
+    await httpDownload(url, downloadPath)
-    core.info(`Downloaded at ${downloadPath}, size ${fs.statSync(downloadPath).size}`);
+    core.info(
+        `Downloaded at ${downloadPath}, size ${fs.statSync(downloadPath).size}`
+    )
 
-    await extractZip(downloadPath, installsDir);
+    await extractZip(downloadPath, installsDir)
-    const installDir = path.join(installsDir, `gradle-${version}`);
+    const installDir = path.join(installsDir, `gradle-${version}`)
-    core.info(`Extracted in ${installDir}`);
+    core.info(`Extracted in ${installDir}`)
 
-    const executable = executableFrom(installDir);
+    const executable = executableFrom(installDir)
-    fs.chmodSync(executable, "755");
+    fs.chmodSync(executable, '755')
-    core.info(`Provisioned Gradle executable ${executable}`);
+    core.info(`Provisioned Gradle executable ${executable}`)
 
-    toolCache.cacheDir(installDir, "gradle", version);
+    toolCache.cacheDir(installDir, 'gradle', version)
 
-    return executable;
+    return executable
 }
 
-
 function executableFrom(installDir: string): string {
-    return path.join(installDir, "bin", `${gradlew.installScriptFilename()}`);
+    return path.join(installDir, 'bin', `${gradlew.installScriptFilename()}`)
 }
 
-
 async function httpGetJson(url: string): Promise<any> {
-    const response = await httpc.get(url);
+    const response = await httpc.get(url)
-    const body = await response.readBody();
+    const body = await response.readBody()
-    return JSON.parse(body);
+    return JSON.parse(body)
 }
 
-
 async function httpDownload(url: string, path: string): Promise<void> {
     return new Promise<void>(function (resolve, reject) {
-        const writeStream = fs.createWriteStream(path);
+        const writeStream = fs.createWriteStream(path)
-        httpc.get(url).then(response => {
+        httpc
-            response.message.pipe(writeStream)
+            .get(url)
-                .on("close", () => {
+            .then(response => {
-                    resolve();
+                response.message
-                })
+                    .pipe(writeStream)
-                .on("error", err => {
+                    .on('close', () => {
-                    reject(err)
+                        resolve()
-                });
+                    })
-        }).catch(reason => {
+                    .on('error', err => {
-            reject(reason);
+                        reject(err)
-        });
+                    })
-    });
+            })
+            .catch(reason => {
+                reject(reason)
+            })
+    })
 }
 
-
 async function extractZip(zip: string, destination: string): Promise<void> {
     return new Promise<void>(function (resolve, reject) {
         fs.createReadStream(zip)
-            .pipe(unzip.Extract({"path": destination}))
+            .pipe(unzip.Extract({path: destination}))
-            .on("close", () => {
+            .on('close', () => {
-                resolve();
+                resolve()
             })
-            .on("error", err => {
+            .on('error', err => {
                 reject(err)
-            });
+            })
-    });
+    })
 }