@dotinc/ogre 0.8.1 → 0.9.0

package/lib/repository.d.ts

@@ -17,21 +17,21 @@ export interface RepositoryObject<T extends {
      * @param shaishFrom expression (e.g. refs (branches, tags), commitSha)
      * @param shaishTo expression (e.g. refs (branches, tags), commitSha)
      */
-    diff(shaishFrom: string, shaishTo?: string): Operation[];
+    diff(shaishFrom: string, shaishTo?: string): Array<Operation>;
     /**
      * Returns pending changes.
      */
-    status(): Operation[];
+    status(): Array<Operation>;
     /**
      * Applies a patch to the repository's HEAD
      * @param patch
      */
-    apply(patch: Operation[]): void;
+    apply(patch: Array<Operation>): void;
     head(): string;
     ref(reference: string): string | undefined;
     commit(message: string, author: string, amend?: boolean): Promise<string>;
     checkout(shaish: string, createBranch?: boolean): void;
-    logs(commits?: number): Commit[];
+    logs(commits?: number): Array<Commit>;
     createBranch(name: string): string;
     merge(source: string | RepositoryObject<T> | History): string;
     /**
@@ -50,6 +50,13 @@ export interface RepositoryObject<T extends {
      * The returned map is a readonly of remote.
      */
     remote(): ReadonlyMap<string, Readonly<Reference>> | undefined;
+    /**
+     * Cherry returns the commits that are missing from upstream and the refs that have been moved since remote
+     */
+    cherry(): {
+        commits: Array<Commit>;
+        refs: Map<string, Reference>;
+    };
 }
 /**
  * A repository recording and managing the state transitions of an object
@@ -61,16 +68,21 @@ export declare class Repository<T extends {
     private readonly original;
     data: T;
     private readonly remoteRefs;
+    private readonly remoteCommits;
     private observer;
     private readonly refs;
     private readonly commits;
+    cherry(): {
+        commits: Array<Commit>;
+        refs: Map<string, Reference>;
+    };
     remote(): ReadonlyMap<string, Readonly<Reference>> | undefined;
     private moveTo;
-    apply(patch: Operation[]): JsonPatchError | undefined;
+    apply(patch: Array<Operation>): JsonPatchError | undefined;
     reset(mode?: "soft" | "hard" | undefined, shaish?: string | undefined): void;
     branch(): string;
     status(): Operation[];
-    diff(shaishFrom: string, shaishTo?: string): Operation[];
+    diff(shaishFrom: string, shaishTo?: string): Array<Operation>;
     checkout(shaish: string, createBranch?: boolean): void;
     commit(message: string, author: string, amend?: boolean): Promise<string>;
     commitAtHead(): Commit | undefined;
@@ -79,7 +91,7 @@ export declare class Repository<T extends {
     head(): string;
     private collectCommits;
     getHistory(): History;
-    logs(numberOfCommits?: number): Commit[];
+    logs(numberOfCommits?: number): Array<Commit>;
     merge(source: string | RepositoryObject<T> | History): string;
     private moveRef;
     private saveNewRef;

package/lib/repository.js

@@ -10,15 +10,16 @@ const utils_1 = require("./utils");
  */
 class Repository {
     constructor(obj, options) {
+        var _a, _b, _c, _d, _e, _f;
         // FIXME: move this to refs/remote as git would do?
-        var _a, _b, _c, _d, _e;
         this.remoteRefs = (0, utils_1.immutableMapCopy)((_a = options.history) === null || _a === void 0 ? void 0 : _a.refs);
+        this.remoteCommits = (0, utils_1.immutableArrayCopy)((_b = options.history) === null || _b === void 0 ? void 0 : _b.commits, (c) => c.hash);
         this.original = (0, fast_json_patch_1.deepClone)(obj);
         // store js ref, so obj can still be modified without going through repo.data
         this.data = obj;
         this.observer = (0, fast_json_patch_1.observe)(obj);
-        this.refs = ((_b = options.history) === null || _b === void 0 ? void 0 : _b.refs)
-            ? (0, utils_1.mutableMapCopy)((_c = options.history) === null || _c === void 0 ? void 0 : _c.refs)
+        this.refs = ((_c = options.history) === null || _c === void 0 ? void 0 : _c.refs)
+            ? (0, utils_1.mutableMapCopy)((_d = options.history) === null || _d === void 0 ? void 0 : _d.refs)
             : new Map([
                 [
                     utils_1.REFS_HEAD_KEY,
@@ -28,7 +29,7 @@ class Repository {
                     },
                 ],
             ]);
-        this.commits = (_e = (_d = options.history) === null || _d === void 0 ? void 0 : _d.commits) !== null && _e !== void 0 ? _e : [];
+        this.commits = (_f = (_e = options.history) === null || _e === void 0 ? void 0 : _e.commits) !== null && _f !== void 0 ? _f : [];
         if (options.history) {
             const commit = this.commitAtHead();
             if (!commit) {
@@ -37,6 +38,84 @@ class Repository {
             this.moveTo(commit);
         }
     }
+    cherry() {
+        var _a;
+        const commits = [];
+        const refs = new Map();
+        const collectedHashes = [];
+        const shouldExclude = (hash) => { var _a; return ((_a = this.remoteCommits) === null || _a === void 0 ? void 0 : _a.includes(hash)) || collectedHashes.includes(hash); };
+        const collect = (c) => {
+            // we can't include remote state in the pending report
+            if (shouldExclude(c.hash)) {
+                return false;
+            }
+            commits.push(c);
+            collectedHashes.push(c.hash);
+            return true;
+        };
+        // collect ref updates and commits that are not present on the remote
+        for (const [key, ref] of this.refs) {
+            if (key === utils_1.REFS_HEAD_KEY) {
+                continue;
+            }
+            const remote = (_a = this.remoteRefs) === null || _a === void 0 ? void 0 : _a.get(key);
+            if (!remote) {
+                // if we have no remote pair, we need to sync the ref
+                refs.set(key, ref);
+                const localCommit = this.commits.find((c) => c.hash === ref.value);
+                // if ref is not pointing to a commit move on
+                if (!localCommit) {
+                    continue;
+                }
+                // map all commits to root
+                const [isAncestor, path] = (0, utils_1.mapPath)(this.commits, localCommit, undefined);
+                if (isAncestor) {
+                    for (let i = 0; i < path.length; i++) {
+                        const commit = path[i];
+                        collect({
+                            hash: commit.hash,
+                            author: commit.author,
+                            changes: commit.changes,
+                            message: commit.message,
+                            parent: commit.parent,
+                            timestamp: commit.timestamp,
+                            tree: commit.tree,
+                        });
+                    }
+                }
+                continue;
+            }
+            if (remote.value === ref.value) {
+                // early exit if remote is the same
+                continue;
+            }
+            // local and remote refs differ
+            refs.set(key, ref);
+            const localCommit = this.commits.find((c) => c.hash === ref.value);
+            // if ref is not pointing to a commit move on
+            if (!localCommit) {
+                continue;
+            }
+            // FIXME: do we have to have the remote ref as a commit locally?
+            const remoteCommit = this.commits.find((c) => c.hash === remote.value);
+            const [isAncestor, path] = (0, utils_1.mapPath)(this.commits, localCommit, remoteCommit);
+            if (isAncestor) {
+                for (let i = 0; i < path.length; i++) {
+                    const commit = path[i];
+                    collect({
+                        hash: commit.hash,
+                        author: commit.author,
+                        changes: commit.changes,
+                        message: commit.message,
+                        parent: commit.parent,
+                        timestamp: commit.timestamp,
+                        tree: commit.tree,
+                    });
+                }
+            }
+        }
+        return { commits, refs };
+    }
     remote() {
         return this.remoteRefs;
     }
@@ -289,7 +368,7 @@ class Repository {
         // *---*
         //      \
         //       *---*---* (master, foo)
-        const [isAncestor] = (0, utils_1.mapPath)(headCommit, srcCommit, this.commits);
+        const [isAncestor] = (0, utils_1.mapPath)(this.commits, srcCommit, headCommit);
         if (isAncestor) {
             this.moveRef(this.head(), srcCommit);
             this.moveTo(srcCommit);

package/lib/utils.d.ts

@@ -18,7 +18,17 @@ export declare const REFS_HEAD_KEY = "HEAD";
  */
 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];
+/**
+ * Maps the path from a commit to another commit.
+ * It travels backwards through parent relationships until the root state.
+ * It returns a boolean whether the to commit parameter is a direct ancestor
+ * of the from commit and returns the path of commits between them.
+ *
+ * @param commits
+ * @param from the higher commit to start from
+ * @param to to lower commit to arrive at
+ */
+export declare const mapPath: (commits: Array<Commit>, from: Commit, to?: Commit) => [isAncestor: boolean, path: Commit[]];
 /**
  * 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/...
@@ -56,3 +66,4 @@ export declare const printChange: (chg: Operation) => void;
 export declare const getLastRefPathElement: (thePath: string) => string;
 export declare const immutableMapCopy: <T extends object>(map: Map<string, T> | undefined) => ReadonlyMap<string, Readonly<T>> | undefined;
 export declare const mutableMapCopy: <T extends object>(map: Map<string, T>) => Map<string, T>;
+export declare const immutableArrayCopy: <T, R extends unknown>(arr: T[] | undefined, fn?: (obj: T) => Readonly<R>) => readonly Readonly<R>[] | undefined;

package/lib/utils.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mutableMapCopy = exports.immutableMapCopy = 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;
+exports.immutableArrayCopy = exports.mutableMapCopy = exports.immutableMapCopy = 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 fast_json_patch_1 = require("fast-json-patch");
 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 === "") {
@@ -48,15 +49,34 @@ 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];
+/**
+ * Maps the path from a commit to another commit.
+ * It travels backwards through parent relationships until the root state.
+ * It returns a boolean whether the to commit parameter is a direct ancestor
+ * of the from commit and returns the path of commits between them.
+ *
+ * @param commits
+ * @param from the higher commit to start from
+ * @param to to lower commit to arrive at
+ */
+const mapPath = (commits, from, to) => {
+    // early exit for first commit
+    if (from.parent === undefined && to === undefined)
+        return [true, [from]];
+    const path = [];
+    let parent = from;
+    while (parent !== undefined) {
+        const child = parent;
+        parent = commits.find((gp) => gp.hash === (parent === null || parent === void 0 ? void 0 : parent.parent));
+        const atTarget = (parent === null || parent === void 0 ? void 0 : parent.hash) === (to === null || to === void 0 ? void 0 : to.hash);
+        path.push(child);
+        if (atTarget) {
+            if (parent)
+                path.push(parent);
+            return [true, path];
         }
     }
-    return [false];
+    return [false, []];
 };
 exports.mapPath = mapPath;
 /**
@@ -225,3 +245,15 @@ const mutableMapCopy = (map) => {
     return m;
 };
 exports.mutableMapCopy = mutableMapCopy;
+const immutableArrayCopy = (arr, fn = (o) => typeof o === "object" ? (0, fast_json_patch_1.deepClone)(o) : o) => {
+    if (!arr) {
+        return undefined;
+    }
+    const a = [];
+    for (let i = 0; i < arr.length; i++) {
+        const o = arr[i];
+        a.push(fn(o));
+    }
+    return a;
+};
+exports.immutableArrayCopy = immutableArrayCopy;

package/package.json

@@ -4,7 +4,7 @@
     "type": "git",
     "url": "https://github.com/dotindustries/ogre.git"
   },
-  "version": "0.8.1",
+  "version": "0.9.0",
   "description": "Git-like repository for in-memory object versioning",
   "private": false,
   "main": "lib/index.js",
@@ -12,6 +12,8 @@
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
     "test": "nyc --reporter=lcov tap --coverage-report=none --allow-incomplete-coverage",
+    "test:cov": "tap",
+    "test:covhtml": "tap --coverage-report=lcov",
     "test:node": "node --import tsx --test src/**/*.test.ts",
     "coverage:html": "nyc report --reporter=html"
   },
@@ -37,5 +39,5 @@
     "registry": "https://registry.npmjs.org/",
     "access": "public"
   },
-  "gitHead": "82800df2bbac9520914c093cdd47356ce5fae00a"
+  "gitHead": "a254347f76edf34818a313cfd85a98b73cc25004"
 }

package/src/commit.ts

@@ -2,13 +2,13 @@ import { digest } from "./hash";
 import { Operation } from "fast-json-patch";
 
 export interface Commit {
-  /*The hash of the commit. Is an sha256 of:
-          - tree object reference (changes?)
-          - parent object reference (parent hash)
-          - author
-          - author commit timestamp with timezone
-          - commit message
-        */
+  /*The hash of the commit. Is a sha256 of:
+                - tree object reference (changes?)
+                - parent object reference (parent hash)
+                - author
+                - author commit timestamp with timezone
+                - commit message
+              */
   hash: string;
   tree: string;
 
@@ -19,7 +19,7 @@ export interface Commit {
   parent: string | undefined;
 
   // The diff of this commit from the parent
-  changes: Operation[];
+  changes: Array<Operation>;
 
   // Commit timestamp with timezone
   timestamp: Date;
@@ -29,7 +29,7 @@ export interface CommitHashContent {
   message: string;
   author: string;
   parentRef: string | undefined;
-  changes: Operation[];
+  changes: Array<Operation>;
   timestamp: Date;
 }