feat(publish_yalc): Support fetching from local directories (not github) and wire publish_yalc logic into test downstream script

Author: christopherthielen

publish_yalc_package.js

@@ -1,26 +1,88 @@
 #!/usr/bin/env node
+
+// This script is intended to fetch a package from a git url and publish it locally using the npm package `yalc`.
+// That package can then be installed from the local yalc registry an tested against by some downstream project.
+// This script can optionally fetch from a local directory instead of a git repository.
+
+// The script leaves the files in place after publishing.
+// This can be handy in Travis which can cache the directory contents.
+// After caching, subsequent re-runs of this script won't have to fetch the git repository (or do much for `yarn install`).
 const fs = require('fs');
 const path = require('path');
+const shelljs = require('shelljs');
 const util = require('./util');
 
 const ORIG_DIR = process.cwd();
 
-function publishYalcPackage(installDir, githubUrl) {
-  if (!installDir || !githubUrl) {
-    throw new Error('Usage: publish_yalc_package [INSTALL_DIR] [GITHUB_URL]');
+function publishYalcPackage(installTargetDir, installSource, flags) {
+  flags = flags || {};
+  if (!installTargetDir || !installSource) {
+    throw new Error('Usage: publish_yalc_package [INSTALL_DIR] [GITHUB_URL|LOCAL_DIR]');
+  }
+
+  installTargetDir = path.resolve(installTargetDir);
+  const isRemoteSource = !/^\./.exec(installSource);
+  const installTargetDirTmp = path.join(installTargetDir, ".tmp");
+  const installSourceDir = isRemoteSource ? null : path.resolve(installSource);
+
+  // Create directory and clone git repo
+  if (!fs.existsSync(path.join(installTargetDir, '.git'))) {
+    if (isRemoteSource) {
+      util._exec(`git clone --depth 3 ${installSource} ${installTargetDir}`);
+    } else {
+      shelljs.rm('-rf', installTargetDir);
+      shelljs.cp('-r', installSourceDir, installTargetDir);
+      process.chdir(installTargetDir);
+      util._exec(`git init && git add . && git commit -m "initial commit"`);
+      process.chdir(ORIG_DIR);
+    }
+  }
+
+  // Update git repo from source and make working copy match exactly
+  if (isRemoteSource) {
+    process.chdir(installTargetDir);
+    util._exec('git fetch origin');
+    util._exec('git reset --hard origin/master');
+    util._exec('git clean --force -d');
+  } else {
+    // Create a tmp dir with a copy of the current package contents
+    shelljs.rm('-rf', installTargetDirTmp);
+    shelljs.cp('-r', installSourceDir, installTargetDirTmp);
+
+    // Copy the current .git metadata from the cache dir into the tmp dir
+    shelljs.cp('-r', path.join(installTargetDir, ".git"), installTargetDirTmp);
+    process.chdir(installTargetDirTmp);
+
+    // Commit the changes from the current package (if any)
+    util._exec('git add . && git diff --staged --quiet || git commit -m "update from source directory"');
+
+    process.chdir(installTargetDir);
+
+    // Move the new .git metadata back into the cache dir
+    shelljs.rm('-rf', '.git');
+    shelljs.mv(path.join('.tmp', '.git'), ".");
+    shelljs.rm('-rf', installTargetDirTmp);
+
+    // Update the cache to match the current package contents
+    util._exec('git reset --hard master');
+    util._exec('git clean --force -d');
   }
 
-  if (!fs.existsSync(path.join(installDir, '.git'))) {
-    util._exec('git clone '+ githubUrl + ' ' + installDir);
+  // Update dependencies
+  util._exec('yarn install --check-files');
+
+  if (!flags.noBuild) {
+    // Build package
+    const pkgJson = JSON.parse(fs.readFileSync('package.json'));
+    if (pkgJson.scripts && pkgJson.scripts.build) {
+      util._exec('npm run build');
+    }
   }
 
-  process.chdir(installDir);
-  util._exec('git fetch origin');
-  util._exec('git reset --hard origin/master');
-  util._exec('git clean --force -d');
-  util._exec('yarn --check-files');
-  util._exec('npm run build');
-  util._exec('yalc publish');
+  if (!flags.noPublish) {
+    // Publish to local yalc registry
+    util._exec('yalc publish');
+  }
 
   process.chdir(ORIG_DIR);
 }

test_downstream_projects.js

@@ -2,6 +2,7 @@
 const fs = require('fs');
 const path = require('path');
 
+const publishYalcPackage = require('./publish_yalc_package');
 const util = require('./util');
 util.packageDir();
 const PKG_DIR = process.cwd();
@@ -16,20 +17,12 @@ const DOWNSTREAM_PKGS = (process.env.DOWNSTREAM_PKGS || '').split(',').filter(x
 function forEachDownstream(callback) {
   Object.keys(config).forEach(key => {
     if (DOWNSTREAM_PKGS.length && DOWNSTREAM_PKGS.indexOf(key) === -1) {
-      console.log(key + ' not in DOWNSTREAM_PKGS, skipping...');
+      console.log(callback.constructor.name + ": " + key + ' not in DOWNSTREAM_PKGS, skipping...');
       return;
     }
 
-    const projectPath = path.resolve(DOWNSTREAMS_PATH, key);
-    if (!fs.existsSync(projectPath)) {
-      process.chdir(DOWNSTREAMS_PATH);
-      const giturl = config[key];
-      console.log('cloning ' + giturl);
-      util._exec('git clone '+ giturl + ' ' + key);
-    }
-    process.chdir(projectPath);
-
-    callback();
+    process.chdir(path.resolve(DOWNSTREAMS_PATH, key));
+    callback(key, config[key]);
   });
 }
 
@@ -47,20 +40,16 @@ function localPublish() {
   util._exec('yalc publish');
 }
 
-function getCleanMaster() {
-  console.log('cleaning ' + process.cwd());
-  util._exec('git fetch origin');
-  util._exec('git reset --hard origin/master');
-  util._exec('git clean --force -d');
-}
-
-function revertLocalChanges() {
-  util._exec('git reset --hard origin/master');
-  util._exec('git clean --force -d');
+function initializeDownstreams() {
+  Object.keys(config).forEach(key => {
+    const installTargetDir = path.resolve(DOWNSTREAMS_PATH, key);
+    const installSource = config[key];
+    const flags = { noBuild: true, noPublish: true };
+    publishYalcPackage(installTargetDir, installSource, flags);
+  });
 }
 
-function installDeps() {
-  util._exec('yarn install --check-files');
+function installUpstreamDeps() {
   UPSTREAM_PKGS.forEach(upstream => util._exec('yalc add ' + upstream));
 }
 
@@ -75,11 +64,27 @@ function runTests() {
   }
 }
 
+function revertLocalChanges(key, source) {
+  const isRemoteSource = source[0] !== '.';
+  const ref = isRemoteSource ? 'origin/master' : 'master';
+  util._exec(`git reset --hard ${ref}`);
+  util._exec('git clean --force -d');
+}
+
+console.log(`      ===> Making working copy <===`);
 makeWorkingCopy();
+
+console.log(`      ===> Publishing ${pkgjson.name} to yalc registry <===`);
 localPublish();
 
-forEachDownstream(getCleanMaster);
-forEachDownstream(installDeps);
+console.log(`      ===> Fetching downstream projects and their dependencies <===`);
+initializeDownstreams();
+
+console.log(`      ===> Installing freshly built upstream packages <===`);
+forEachDownstream(installUpstreamDeps);
+
+console.log(`      ===> Running downstream tests <===`);
 forEachDownstream(runTests);
-forEachDownstream(revertLocalChanges);
 
+console.log(`      ===> Cleaning downstream projects <===`);
+forEachDownstream(revertLocalChanges);