@dotinc/ogre 0.7.0 → 0.8.0

package/lib/repository.js

@@ -1,15 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.printChange = exports.printChangeLog = exports.validateRef = exports.validateBranchName = exports.tagToRef = exports.brancheNameToRef = exports.cleanRefValue = exports.isTagRef = exports.createHeadRefValue = exports.Repository = exports.REFS_MAIN_KEY = exports.REFS_HEAD_KEY = void 0;
+exports.Repository = void 0;
 const fast_json_patch_1 = require("fast-json-patch");
 const commit_1 = require("./commit");
-const ref_1 = require("./ref");
 const fflate_1 = require("fflate");
-const tagRefPathPrefix = "refs/tags/";
-const headsRefPathPrefix = "refs/heads/";
-const headValueRefPrefix = "ref: ";
-exports.REFS_HEAD_KEY = "HEAD";
-exports.REFS_MAIN_KEY = `${headsRefPathPrefix}main`;
+const utils_1 = require("./utils");
 /**
  * A repository recording and managing the state transitions of an object
  */
@@ -25,10 +20,10 @@ class Repository {
         this.refs =
             (_c = (_b = options.history) === null || _b === void 0 ? void 0 : _b.refs) !== null && _c !== void 0 ? _c : new Map([
                 [
-                    exports.REFS_HEAD_KEY,
+                    utils_1.REFS_HEAD_KEY,
                     {
-                        name: exports.REFS_HEAD_KEY,
-                        value: `ref: ${exports.REFS_MAIN_KEY}`,
+                        name: utils_1.REFS_HEAD_KEY,
+                        value: `ref: ${utils_1.REFS_MAIN_KEY}`,
                     },
                 ],
             ]);
@@ -45,7 +40,7 @@ class Repository {
         return this.remoteRefs;
     }
     moveTo(commit) {
-        const targetTree = treeToObject(commit.tree);
+        const targetTree = (0, utils_1.treeToObject)(commit.tree);
         const patchToTarget = (0, fast_json_patch_1.compare)(this.data, targetTree);
         if (!patchToTarget || patchToTarget.length < 1) {
             return;
@@ -86,15 +81,15 @@ class Repository {
         (0, fast_json_patch_1.applyPatch)(this.data, patch);
         // const changed = patch.reduce(applyReducer, this.data);
     }
-    reset(mode = "hard", shaish = exports.REFS_HEAD_KEY) {
+    reset(mode = "hard", shaish = utils_1.REFS_HEAD_KEY) {
         if (mode === "hard") {
             (0, fast_json_patch_1.unobserve)(this.data, this.observer);
         }
-        const [commit] = shaishToCommit(shaish, this.refs, this.commits);
+        const [commit] = (0, utils_1.shaishToCommit)(shaish, this.refs, this.commits);
         this.moveTo(commit);
-        const refs = refsAtCommit(this.refs, commit);
+        const refs = (0, utils_1.refsAtCommit)(this.refs, commit);
         // reset only moves heads and not tags
-        const moveableRefs = refs.filter((r) => r.name.startsWith(headsRefPathPrefix));
+        const moveableRefs = refs.filter((r) => r.name.startsWith((0, utils_1.localHeadPathPrefix)()));
         for (const ref of moveableRefs) {
             this.moveRef(ref.name, commit);
         }
@@ -103,16 +98,16 @@ class Repository {
         }
     }
     branch() {
-        const currentHeadRef = this.refs.get(exports.REFS_HEAD_KEY);
+        const currentHeadRef = this.refs.get(utils_1.REFS_HEAD_KEY);
         if (!currentHeadRef) {
             throw new Error("unreachable: ref HEAD not available");
         }
-        if (currentHeadRef.value.includes(headValueRefPrefix)) {
-            const refName = (0, exports.cleanRefValue)(currentHeadRef.value);
+        if (currentHeadRef.value.includes(utils_1.headValueRefPrefix)) {
+            const refName = (0, utils_1.cleanRefValue)(currentHeadRef.value);
             if (this.refs.has(refName))
-                return getLastItem(refName);
+                return (0, utils_1.getLastRefPathElement)(refName);
         }
-        return exports.REFS_HEAD_KEY; // detached state
+        return utils_1.REFS_HEAD_KEY; // detached state
     }
     status() {
         const commit = this.commitAtHead();
@@ -123,32 +118,32 @@ class Repository {
         return this.diff(commit.hash);
     }
     diff(shaishFrom, shaishTo) {
-        const [cFrom] = shaishToCommit(shaishFrom, this.refs, this.commits);
+        const [cFrom] = (0, utils_1.shaishToCommit)(shaishFrom, this.refs, this.commits);
         let target;
         if (shaishTo) {
-            const [cTo] = shaishToCommit(shaishTo, this.refs, this.commits);
-            target = treeToObject(cTo.tree);
+            const [cTo] = (0, utils_1.shaishToCommit)(shaishTo, this.refs, this.commits);
+            target = (0, utils_1.treeToObject)(cTo.tree);
         }
         else {
             target = this.data;
         }
-        const targetTree = treeToObject(cFrom.tree);
+        const targetTree = (0, utils_1.treeToObject)(cFrom.tree);
         return (0, fast_json_patch_1.compare)(targetTree, target);
     }
     checkout(shaish, createBranch) {
         if (createBranch) {
-            (0, exports.validateBranchName)(shaish);
-            let branchRef = (0, exports.brancheNameToRef)(shaish);
+            (0, utils_1.validateBranchName)(shaish);
+            let branchRef = (0, utils_1.brancheNameToRef)(shaish);
             const commit = this.commitAtHead();
             if (commit) {
                 this.moveRef(branchRef, commit);
             }
-            this.moveRef(exports.REFS_HEAD_KEY, branchRef);
+            this.moveRef(utils_1.REFS_HEAD_KEY, branchRef);
         }
         else {
-            const [commit, isRef, refKey] = shaishToCommit(shaish, this.refs, this.commits);
+            const [commit, isRef, refKey] = (0, utils_1.shaishToCommit)(shaish, this.refs, this.commits);
             this.moveTo(commit);
-            this.moveRef(exports.REFS_HEAD_KEY, isRef && refKey !== undefined ? refKey : commit);
+            this.moveRef(utils_1.REFS_HEAD_KEY, isRef && refKey !== undefined ? refKey : commit);
         }
     }
     async commit(message, author, amend) {
@@ -160,7 +155,7 @@ class Repository {
         if (parent) {
             if (amend) {
                 [parent] = parent.parent
-                    ? shaishToCommit(parent.parent, this.refs, this.commits)
+                    ? (0, utils_1.shaishToCommit)(parent.parent, this.refs, this.commits)
                     : [parent]; // we are the very first commit in the repository
             }
         }
@@ -203,13 +198,13 @@ class Repository {
         }
         else {
             // move detached HEAD to new commit
-            this.moveRef(exports.REFS_HEAD_KEY, commit);
+            this.moveRef(utils_1.REFS_HEAD_KEY, commit);
         }
         return sha;
     }
     // region Commit lookups
     commitAtHead() {
-        return commitAtRefIn(exports.REFS_HEAD_KEY, this.refs, this.commits);
+        return (0, utils_1.commitAtRefIn)(utils_1.REFS_HEAD_KEY, this.refs, this.commits);
     }
     mustCommitAtHead() {
         const commitHead = this.commitAtHead();
@@ -220,17 +215,17 @@ class Repository {
     }
     // endregion
     createBranch(name) {
-        (0, exports.validateBranchName)(name);
-        const branchRef = (0, exports.brancheNameToRef)(name);
+        (0, utils_1.validateBranchName)(name);
+        const branchRef = (0, utils_1.brancheNameToRef)(name);
         this.saveNewRef(branchRef, name);
         return branchRef;
     }
     head() {
-        const ref = this.refs.get(exports.REFS_HEAD_KEY);
+        const ref = this.refs.get(utils_1.REFS_HEAD_KEY);
         if (!ref) {
             throw new Error(`unreachable: HEAD is not present`);
         }
-        return (0, exports.cleanRefValue)(ref.value);
+        return (0, utils_1.cleanRefValue)(ref.value);
     }
     // region History functions
     collectCommits() {
@@ -276,7 +271,7 @@ class Repository {
             // const srcHead = commitAtRefIn(REFS_HEAD, src.refs, src.commits)
             throw new Error(`fatal: source type (${source instanceof Repository ? "Repository" : "History"}) not implemented`);
         }
-        const [srcCommit] = shaishToCommit(source, this.refs, this.commits);
+        const [srcCommit] = (0, utils_1.shaishToCommit)(source, this.refs, this.commits);
         const headCommit = this.mustCommitAtHead();
         // no change
         // *---* (master)
@@ -293,7 +288,7 @@ class Repository {
         // *---*
         //      \
         //       *---*---* (master, foo)
-        const [isAncestor] = mapPath(headCommit, srcCommit, this.commits);
+        const [isAncestor] = (0, utils_1.mapPath)(headCommit, srcCommit, this.commits);
         if (isAncestor) {
             this.moveRef(this.head(), srcCommit);
             this.moveTo(srcCommit);
@@ -316,9 +311,9 @@ class Repository {
     // region Ref methods
     moveRef(refName, value) {
         let ref = this.refs.get(refName);
-        const val = typeof value === "string" ? (0, exports.createHeadRefValue)(value) : value.hash;
+        const val = typeof value === "string" ? (0, utils_1.createHeadRefValue)(value) : value.hash;
         if (!ref) {
-            ref = { name: getLastItem(refName), value: val };
+            ref = { name: (0, utils_1.getLastRefPathElement)(refName), value: val };
         }
         else {
             ref.value = val;
@@ -332,24 +327,24 @@ class Repository {
             if (!headRef) {
                 throw new Error(`unreachable: HEAD not present`);
             }
-            throw new Error(`fatal: not a valid object name: '${getLastItem(headRef)}'`);
+            throw new Error(`fatal: not a valid object name: '${(0, utils_1.getLastRefPathElement)(headRef)}'`);
         }
         this.refs.set(refKey, { name: name, value: headCommit.hash });
     }
     ref(reference) {
         var _a;
         const ref = (_a = this.refs.get(reference)) === null || _a === void 0 ? void 0 : _a.value;
-        return ref ? (0, exports.cleanRefValue)(ref) : undefined;
+        return ref ? (0, utils_1.cleanRefValue)(ref) : undefined;
     }
     // endregion
     tag(tag) {
         try {
-            (0, exports.validateRef)(tag);
+            (0, utils_1.validateRef)(tag);
         }
         catch (e) {
             throw new Error(`fatal: '${tag}' is not a valid tag name`);
         }
-        const tagRef = (0, exports.tagToRef)(tag);
+        const tagRef = (0, utils_1.tagToRef)(tag);
         try {
             this.saveNewRef(tagRef, tag);
         }
@@ -362,155 +357,3 @@ class Repository {
     }
 }
 exports.Repository = Repository;
-const treeToObject = (tree) => {
-    return JSON.parse((0, fflate_1.strFromU8)((0, fflate_1.decompressSync)(Buffer.from(tree, "base64"))));
-};
-const getLastItem = (thePath) => thePath.substring(thePath.lastIndexOf("/") + 1);
-const mapPath = (from, to, commits) => {
-    let c = to;
-    while (c !== undefined) {
-        c = commits.find((parent) => parent.hash === (c === null || c === void 0 ? void 0 : c.parent));
-        if ((c === null || c === void 0 ? void 0 : c.hash) === from.hash) {
-            return [true];
-        }
-    }
-    return [false];
-};
-/**
- * Returns the commit to which the provided ref is pointing
- * @param ref - needs to be in key format, e.g. refs/heads/... or refs/tags/...
- * @param references
- * @param commitsList
- */
-const commitAtRefIn = (ref, references, commitsList) => {
-    const reference = references.get(ref);
-    if (!reference) {
-        throw new Error(`unreachable: '${ref}' is not present`);
-    }
-    let commitHash;
-    if (reference.value.includes(headValueRefPrefix)) {
-        const refKey = (0, exports.cleanRefValue)(reference.value);
-        const targetRef = references.get(refKey);
-        if (!targetRef) {
-            // target branch may not have been saved yet
-            return undefined;
-        }
-        commitHash = targetRef.value;
-    }
-    else {
-        commitHash = reference.value;
-    }
-    for (const c of commitsList) {
-        if (c.hash === commitHash) {
-            return c;
-        }
-    }
-    return undefined;
-};
-const refsAtCommit = (references, commit) => {
-    const list = [];
-    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
- * - isRef boolean whether it is a direct reference
- * - ref the key of the reference
- */
-const shaishToCommit = (shaish, references, commitsList) => {
-    let sha = shaish;
-    let isRef = false;
-    let refKey = undefined;
-    // check for refs
-    for (const [name, ref] of references.entries()) {
-        // match on
-        if (ref.name === shaish || name === shaish) {
-            isRef = true;
-            refKey = name;
-            sha = ref.value;
-            if (sha.includes(headValueRefPrefix)) {
-                const cleanedRef = (0, exports.cleanRefValue)(sha);
-                const c = commitAtRefIn(cleanedRef, references, commitsList);
-                if (!c) {
-                    throw new Error(`${cleanedRef} points to non-existing commit`);
-                }
-                return [c, isRef, refKey];
-            }
-            break;
-        }
-    }
-    // check for partial sha matches
-    const found = commitsList.filter((c) => c.hash.indexOf(sha) > -1);
-    if (found.length === 0) {
-        throw new Error(`pathspec '${shaish}' did not match any known refs`);
-    }
-    // but sha should be specific enough to resolve to 1 commit
-    if (found.length > 1) {
-        throw new Error(`commit `);
-    }
-    return [found[0], isRef, refKey];
-};
-const createHeadRefValue = (refKey) => {
-    return `${headValueRefPrefix}${refKey}`;
-};
-exports.createHeadRefValue = createHeadRefValue;
-const isTagRef = (refKey) => refKey.indexOf(tagRefPathPrefix) > -1;
-exports.isTagRef = isTagRef;
-const cleanRefValue = (ref) => ref.replace(headValueRefPrefix, "");
-exports.cleanRefValue = cleanRefValue;
-const brancheNameToRef = (name) => {
-    return `${headsRefPathPrefix}${name}`;
-};
-exports.brancheNameToRef = brancheNameToRef;
-const tagToRef = (tag) => {
-    return `${tagRefPathPrefix}${tag}`;
-};
-exports.tagToRef = tagToRef;
-const validateBranchName = (name) => {
-    if (!(0, ref_1.validBranch)(name)) {
-        throw new Error(`invalid ref name`);
-    }
-};
-exports.validateBranchName = validateBranchName;
-const validateRef = (name, oneLevel = true) => {
-    if (!(0, ref_1.validRef)(name, oneLevel)) {
-        throw new Error(`invalid ref name`);
-    }
-};
-exports.validateRef = validateRef;
-/**
- * Prints the underlying changelog of a repository
- * @param repository
- */
-const printChangeLog = (repository) => {
-    console.log("----------------------------------------------------------");
-    console.log("Changelog");
-    console.log("----------------------------------------------------------");
-    const history = repository.getHistory();
-    const head = commitAtRefIn(repository.head(), history.refs, history.commits);
-    if (!head) {
-        throw new Error(`fatal: HEAD is not defined`);
-    }
-    let c = head;
-    while (c) {
-        console.log(`${c.hash} ${refsAtCommit(history.refs, c)
-            .map((r) => r.name)
-            .join(" ")}`);
-        for (const chg of c.changes) {
-            (0, exports.printChange)(chg);
-        }
-        c = history.commits.find((parent) => parent.hash === (c === null || c === void 0 ? void 0 : c.parent));
-    }
-    console.log("End of changelog");
-    console.log("----------------------------------------------------------");
-};
-exports.printChangeLog = printChangeLog;
-const printChange = (chg) => {
-    console.log(`  ${JSON.stringify(chg)}`);
-};
-exports.printChange = printChange;

package/lib/utils.d.ts

@@ -1 +1,56 @@
+import { Commit } from "./commit";
+import { Reference } from "./interfaces";
+import { Operation } from "fast-json-patch";
+import { RepositoryObject } from "./repository";
 export declare const cleanAuthor: (author: string) => [name: string, email: string];
+export declare const localRefPrefix = "refs/";
+export declare const remoteRefPrefix = "refs/remotes/origin/";
+export declare const tagRefPathPrefix = "tags/";
+export declare const headsRefPathPrefix = "heads/";
+export declare const headValueRefPrefix = "ref: ";
+export declare const localHeadPathPrefix: () => string;
+export declare const remoteHeadPathPrefix: () => string;
+export declare const localTagPathPrefix: () => string;
+export declare const remoteTagPathPrefix: () => string;
+export declare const REFS_HEAD_KEY = "HEAD";
+/**
+ * Should only be used in local context
+ */
+export declare const REFS_MAIN_KEY: string;
+export declare const treeToObject: <T = any>(tree: string) => T;
+export declare const mapPath: (from: Commit, to: Commit, commits: Commit[]) => [isAncestor: boolean];
+/**
+ * Returns the commit to which the provided ref is pointing
+ * @param ref - needs to be in key format, e.g. refs/heads/... or refs/tags/...
+ * @param references
+ * @param commitsList
+ */
+export declare const commitAtRefIn: (ref: string, references: Map<string, Reference>, commitsList: Commit[]) => Commit | undefined;
+export declare const refsAtCommit: (references: Map<string, Reference>, commit: Commit) => Reference[];
+/**
+ * Accepts a shaish expression (e.g. refs (branches, tags), commitSha) and returns
+ * - a commit of type Commit
+ * - isRef boolean whether it is a direct reference
+ * - ref the key of the reference
+ */
+export declare const shaishToCommit: (shaish: string, references: Map<string, Reference>, commitsList: Commit[]) => [commit: Commit, isRef: boolean, ref: string | undefined];
+export declare const createHeadRefValue: (refKey: string) => string;
+export declare const isTagRef: (refKey: string) => boolean;
+export declare const cleanRefValue: (ref: string) => string;
+export declare const brancheNameToRef: (name: string) => string;
+export declare const tagToRef: (tag: string) => string;
+export declare const validateBranchName: (name: string) => void;
+export declare const validateRef: (name: string, oneLevel?: boolean) => void;
+/**
+ * Prints the underlying changelog of a repository
+ * @param repository
+ */
+export declare const printChangeLog: <T extends {
+    [k: string]: any;
+}>(repository: RepositoryObject<T>) => void;
+export declare const printChange: (chg: Operation) => void;
+/**
+ * Should be called with a `/` delimited ref path. E.g. refs/heads/main
+ * @param thePath
+ */
+export declare const getLastRefPathElement: (thePath: string) => string;

package/lib/utils.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cleanAuthor = void 0;
-// [RFC5322](https://www.ietf.org/rfc/rfc5322.txt)
+exports.getLastRefPathElement = exports.printChange = exports.printChangeLog = exports.validateRef = exports.validateBranchName = exports.tagToRef = exports.brancheNameToRef = exports.cleanRefValue = exports.isTagRef = exports.createHeadRefValue = exports.shaishToCommit = exports.refsAtCommit = exports.commitAtRefIn = exports.mapPath = exports.treeToObject = exports.REFS_MAIN_KEY = exports.REFS_HEAD_KEY = exports.remoteTagPathPrefix = exports.localTagPathPrefix = exports.remoteHeadPathPrefix = exports.localHeadPathPrefix = exports.headValueRefPrefix = exports.headsRefPathPrefix = exports.tagRefPathPrefix = exports.remoteRefPrefix = exports.localRefPrefix = exports.cleanAuthor = void 0;
+const fflate_1 = require("fflate");
+const ref_1 = require("./ref");
 const emailRegex = /(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9]))\.){3}(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9])|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])/;
 const cleanAuthor = (author) => {
     if (author === "") {
@@ -25,3 +26,183 @@ const cleanAuthor = (author) => {
     return [author, ""];
 };
 exports.cleanAuthor = cleanAuthor;
+exports.localRefPrefix = `refs/`;
+exports.remoteRefPrefix = `refs/remotes/origin/`;
+exports.tagRefPathPrefix = "tags/";
+exports.headsRefPathPrefix = "heads/";
+exports.headValueRefPrefix = "ref: ";
+const localHeadPathPrefix = () => `${exports.localRefPrefix}${exports.headsRefPathPrefix}`;
+exports.localHeadPathPrefix = localHeadPathPrefix;
+const remoteHeadPathPrefix = () => `${exports.remoteRefPrefix}${exports.headsRefPathPrefix}`;
+exports.remoteHeadPathPrefix = remoteHeadPathPrefix;
+const localTagPathPrefix = () => `${exports.localRefPrefix}${exports.tagRefPathPrefix}`;
+exports.localTagPathPrefix = localTagPathPrefix;
+const remoteTagPathPrefix = () => `${exports.remoteRefPrefix}${exports.tagRefPathPrefix}`;
+exports.remoteTagPathPrefix = remoteTagPathPrefix;
+exports.REFS_HEAD_KEY = "HEAD";
+/**
+ * Should only be used in local context
+ */
+exports.REFS_MAIN_KEY = `${(0, exports.localHeadPathPrefix)()}main`;
+const treeToObject = (tree) => {
+    return JSON.parse((0, fflate_1.strFromU8)((0, fflate_1.decompressSync)(Buffer.from(tree, "base64"))));
+};
+exports.treeToObject = treeToObject;
+const mapPath = (from, to, commits) => {
+    let c = to;
+    while (c !== undefined) {
+        c = commits.find((parent) => parent.hash === (c === null || c === void 0 ? void 0 : c.parent));
+        if ((c === null || c === void 0 ? void 0 : c.hash) === from.hash) {
+            return [true];
+        }
+    }
+    return [false];
+};
+exports.mapPath = mapPath;
+/**
+ * Returns the commit to which the provided ref is pointing
+ * @param ref - needs to be in key format, e.g. refs/heads/... or refs/tags/...
+ * @param references
+ * @param commitsList
+ */
+const commitAtRefIn = (ref, references, commitsList) => {
+    const reference = references.get(ref);
+    if (!reference) {
+        throw new Error(`unreachable: '${ref}' is not present`);
+    }
+    let commitHash;
+    if (reference.value.includes(exports.headValueRefPrefix)) {
+        const refKey = (0, exports.cleanRefValue)(reference.value);
+        const targetRef = references.get(refKey);
+        if (!targetRef) {
+            // target branch may not have been saved yet
+            return undefined;
+        }
+        commitHash = targetRef.value;
+    }
+    else {
+        commitHash = reference.value;
+    }
+    for (const c of commitsList) {
+        if (c.hash === commitHash) {
+            return c;
+        }
+    }
+    return undefined;
+};
+exports.commitAtRefIn = commitAtRefIn;
+const refsAtCommit = (references, commit) => {
+    const list = [];
+    for (const [name, ref] of references.entries()) {
+        if (ref.value === commit.hash) {
+            list.push(ref);
+        }
+    }
+    return list;
+};
+exports.refsAtCommit = refsAtCommit;
+/**
+ * Accepts a shaish expression (e.g. refs (branches, tags), commitSha) and returns
+ * - a commit of type Commit
+ * - isRef boolean whether it is a direct reference
+ * - ref the key of the reference
+ */
+const shaishToCommit = (shaish, references, commitsList) => {
+    let sha = shaish;
+    let isRef = false;
+    let refKey = undefined;
+    // check for refs
+    for (const [name, ref] of references.entries()) {
+        // match on
+        if (ref.name === shaish || name === shaish) {
+            isRef = true;
+            refKey = name;
+            sha = ref.value;
+            if (sha.includes(exports.headValueRefPrefix)) {
+                const cleanedRef = (0, exports.cleanRefValue)(sha);
+                const c = (0, exports.commitAtRefIn)(cleanedRef, references, commitsList);
+                if (!c) {
+                    throw new Error(`${cleanedRef} points to non-existing commit`);
+                }
+                return [c, isRef, refKey];
+            }
+            break;
+        }
+    }
+    // check for partial sha matches
+    const found = commitsList.filter((c) => c.hash.indexOf(sha) > -1);
+    if (found.length === 0) {
+        throw new Error(`pathspec '${shaish}' did not match any known refs`);
+    }
+    // but sha should be specific enough to resolve to 1 commit
+    if (found.length > 1) {
+        throw new Error(`commit `);
+    }
+    return [found[0], isRef, refKey];
+};
+exports.shaishToCommit = shaishToCommit;
+const createHeadRefValue = (refKey) => {
+    return `${exports.headValueRefPrefix}${refKey}`;
+};
+exports.createHeadRefValue = createHeadRefValue;
+const isTagRef = (refKey) => refKey.indexOf((0, exports.localTagPathPrefix)()) > -1;
+exports.isTagRef = isTagRef;
+const cleanRefValue = (ref) => ref.replace(exports.headValueRefPrefix, "");
+exports.cleanRefValue = cleanRefValue;
+const brancheNameToRef = (name) => {
+    return `${(0, exports.localHeadPathPrefix)()}${name}`;
+};
+exports.brancheNameToRef = brancheNameToRef;
+const tagToRef = (tag) => {
+    return `${(0, exports.localTagPathPrefix)()}${tag}`;
+};
+exports.tagToRef = tagToRef;
+const validateBranchName = (name) => {
+    if (!(0, ref_1.validBranch)(name)) {
+        throw new Error(`invalid ref name`);
+    }
+};
+exports.validateBranchName = validateBranchName;
+const validateRef = (name, oneLevel = true) => {
+    if (!(0, ref_1.validRef)(name, oneLevel)) {
+        throw new Error(`invalid ref name`);
+    }
+};
+exports.validateRef = validateRef;
+/**
+ * Prints the underlying changelog of a repository
+ * @param repository
+ */
+const printChangeLog = (repository) => {
+    console.log("----------------------------------------------------------");
+    console.log("Changelog");
+    console.log("----------------------------------------------------------");
+    const history = repository.getHistory();
+    const head = (0, exports.commitAtRefIn)(repository.head(), history.refs, history.commits);
+    if (!head) {
+        throw new Error(`fatal: HEAD is not defined`);
+    }
+    let c = head;
+    while (c) {
+        console.log(`${c.hash} ${(0, exports.refsAtCommit)(history.refs, c)
+            .map((r) => r.name)
+            .join(" ")}`);
+        for (const chg of c.changes) {
+            (0, exports.printChange)(chg);
+        }
+        c = history.commits.find((parent) => parent.hash === (c === null || c === void 0 ? void 0 : c.parent));
+    }
+    console.log("End of changelog");
+    console.log("----------------------------------------------------------");
+};
+exports.printChangeLog = printChangeLog;
+const printChange = (chg) => {
+    console.log(`  ${JSON.stringify(chg)}`);
+};
+exports.printChange = printChange;
+/**
+ * Should be called with a `/` delimited ref path. E.g. refs/heads/main
+ * @param thePath
+ */
+const getLastRefPathElement = (thePath) => thePath.substring(thePath.lastIndexOf("/") + 1);
+exports.getLastRefPathElement = getLastRefPathElement;

package/package.json

@@ -4,7 +4,7 @@
     "type": "git",
     "url": "https://github.com/dotindustries/ogre.git"
   },
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Git-like repository for in-memory object versioning",
   "private": false,
   "main": "lib/index.js",
@@ -37,5 +37,5 @@
     "registry": "https://registry.npmjs.org/",
     "access": "public"
   },
-  "gitHead": "09b9f4937721eae3bbf38bce555a0a3000f82eba"
+  "gitHead": "8745cba07d9dc502ee7b0fc595d660a5de58f64f"
 }

package/src/commit.test.ts

@@ -8,7 +8,8 @@ import {
   testAuthor,
   updateHeaderData,
 } from "./test.utils";
-import { printChangeLog, Repository } from "./repository";
+import { Repository } from "./repository";
+import { printChangeLog } from "./utils";
 
 test("baseline with 1 commit and zero changelog entries", async (t) => {
   const [repo] = await getBaseline();

package/src/git2json.ts

@@ -1,7 +1,11 @@
 import { Commit } from "./commit";
 import { History, Reference } from "./interfaces";
-import { createHeadRefValue, isTagRef, REFS_HEAD_KEY } from "./repository";
-import { cleanAuthor } from "./utils";
+import {
+  cleanAuthor,
+  createHeadRefValue,
+  isTagRef,
+  REFS_HEAD_KEY,
+} from "./utils";
 
 const findRefs = (commit: Commit, refs: Map<string, Reference>) => {
   const list = [];