@adobe/sizewatcher 1.2.0 → 1.2.1

package/index.js

@@ -14,60 +14,5 @@
 
 'use strict';
 
-// index.js - main cli entry point
-
-const debug = require("debug")("sizewatcher");
-const gitCheckoutBeforeAndAfter = require("./lib/checkout");
-const compare = require("./lib/compare");
-const report = require("./lib/report");
-const Git = require("simple-git/promise");
-
-function printUsage() {
-    console.log(`Usage: sizewatcher [<options>] [<before> [<after>]]`);
-    console.log();
-    console.log("Arguments:");
-    console.log("  <before>   Before branch/commit for comparison. Defaults to default branch or main/master.");
-    console.log("  <after>    After branch/commit for comparison. Defaults to current branch.");
-    console.log();
-    console.log("Options:");
-    console.log("  -h     Show help");
-}
-
-async function main(argv) {
-    try {
-        // yes, this should probably use a framework like oclif or yargs.
-        // but cli arguments are very limited now and so manual handling is enough
-        if (argv[0] === "-h") {
-            printUsage();
-            process.exit(1);
-        }
-
-        if (!await Git().checkIsRepo()) {
-            throw new Error(`Not inside a git checkout: ${process.cwd()}`);
-        }
-
-        console.log(`Checking out git branches...`);
-        const { before, after } = await gitCheckoutBeforeAndAfter(process.cwd(), argv[0], argv[1]);
-
-        if (before.branch === after.branch) {
-            console.log(`Branches are identical, nothing to compare (${before.branch}=${after.branch}). Compare selected branches using 'sizewatcher <before> <after>'.`);
-            process.exit();
-        }
-
-        console.log(`Comparing changes from '${before.branch}' to '${after.branch}'\n`);
-
-        const deltas = await compare(before, after);
-
-        await report(deltas);
-
-    } catch (e) {
-        debug(e);
-        console.error("Error:", e.message || e);
-        process.exit(1);
-    } finally {
-        console.log("Done. Cleaning up...");
-    }
-}
-
-
-main(process.argv.slice(2));
+const sizewatcher = require("./lib/sizewatcher");
+sizewatcher(process.argv.slice(2));

package/lib/checkout.js

@@ -18,7 +18,7 @@ const debug = require("debug")("sizewatcher");
 const tmp = require("tmp");
 tmp.setGracefulCleanup();
 const path = require("path");
-const Git = require("simple-git/promise");
+const Git = require("simple-git");
 
 async function getGitRoot(dir) {
     // --git-dir will return relative directories
@@ -43,10 +43,14 @@ async function currentSha(dir) {
 }
 
 async function getDefaultBranch(dir) {
-    const originInfo = await Git(dir).remote(["show", "origin"]);
-    const m = originInfo.match(/HEAD branch: (.*)$/m);
-    if (m) {
-        return m[1];
+    try {
+        const originInfo = await Git(dir).remote(["show", "origin"]);
+        const m = originInfo.match(/HEAD branch: (.*)$/m);
+        if (m) {
+            return m[1];
+        }
+    } catch (e) {
+        debug(`ignoring error in getDefaultBranch(): ${e.message}`);
     }
 }
 
@@ -54,22 +58,12 @@ async function hasBranch(dir, branch) {
     try {
         await Git(dir).revparse(["--verify", branch]);
         return branch;
-    } catch (e) { // eslint-disable-line no-unused-vars
+    } catch (e) {
+        debug(`ignoring error in hasBranch(): ${e.message}`);
         return undefined;
     }
 }
 
-async function hasRemoteTrackingBranch(dir) {
-    const git = Git(dir);
-    try {
-        const remoteBranch = await git.revparse(["--abbrev-ref", "--symbolic-full-name", "@{u}"]);
-        console.log(remoteBranch);
-        return true;
-    } catch (e) { // eslint-disable-line no-unused-vars
-        return false;
-    }
-}
-
 async function getPullRequestBaseBranch() {
     return process.env.GITHUB_BASE_REF
         || (process.env.TRAVIS_PULL_REQUEST !== "false" && process.env.TRAVIS_BRANCH);
@@ -110,14 +104,18 @@ async function cloneLocalAndCheckout(from, to, branch) {
     const gitRoot = await getGitRoot(from);
 
     debug(`local cloning ${gitRoot} into ${to}`);
-    await Git().clone(gitRoot, to, { local: true });
+    await Git().clone(gitRoot, to, { '--local'  : true });
 
-    debug(`checking out '${branch}'...`);
-    await Git(to).checkout(branch);
+    if (branch) {
+        debug(`checking out '${branch}'...`);
+        await Git(to).checkout(branch);
+    }
 }
 
 async function gitCheckoutBeforeAndAfter(gitDir, beforeBranch, afterBranch) {
+    debug(`retrieving before branch: ${beforeBranch}`);
     beforeBranch = await getBeforeBranch(gitDir, beforeBranch);
+    debug(`retrieving after branch: ${afterBranch}`);
     afterBranch = await getAfterBranch(gitDir, afterBranch);
     if (beforeBranch === afterBranch) {
         return {
@@ -135,24 +133,33 @@ async function gitCheckoutBeforeAndAfter(gitDir, beforeBranch, afterBranch) {
     const tempDir = tmp.dirSync({unsafeCleanup: true}).name;
     debug(`temporary directory: ${tempDir}`);
 
+    // before checkout --------------------------------------------------------------
+
     const beforeDir = path.join(tempDir, "before");
-    await cloneRemoteAndCheckout(gitDir, beforeDir, beforeBranch);
+
+    // we can use the faster local clone only if the "branch" is present locally
+    if (await hasBranch(gitDir, beforeBranch)) {
+        debug(`[before] using local cloning because existing checkout already has before branch '${beforeBranch}'`);
+        await cloneLocalAndCheckout(gitDir, beforeDir, beforeBranch);
+    } else {
+        debug(`[before] using remote cloning, as existing checkout does not have before branch '${beforeBranch}'`);
+        // ...otherwise need to do a full remote clone
+        await cloneRemoteAndCheckout(gitDir, beforeDir, beforeBranch);
+    }
+
+    // after checkout --------------------------------------------------------------
 
     const afterDir = path.join(tempDir, "after");
-    if (process.env.CI || await hasRemoteTrackingBranch(afterDir)) {
-        await cloneRemoteAndCheckout(gitDir, afterDir, afterBranch);
 
-    } else {
-        // if sizewatcher is run locally inside checkout
-        await cloneLocalAndCheckout(gitDir, afterDir, afterBranch);
-
-        try {
-            // need to ensure before branch is available under local name
-            await Git(afterDir).branch([beforeBranch, "-t", `origin/${beforeBranch}`]);
-        } catch (e) {
-            debug("ignoring error", e);
-        }
+    debug(`[after] using local cloning`);
+    await cloneLocalAndCheckout(gitDir, afterDir);
+    try {
+        // need to ensure before branch is available under local name
+        await Git(afterDir).branch([beforeBranch, "-t", `origin/${beforeBranch}`]);
+    } catch (e) {
+        debug("ignoring error", e);
     }
+    debug(`[after] current branch: ${await currentBranch(afterDir)}`);
 
     debug("folders ready");
 

package/lib/comparators/git.js

@@ -19,7 +19,7 @@ const du = require("du");
 const path = require("path");
 const fs = require("fs");
 const { execSync } = require("child_process");
-const Git = require("simple-git/promise");
+const Git = require("simple-git");
 
 async function getSize(dir) {
     debug(`git garbage collection of '${dir}'...`);
@@ -50,7 +50,7 @@ module.exports = {
     compare: async function(before, after) {
         const beforeSize = await getSize(before.dir);
         const afterSize = await getSize(after.dir);
-        const details = await largestCommits(after.dir, before.branch, after.branch);
+        const details = await largestCommits(after.dir, before.branch, after.sha);
 
         return {
             beforeSize,

package/lib/comparators/node_modules.js

@@ -24,19 +24,36 @@ function isEmptyObject(obj) {
     return Object.keys(obj).length === 0 && obj.constructor === Object;
 }
 
+function hasPackageJson(dir) {
+    return fs.existsSync(path.join(dir, "package.json"));
+}
+
 async function getSize(dir) {
+    if (!hasPackageJson(dir)) {
+        return 0;
+    }
     process.chdir(dir);
+
     debug(`installing node dependencies inside ${dir}...`);
     if (fs.existsSync("package-lock.json") || fs.existsSync("npm-shrinkwrap.json")) {
         execSync("npm ci");
     } else {
         execSync("npm install");
     }
-    debug(`calculating folder size of ${dir}/node_modules...`);
-    return du(path.join(dir, "node_modules"));
+
+    const nodeModules = path.join(dir, "node_modules");
+    if (fs.existsSync(nodeModules)) {
+        debug(`calculating folder size of ${nodeModules}...`);
+        return du(nodeModules);
+    } else {
+        return 0;
+    }
 }
 
 async function costOfModules(dir) {
+    if (!hasPackageJson(dir)) {
+        return "(no package.json)";
+    }
     process.chdir(dir);
 
     const pkgJsonPath = path.join(dir, "package.json");
@@ -62,7 +79,7 @@ async function costOfModules(dir) {
 module.exports = {
 
     shouldRun: async function(beforeDir, afterDir) {
-        return fs.existsSync(path.join(afterDir, "package.json"));
+        return hasPackageJson(beforeDir) || hasPackageJson(afterDir);
     },
 
     compare: async function(before, after) {

package/lib/compare.js

@@ -136,6 +136,7 @@ function process(deltas) {
     };
 
     for (const d of deltas) {
+        debug("processing delta:", d);
         if (d.error) {
             summary.error++;
             continue;
@@ -147,14 +148,14 @@ function process(deltas) {
         };
 
         let increase;
-        if (d.beforeSize <= 0) {
-            if (d.afterSize <= 0) {
-                increase = 0;
-            } else {
-                increase = -100;
-            }
+        if (d.beforeSize <= 0 && d.afterSize <= 0) {
+            increase = 0;
+        } else if (d.afterSize <= 0) {
+            increase = -100;
+        } else if (d.beforeSize <= 0) {
+            increase = 100;
         } else {
-            increase = d.beforeSize <= 0 ? -100 : (d.afterSize - d.beforeSize) / d.beforeSize * 100;
+            increase = (d.afterSize - d.beforeSize) / d.beforeSize * 100;
         }
         d.increase = increase.toFixed(1);
 

package/lib/sizewatcher.js

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+'use strict';
+
+// main cli entry point
+
+const debug = require("debug")("sizewatcher");
+const gitCheckoutBeforeAndAfter = require("./checkout");
+const compare = require("./compare");
+const report = require("./report");
+const Git = require("simple-git");
+
+function printUsage() {
+    console.error(`Usage: sizewatcher [<options>] [<before> [<after>]]`);
+    console.error();
+    console.error("Arguments:");
+    console.error("  <before>   Before branch/commit for comparison. Defaults to default branch or main/master.");
+    console.error("  <after>    After branch/commit for comparison. Defaults to current branch.");
+    console.error();
+    console.error("Options:");
+    console.error("  -h     Show help");
+}
+
+async function sizewatcher(argv) {
+    try {
+        if (!argv) argv = [];
+
+        // yes, this should probably use a framework like oclif or yargs.
+        // but cli arguments are very limited now and so manual handling is enough
+        if (argv[0] === "-h") {
+            printUsage();
+            return process.exit(1);
+        }
+
+        debug(`Running inside ${process.cwd()}`);
+
+        if (!await Git().checkIsRepo()) {
+            throw new Error(`Not inside a git checkout: ${process.cwd()}`);
+        }
+
+        console.log(`Checking out git branches...`);
+        const { before, after } = await gitCheckoutBeforeAndAfter(process.cwd(), argv[0], argv[1]);
+
+        if (before.branch === after.branch) {
+            console.log(`Branches are identical, nothing to compare (${before.branch}=${after.branch}). Compare selected branches using 'sizewatcher <before> <after>'.`);
+            return process.exit();
+        }
+
+        console.log(`Comparing changes from '${before.branch}' to '${after.branch}'\n`);
+
+        const deltas = await compare(before, after);
+
+        await report(deltas);
+
+        console.log("Done. Cleaning up...");
+
+    } catch (e) {
+        debug(e);
+        console.error("Error:", e.message || e);
+        return process.exit(1);
+    }
+}
+
+module.exports = sizewatcher;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/sizewatcher",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "Warns if your pull requests introduce large size increases.",
   "main": "index.js",
   "bin": {
@@ -30,7 +30,8 @@
     "eslint": "^7.1.0",
     "mocha": "^7.2.0",
     "mock-fs": "^4.13.0",
-    "nyc": "^15.1.0"
+    "nyc": "^15.1.0",
+    "supports-color": "^8.1.1"
   },
   "dependencies": {
     "@octokit/rest": "^18.0.3",
@@ -41,7 +42,7 @@
     "js-yaml": "^3.14.0",
     "pretty-bytes": "^5.3.0",
     "require-dir": "^1.2.0",
-    "simple-git": "^2.5.0",
+    "simple-git": "^3.7.1",
     "tmp": "^0.2.1",
     "xbytes": "^1.6.2"
   }