@dotinc/ogre 0.4.0 → 0.5.0

package/src/repository.ts

@@ -59,6 +59,13 @@ export interface RepositoryObject<T extends { [k: string]: any }> {
   branch(): string;
 
   tag(tag: string): string;
+
+  /**
+   * Moves the HEAD and the branch to a specific shaish (commit or tag)
+   * @param mode hard - discard changes
+   * @param shaish
+   */
+  reset(mode?: "soft" | "hard", shaish?: string): void;
 }
 
 /**
@@ -84,12 +91,22 @@ export class Repository<T extends { [k: PropertyKey]: any }>
       ]);
 
     this.commits = options.history?.commits ?? [];
+
+    if (options.history) {
+      const commit = this.commitAtHead();
+      if (!commit) {
+        return;
+      }
+      this.moveTo(commit);
+    }
   }
 
   private readonly original: T;
 
   data: T;
+
   private observer: Observer<T>;
+
   private readonly refs: Map<string, Reference>;
   private readonly commits: Commit[];
 
@@ -104,6 +121,32 @@ export class Repository<T extends { [k: PropertyKey]: any }>
     this.observer = observe(this.data);
   }
 
+  reset(
+    mode: "soft" | "hard" | undefined = "hard",
+    shaish: string | undefined = REFS_HEAD_KEY,
+  ): void {
+    if (mode === "hard") {
+      unobserve(this.data, this.observer);
+    }
+
+    const [commit] = shaishToCommit(shaish, this.refs, this.commits);
+    this.moveTo(commit);
+
+    const refs = refsAtCommit(this.refs, commit);
+    // reset only moves heads and not tags
+    const moveableRefs = refs.filter((r) =>
+      r.name.startsWith(headsRefPathPrefix),
+    );
+
+    for (const ref of moveableRefs) {
+      this.moveRef(ref.name, commit);
+    }
+
+    if (mode === "hard") {
+      this.observer = observe(this.data);
+    }
+  }
+
   branch(): string {
     const currentHeadRef = this.refs.get(REFS_HEAD_KEY);
     if (!currentHeadRef) {
@@ -145,12 +188,12 @@ export class Repository<T extends { [k: PropertyKey]: any }>
       const [commit, isRef, refKey] = shaishToCommit(
         shaish,
         this.refs,
-        this.commits
+        this.commits,
       );
       this.moveTo(commit);
       this.moveRef(
         REFS_HEAD_KEY,
-        isRef && refKey !== undefined ? refKey : commit
+        isRef && refKey !== undefined ? refKey : commit,
       );
     }
   }
@@ -158,7 +201,7 @@ export class Repository<T extends { [k: PropertyKey]: any }>
   async commit(
     message: string,
     author: string,
-    amend?: boolean
+    amend?: boolean,
   ): Promise<string> {
     let parent = this.commitAtHead();
     if (amend && !parent) {
@@ -196,7 +239,7 @@ export class Repository<T extends { [k: PropertyKey]: any }>
     });
 
     const treeHash = Buffer.from(
-      compressSync(strToU8(JSON.stringify(this.data)), { level: 6, mem: 8 })
+      compressSync(strToU8(JSON.stringify(this.data)), { level: 6, mem: 8 }),
     ).toString("base64");
     const commit = {
       hash: sha,
@@ -307,7 +350,7 @@ export class Repository<T extends { [k: PropertyKey]: any }>
       throw new Error(
         `fatal: source type (${
           source instanceof Repository ? "Repository" : "History"
-        }) not implemented`
+        }) not implemented`,
       );
     }
 
@@ -374,7 +417,7 @@ export class Repository<T extends { [k: PropertyKey]: any }>
         throw new Error(`unreachable: HEAD not present`);
       }
       throw new Error(
-        `fatal: not a valid object name: '${getLastItem(headRef)}'`
+        `fatal: not a valid object name: '${getLastItem(headRef)}'`,
       );
     }
     this.refs.set(refKey, { name: name, value: headCommit.hash });
@@ -430,7 +473,7 @@ const traverseAndCollectChangelog = (commit: Commit, commitsList: Commit[]) => {
 const mapPath = (
   from: Commit,
   to: Commit,
-  commits: Commit[]
+  commits: Commit[],
 ): [isAncestor: boolean] => {
   let c: Commit | undefined = to;
   while (c !== undefined) {
@@ -451,7 +494,7 @@ const mapPath = (
 const commitAtRefIn = (
   ref: string,
   references: Map<string, Reference>,
-  commitsList: Commit[]
+  commitsList: Commit[],
 ) => {
   const reference = references.get(ref);
   if (!reference) {
@@ -477,6 +520,16 @@ const commitAtRefIn = (
   return undefined;
 };
 
+const refsAtCommit = (references: Map<string, Reference>, commit: Commit) => {
+  const list: Array<Reference> = [];
+  for (const [name, ref] of references.entries()) {
+    if (ref.value === commit.hash) {
+      list.push(ref);
+    }
+  }
+  return list;
+};
+
 /**
  * Accepts a shaish expression (e.g. refs (branches, tags), commitSha) and returns
  * - a commit of type Commit
@@ -486,7 +539,7 @@ const commitAtRefIn = (
 const shaishToCommit = (
   shaish: string,
   references: Map<string, Reference>,
-  commitsList: Commit[]
+  commitsList: Commit[],
 ): [commit: Commit, isRef: boolean, ref: string | undefined] => {
   let sha = shaish;
   let isRef = false;
@@ -557,7 +610,7 @@ export const validateRef = (name: string, oneLevel: boolean = true) => {
  * @param repository
  */
 export const printChangeLog = <T extends { [k: string]: any }>(
-  repository: RepositoryObject<T>
+  repository: RepositoryObject<T>,
 ) => {
   console.log("----------------------------------------------------------");
   console.log(`Changelog at ${repository.head()}`);

package/src/tag.test.ts

@@ -1,4 +1,4 @@
-import test from "ava";
+import { test } from "tap";
 import { getBaseline, testAuthor } from "./test.utils";
 
 test("cannot tag on an empty repo", async (t) => {
@@ -8,7 +8,7 @@ test("cannot tag on an empty repo", async (t) => {
     () => {
       repo.tag("v1.0.0");
     },
-    { message: `fatal: failed to resolve 'HEAD' as a valid ref.` }
+    { message: `fatal: failed to resolve 'HEAD' as a valid ref.` },
   );
 });
 
@@ -21,10 +21,10 @@ test("can create simple tag pointing to HEAD", async (t) => {
   const tagRef = repo.tag(tag);
 
   let expectedRefKey = `refs/tags/${tag}`;
-  t.is(tagRef, expectedRefKey);
-  t.is(repo.ref(tagRef), commit, "tag is not pointing to expected commit");
+  t.equal(tagRef, expectedRefKey);
+  t.equal(repo.ref(tagRef), commit, "tag is not pointing to expected commit");
   const { refs } = repo.getHistory();
-  t.true(refs.has(expectedRefKey), "reference was not present in history");
+  t.ok(refs.has(expectedRefKey), "reference was not present in history");
 });
 
 test("cannot create tag with whitespace", async (t) => {
@@ -37,6 +37,6 @@ test("cannot create tag with whitespace", async (t) => {
     () => {
       repo.tag(tag);
     },
-    { message: `fatal: '${tag}' is not a valid tag name` }
+    { message: `fatal: '${tag}' is not a valid tag name` },
   );
 });

package/src/test.utils.ts

@@ -2,24 +2,29 @@ import { v4 as uuid4 } from "uuid";
 import { Repository, RepositoryObject } from "./repository";
 import { Commit } from "./commit";
 
-export class NestedObject {
-  public name: string | undefined;
-  public uuid: string | undefined;
-}
-
-export class ComplexObject {
-  public uuid: string | undefined;
-  public name: string | undefined;
-  public description: string | undefined;
-  public nested: NestedObject[] = [];
-}
+export type NestedObject = {
+  name?: string;
+  uuid?: string;
+};
+
+export type ComplexObject = {
+  uuid?: string;
+  name?: string;
+  description?: string;
+  nested: NestedObject[];
+};
 
 export const testAuthor = "User name <name@domain.com>";
 
 export async function getBaseline(): Promise<
   [RepositoryObject<ComplexObject>, ComplexObject]
 > {
-  const co = new ComplexObject();
+  const co: ComplexObject = {
+    uuid: undefined,
+    name: undefined,
+    description: undefined,
+    nested: [],
+  };
   const repo = new Repository(co, {});
   return [repo, co];
 }
@@ -33,7 +38,7 @@ export function updateHeaderData(wrapped: ComplexObject) {
 }
 
 export function addOneStep(wrapped: ComplexObject) {
-  const pe = new NestedObject();
+  const pe: NestedObject = {};
   pe.uuid = uuid4();
   pe.name = "first name";
 

package/src/utils.test.ts

@@ -1,40 +1,46 @@
-import test from "ava";
+import { test } from "tap";
 import { cleanAuthor } from "./utils";
 
 test("author <email@domain.info>", (t) => {
   const [name, email] = cleanAuthor("author <email@domain.info>");
-  t.is(name, "author");
-  t.is(email, "email@domain.info");
+  t.equal(name, "author");
+  t.equal(email, "email@domain.info");
+  t.end();
 });
 
 test("author with space <email@domain.info>", (t) => {
   const [name, email] = cleanAuthor("author with space <email@domain.info>");
-  t.is(name, "author with space");
-  t.is(email, "email@domain.info");
+  t.equal(name, "author with space");
+  t.equal(email, "email@domain.info");
+  t.end();
 });
 
 test("author @handle", (t) => {
   const [name, email] = cleanAuthor("author @handle");
-  t.is(name, "author");
-  t.is(email, "@handle");
+  t.equal(name, "author");
+  t.equal(email, "@handle");
+  t.end();
 });
 
 test("author with space @handle", (t) => {
   const [name, email] = cleanAuthor("author with space @handle");
-  t.is(name, "author with space");
-  t.is(email, "@handle");
+  t.equal(name, "author with space");
+  t.equal(email, "@handle");
+  t.end();
 });
 
 test("email@domain.info", (t) => {
   const [name, email] = cleanAuthor("email@domain.info");
-  t.is(name, "");
-  t.is(email, "email@domain.info");
+  t.equal(name, "");
+  t.equal(email, "email@domain.info");
+  t.end();
 });
 
 test("@handle", (t) => {
   const [name, email] = cleanAuthor("@handle");
-  t.is(name, "@handle");
-  t.is(email, "");
+  t.equal(name, "@handle");
+  t.equal(email, "");
+  t.end();
 });
 
 test("empty author", (t) => {
@@ -42,6 +48,7 @@ test("empty author", (t) => {
     () => {
       cleanAuthor("");
     },
-    { message: "author not provided" }
+    { message: "author not provided" },
   );
+  t.end();
 });