Merge pull request #26 from coderoad/feature/validate-commit-order

Feature/validate commit order

Author: ShMcK

Diff for: src/build.ts

@@ -1,6 +1,5 @@
 import * as yamlParser from "js-yaml";
 import * as path from "path";
-import * as _ from "lodash";
 import * as fs from "fs";
 import * as util from "util";
 import { parse } from "./utils/parse";

Diff for: src/utils/commitOrder.ts

@@ -0,0 +1,60 @@
+// should flag commits that are out of order based on the previous commit
+// position is a string like 'INIT', 'L1', 'L1S1'
+export function addToCommitOrder(position: string) {
+  // add position to list
+}
+
+export function validateCommitOrder(positions: string[]): boolean {
+  // loop over positions
+  const errors: number[] = [];
+  let previous = { level: 0, step: 0 };
+  let current = { level: 0, step: 0 };
+  positions.forEach((position: string, index: number) => {
+    if (position === "INIT") {
+      if (previous.level !== 0 && previous.step !== 0) {
+        console.log("ERROR HERE");
+        errors.push(index);
+      }
+      current = { level: 0, step: 0 };
+      return;
+    } else {
+      const levelMatch = position.match(/^L([0-9])+$/);
+      const stepMatch = position.match(/^L([0-9])+S([0-9])+$/);
+      if (levelMatch) {
+        // allows next level or step
+        const [_, levelString] = levelMatch;
+        const level = Number(levelString);
+        current = { level, step: 0 };
+      } else if (stepMatch) {
+        // allows next level or step
+        const [_, levelString, stepString] = stepMatch;
+        const level = Number(levelString);
+        const step = Number(stepString);
+        current = { level, step };
+      } else {
+        // error
+        console.error(`Invalid commit position: ${position}`);
+        return;
+      }
+      if (
+        current.level < previous.level ||
+        (current.level === previous.level && current.step < previous.step)
+      ) {
+        errors.push(index);
+      }
+    }
+    previous = current;
+  });
+
+  if (errors.length) {
+    console.warn("Found commit positions out of order");
+    positions.forEach((position, index) => {
+      if (errors.includes(index)) {
+        console.warn(`${position} <-`);
+      } else {
+        console.log(position);
+      }
+    });
+  }
+  return !errors.length;
+}

Diff for: src/utils/commits.ts

@@ -2,7 +2,7 @@ import * as fs from "fs";
 import util from "util";
 import * as path from "path";
 import gitP, { SimpleGit } from "simple-git/promise";
-import * as T from "../../typings/tutorial";
+import { addToCommitOrder, validateCommitOrder } from "./commitOrder";
 
 const mkdir = util.promisify(fs.mkdir);
 const exists = util.promisify(fs.exists);
@@ -21,19 +21,20 @@ export async function getCommits({
 }: GetCommitOptions): Promise<CommitLogObject> {
   const git: SimpleGit = gitP(localDir);
 
+  // check that a repo is created
   const isRepo = await git.checkIsRepo();
-
   if (!isRepo) {
     throw new Error("No git repo provided");
   }
 
+  // setup .tmp directory
   const tmpDir = path.join(localDir, ".tmp");
-
   const tmpDirExists = await exists(tmpDir);
   if (tmpDirExists) {
     await rmdir(tmpDir, { recursive: true });
   }
   await mkdir(tmpDir);
+
   const tempGit = gitP(tmpDir);
   await tempGit.clone(localDir, tmpDir);
 
@@ -57,6 +58,7 @@ export async function getCommits({
 
     // Load all logs
     const logs = await git.log();
+    const positions: string[] = [];
 
     for (const commit of logs.all) {
       const matches = commit.message.match(
@@ -73,6 +75,7 @@ export async function getCommits({
           // add to the list
           commits[position].push(commit.hash);
         }
+        positions.push(position);
       } else {
         const initMatches = commit.message.match(/^INIT/);
         if (initMatches && initMatches.length) {
@@ -83,9 +86,11 @@ export async function getCommits({
             // add to the list
             commits.INIT.push(commit.hash);
           }
+          positions.push("INIT");
         }
       }
     }
+    validateCommitOrder(positions);
   } catch (e) {
     console.error("Error with checkout or commit matching");
     throw new Error(e.message);

Diff for: src/utils/parse.ts

@@ -1,4 +1,4 @@
-import * as _ from "lodash";
+import { truncate } from "lodash";
 import { CommitLogObject } from "./commits";
 import * as T from "../../typings/tutorial";
 
@@ -68,7 +68,7 @@ export function parseMdContent(md: string): TutorialFrame | never {
         title: levelTitle.trim(),
         summary: levelSummary
           ? levelSummary.trim()
-          : _.truncate(levelContent.trim(), { length: 80, omission: "..." }),
+          : truncate(levelContent.trim(), { length: 80, omission: "..." }),
         content: levelContent.trim(),
       };
     } else {

Diff for: src/validate.ts

@@ -1,12 +1,22 @@
+import * as path from "path";
+import * as fs from "fs";
+import util from "util";
+import gitP, { SimpleGit } from "simple-git/promise";
+import { getCommits, CommitLogObject } from "./utils/commits";
+
+const mkdir = util.promisify(fs.mkdir);
+const exists = util.promisify(fs.exists);
+const rmdir = util.promisify(fs.rmdir);
+
 async function validate(args: string[]) {
   // dir - default .
   const dir = !args.length || args[0].match(/^-/) ? "." : args[0];
   console.warn("Not yet implemented. Coming soon");
-  return;
 
-  // setup .tmp directory
-  // git clone branch
+  const localDir = path.join(process.cwd(), dir);
+  const codeBranch = "";
 
+  const commits = getCommits({ localDir, codeBranch });
   // VALIDATE SKELETON WITH COMMITS
   // parse tutorial skeleton for order and commands
 
@@ -37,7 +47,6 @@ async function validate(args: string[]) {
   // on error, show level/step & error message
 
   // CLEANUP
-  // finally: remove .tmp directory
 }
 
 export default validate;

Diff for: tests/commitOrder.test.ts

@@ -0,0 +1,47 @@
+import { validateCommitOrder } from "../src/utils/commitOrder";
+
+describe("commitOrder", () => {
+  it("should return true if order is valid", () => {
+    const positions = ["INIT", "L1", "L1S1", "L1S2", "L2", "L2S1"];
+    const result = validateCommitOrder(positions);
+    expect(result).toBe(true);
+  });
+  it("should return true if valid with duplicates", () => {
+    const positions = [
+      "INIT",
+      "INIT",
+      "L1",
+      "L1",
+      "L1S1",
+      "L1S1",
+      "L1S2",
+      "L1S2",
+      "L2",
+      "L2",
+      "L2S1",
+      "L2S1",
+    ];
+    const result = validateCommitOrder(positions);
+    expect(result).toBe(true);
+  });
+  it("should return false if INIT is out of order", () => {
+    const positions = ["INIT", "L1", "L1S1", "L1S2", "INIT", "L2", "L2S1"];
+    const result = validateCommitOrder(positions);
+    expect(result).toBe(false);
+  });
+  it("should return false if level after step is out of order", () => {
+    const positions = ["INIT", "L1", "L1S1", "L1S2", "L2S1", "L2"];
+    const result = validateCommitOrder(positions);
+    expect(result).toBe(false);
+  });
+  it("should return false if level is out of order", () => {
+    const positions = ["INIT", "L1", "L3", "L2"];
+    const result = validateCommitOrder(positions);
+    expect(result).toBe(false);
+  });
+  it("should return false if step is out of order", () => {
+    const positions = ["INIT", "L1", "L1S1", "L1S3", "L1S2"];
+    const result = validateCommitOrder(positions);
+    expect(result).toBe(false);
+  });
+});

Diff for: tests/validate.test.ts

@@ -1,5 +1,5 @@
 import * as T from "../typings/tutorial";
-import { validateSchema } from "../src/utils/validate";
+import { validateSchema } from "../src/utils/validateSchema";
 
 describe("validate", () => {
   it("should reject an empty tutorial", () => {