saturn-core-cli 0.0.9 → 0.0.10

package/commands/publish.js

@@ -15,6 +15,7 @@ const SATURN_API_TOKEN =
 var exec = require("child-process-promise").exec;
 var spawn = require("child-process-promise").spawn;
 const semverInc = require("semver/functions/inc");
+const { buildChangelog } = require("../lib/changelog");
 
 async function action(release = "patch", options) {
   try {
@@ -24,23 +25,30 @@ async function action(release = "patch", options) {
       console.log(e.message, e);
       exemptions = [];
     }
-    let message = options["message"];
     const packageObj = await fs.readJson(`package.json`);
-    //if (version == undefined) {
-    //let version = packageObj.version;
-    //}
     console.log("Exemptions", exemptions);
     let version = semverInc(packageObj.version, release);
-    packageObj.version = version;
-    await fs.writeJson(`package.json`, packageObj, { spaces: 2 });
+    if (!version) {
+      throw new Error(`Invalid release type "${release}"`);
+    }
+    let changelog = options.changelog
+      ? await buildChangelog(packageObj.version)
+      : "";
+    let description = [options.message, changelog].filter(Boolean).join("\n\n");
+    // The map checksums package.json, so the bump must land first; a dry run leaves it alone.
+    if (!options.dry) {
+      packageObj.version = version;
+      await fs.writeJson(`package.json`, packageObj, { spaces: 2 });
+    }
     let map = await new mapper({ exemptions: exemptions }).createMap("./");
     console.log("MAP", map);
     if (options.dry) {
+      console.log(`DESCRIPTION for ${version}\n${description}`);
       return;
     }
 
     let core = await getCoreId(packageObj.saturn.core);
-    await createInstance(map, core.id, version, message);
+    await createInstance(map, core.id, version, description);
     console.log("DONE");
     await doGitAdd();
     await doGitCommit("SC Publish");
@@ -219,8 +227,9 @@ function command(prog) {
   program = prog;
   program
     .command("publish [release]", { isDefault: true })
-    .option("-d, --dry <template>", "Dry Run", false)
-    .option("-m, --message", "Description of the update", "")
+    .option("-d, --dry", "Dry run: print the map and description without publishing", false)
+    .option("-m, --message <text>", "Description of the update", "")
+    .option("--no-changelog", "Leave the commit changelog out of the description")
     .description("Publish Saturn Version")
     .action(action);
 }

package/lib/changelog.js

@@ -0,0 +1,114 @@
+var execFile = require("child-process-promise").execFile;
+
+// Saturn Instance descriptions are stored by the manager; keep them to a readable size.
+const MAX_LENGTH = 20000;
+const MAX_LISTED_FILES = 10;
+const PUBLISH_SUBJECT = /^"?SC Publish"?$/;
+const TRAILER = /^(Co-Authored-By|Signed-off-by):/i;
+
+async function git(args) {
+  let result = await execFile("git", args, { maxBuffer: 10 * 1024 * 1024 });
+  return result.stdout;
+}
+
+async function tagExists(tag) {
+  try {
+    await git(["rev-parse", "-q", "--verify", `refs/tags/${tag}`]);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+async function resolveBaseTag(previousVersion) {
+  if (previousVersion && (await tagExists(previousVersion))) {
+    return previousVersion;
+  }
+  try {
+    return (await git(["describe", "--tags", "--abbrev=0"])).trim();
+  } catch (e) {
+    return null;
+  }
+}
+
+async function readCommits(base) {
+  let output = await git([
+    "log",
+    "--no-merges",
+    "--reverse",
+    "--format=%h%x1f%s%x1f%b%x1e",
+    `${base}..HEAD`,
+  ]);
+  return output
+    .split("\x1e")
+    .map((record) => record.replace(/^\n/, ""))
+    .filter((record) => record.trim())
+    .map((record) => {
+      let [hash, subject, body = ""] = record.split("\x1f");
+      return { hash, subject: subject.trim(), body };
+    })
+    .filter((commit) => !PUBLISH_SUBJECT.test(commit.subject));
+}
+
+function formatCommit(commit) {
+  let lines = commit.body.split("\n").filter((line) => !TRAILER.test(line.trim()));
+  while (lines.length && !lines[lines.length - 1].trim()) {
+    lines.pop();
+  }
+  while (lines.length && !lines[0].trim()) {
+    lines.shift();
+  }
+  let body = lines.map((line) => (line.trim() ? `  ${line}` : "")).join("\n");
+  return body ? `- ${commit.subject}\n${body}` : `- ${commit.subject}`;
+}
+
+async function uncommittedFiles() {
+  let output = await git(["status", "--porcelain"]);
+  return output
+    .split("\n")
+    .filter((line) => line.trim())
+    .map((line) => line.slice(3).split(" -> ").pop().replace(/^"|"$/g, ""))
+    .filter((file) => file !== "package.json");
+}
+
+function formatUncommitted(files) {
+  let listed = files.slice(0, MAX_LISTED_FILES).join(", ");
+  let more = files.length > MAX_LISTED_FILES ? ` +${files.length - MAX_LISTED_FILES} more` : "";
+  return `- Uncommitted changes in: ${listed}${more}`;
+}
+
+/**
+ * Builds markdown release notes from the commits since the previous published tag, for the
+ * Saturn Instance description. Returns "" when there is no tag to compare against.
+ */
+async function buildChangelog(previousVersion) {
+  let base = await resolveBaseTag(previousVersion);
+  if (!base) {
+    console.log("No previous git tag found, skipping changelog");
+    return "";
+  }
+
+  let entries = (await readCommits(base)).map(formatCommit);
+  let files = await uncommittedFiles();
+  if (files.length) {
+    entries.push(formatUncommitted(files));
+  }
+
+  let kept = [];
+  let length = 0;
+  for (let entry of entries) {
+    if (length + entry.length > MAX_LENGTH) {
+      break;
+    }
+    kept.push(entry);
+    length += entry.length + 1;
+  }
+  if (kept.length < entries.length) {
+    kept.push(`…and ${entries.length - kept.length} more commits`);
+  }
+  return kept.join("\n");
+}
+
+module.exports = {
+  buildChangelog: buildChangelog,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "saturn-core-cli",
-  "version": "0.0.9",
+  "version": "0.0.10",
   "description": "Saturn Core CLI",
   "main": "index.js",
   "scripts": {