@dotinc/ogre 0.3.0 → 0.3.1-canary.132.73cd488.0

package/README.md

@@ -11,43 +11,43 @@ keep the history around for a bit longer.
 - Checkout
 - Visualization via `@dotinc/ogre-react`
 - Merge
-    - fast-forward
+  - fast-forward
 
 ## Usage
 
 ```typescript
-const repo = new Repository(new ComplexObject())
+const repo = new Repository(new ComplexObject());
 
 // apply changes
-repo.data.name = 'my name'
-repo.data.description = 'now we have a description'
+repo.data.name = "my name";
+repo.data.description = "now we have a description";
 
-// commit changes 
-const init = await repo.commit('initial commit', 'author <author@test.com>')
+// commit changes
+const init = await repo.commit("initial commit", "author <author@test.com>");
 // create a branch named savepoint pointing to the last commit
-repo.createBranch('savepoint')
+repo.createBranch("savepoint");
 
 // switch to new branch
-repo.checkout('add_details', true)
+repo.checkout("add_details", true);
 
 // apply changes
-repo.data.name = 'a fancier name'
+repo.data.name = "a fancier name";
 
 // a) commit & merge
-  await repo.commit('change name', 'author <author@test.com>')
-  repo.checkout('main')
-  repo.merge('add_details')
-  repo.tag('v1.0.0')
+await repo.commit("change name", "author <author@test.com>");
+repo.checkout("main");
+repo.merge("add_details");
+repo.tag("v1.0.0");
 
 // or b) discard change and go back
-  // by using the branch name 
-  repo.checkout('main')
-  // by using the commit hash in a detached state
-  repo.checkout(init)
+// by using the branch name
+repo.checkout("main");
+// by using the commit hash in a detached state
+repo.checkout(init);
 ```
 
 ## TODO
 
 - [ ] Merge
-    - [ ] recursive
-    - [ ] octopus
+  - [ ] recursive
+  - [ ] octopus

package/lib/commit.d.ts

@@ -1,19 +1,18 @@
-import { Change } from './interfaces';
+import { Operation } from "fast-json-patch";
 export interface Commit {
     hash: string;
     tree: string;
     message: string | undefined;
     author: string;
     parent: string | undefined;
-    changes: Change[];
+    changes: Operation[];
     timestamp: Date;
-    to: number;
 }
 export interface CommitHashContent {
     message: string;
     author: string;
     parentRef: string | undefined;
-    changes: Change[];
+    changes: Operation[];
     timestamp: Date;
 }
 export declare function calculateCommitHash(content: CommitHashContent): Promise<string>;

package/lib/git2json.d.ts

@@ -0,0 +1,33 @@
+import { History } from "./interfaces";
+/**
+ * The function `formatGit2Json` takes a `history` object and returns an array of formatted commit
+ * objects.
+ * @param {History} history - The `history` parameter is an object that contains information about the
+ * Repository history.
+ * @returns The function `formatGit2Json` returns an array of objects. Each object represents a commit
+ * in the Repository history. The json representation is returned in `git2json` format based on:
+ * https://github.com/fabien0102/git2json/blob/e067166d2468018b6f3982a8fb44a2e54110ce02/src/git2json.js#L5-L22
+ */
+export declare const formatGit2Json: <T = any>(history: History<T>) => {
+    refs: string[];
+    hash: string;
+    hashAbbrev: string;
+    tree: string;
+    treeAbbrev: string;
+    parents: string[];
+    parentsAbbrev: string[];
+    committer: {
+        name: string;
+        email: string;
+        date: number;
+    };
+    author: {
+        name: string;
+        email: string;
+        timestamp: number;
+    };
+    subject: string | undefined;
+    body: string;
+    notes: string;
+    stats: never[];
+}[];

package/lib/git2json.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatGit2Json = void 0;
+const repository_1 = require("./repository");
+const utils_1 = require("./utils");
+const findRefs = (commit, refs) => {
+    const list = [];
+    const headRef = refs.get(repository_1.REFS_HEAD_KEY);
+    for (const [key, ref] of refs.entries()) {
+        if (ref.value === commit.hash) {
+            if ((0, repository_1.isTagRef)(key)) {
+                list.push(`tag: ${ref.name}`);
+            }
+            else {
+                list.push(ref.name);
+            }
+            // also check if HEAD is pointing to this ref
+            if (headRef && headRef.value === (0, repository_1.createHeadRefValue)(key)) {
+                list.push(headRef.name);
+            }
+        }
+    }
+    return list;
+};
+/**
+ * The function `formatGit2Json` takes a `history` object and returns an array of formatted commit
+ * objects.
+ * @param {History} history - The `history` parameter is an object that contains information about the
+ * Repository history.
+ * @returns The function `formatGit2Json` returns an array of objects. Each object represents a commit
+ * in the Repository history. The json representation is returned in `git2json` format based on:
+ * https://github.com/fabien0102/git2json/blob/e067166d2468018b6f3982a8fb44a2e54110ce02/src/git2json.js#L5-L22
+ */
+const formatGit2Json = (history) => {
+    const { commits, refs } = history;
+    return commits.reverse().map((c) => {
+        const [name, email] = (0, utils_1.cleanAuthor)(c.author);
+        return {
+            refs: findRefs(c, refs),
+            hash: c.hash,
+            hashAbbrev: c.hash.substring(0, 8),
+            tree: c.tree,
+            treeAbbrev: c.tree.substring(0, 8),
+            // FIXME there is only one parent at the moment on ogre
+            parents: c.parent ? [c.parent] : [],
+            parentsAbbrev: c.parent ? [c.parent.substring(0, 8)] : [],
+            committer: {
+                name,
+                email,
+                date: c.timestamp.getMilliseconds(),
+            },
+            author: {
+                name,
+                email,
+                timestamp: c.timestamp.getMilliseconds(),
+            },
+            subject: c.message,
+            body: "",
+            notes: "",
+            // MAYBE? map changes to {additions: number, deletions: number, file: string}
+            stats: [],
+        };
+    });
+};
+exports.formatGit2Json = formatGit2Json;

package/lib/hash.js

@@ -23,25 +23,29 @@ exports.digest = void 0;
  *
  * @returns a promise that resolves to a string with hexadecimal content.
  */
-function digest(obj, algorithm = 'SHA-256', isBrowser = false) {
-    const algorithms = ['SHA-1', 'SHA-256', 'SHA-384', 'SHA-512'];
+function digest(obj, algorithm = "SHA-256", isBrowser = false) {
+    // eslint-disable-line
+    const algorithms = ["SHA-1", "SHA-256", "SHA-384", "SHA-512"];
     if (!algorithms.includes(algorithm)) {
         throw RangeError(`Valid hash algorithm values are any of ${JSON.stringify(algorithms)}`);
     }
     return (async function (obj, algorithm) {
         const encoder = new TextEncoder();
         const hashInput = encoder.encode(hashable(obj)).buffer;
-        let digest = '';
+        let digest = "";
         if (isBrowser) {
             const buf = await crypto.subtle.digest(algorithm, hashInput);
-            const h = '0123456789abcdef';
-            (new Uint8Array(buf)).forEach((v) => {
+            const h = "0123456789abcdef";
+            new Uint8Array(buf).forEach((v) => {
                 digest += h[v >> 4] + h[v & 15];
             });
         }
         else {
-            const nodeAlg = algorithm.toLowerCase().replace('-', '');
-            digest = require('crypto').createHash(nodeAlg).update(Buffer.from(hashInput)).digest('hex'); // eslint-disable-line
+            const nodeAlg = algorithm.toLowerCase().replace("-", "");
+            digest = require("crypto")
+                .createHash(nodeAlg)
+                .update(Buffer.from(hashInput))
+                .digest("hex"); // eslint-disable-line
         }
         /* eslint-enable no-lone-blocks */
         return digest;
@@ -49,7 +53,7 @@ function digest(obj, algorithm = 'SHA-256', isBrowser = false) {
 }
 exports.digest = digest;
 function isObject(val) {
-    return (val != null) && (typeof val === 'object') && !(Array.isArray(val));
+    return val != null && typeof val === "object" && !Array.isArray(val);
 }
 function objectToArraySortedByKey(obj) {
     if (!isObject(obj) && !Array.isArray(obj)) {

package/lib/index.d.ts

@@ -1,6 +1,7 @@
-export * from './interfaces';
-export * from './repository';
-export { Commit } from './commit';
-export * from './ref';
-export * from './size';
-export * from './utils';
+export * from "./interfaces";
+export * from "./repository";
+export { Commit } from "./commit";
+export * from "./ref";
+export * from "./size";
+export * from "./utils";
+export * from "./git2json";

package/lib/index.js

@@ -6,3 +6,4 @@ tslib_1.__exportStar(require("./repository"), exports);
 tslib_1.__exportStar(require("./ref"), exports);
 tslib_1.__exportStar(require("./size"), exports);
 tslib_1.__exportStar(require("./utils"), exports);
+tslib_1.__exportStar(require("./git2json"), exports);

package/lib/interfaces.d.ts

@@ -1,14 +1,12 @@
-import { Commit } from './commit';
+import { Commit } from "./commit";
 export interface Reference {
     name: string;
     value: string;
 }
-export interface Change {
-    path: any[];
-    newValue: any | undefined;
-    oldValue: any | undefined;
-}
-export interface History {
+export interface History<T extends {
+    [k: string]: any;
+}> {
+    original: T;
     refs: Map<string, Reference>;
     commits: Commit[];
 }

package/lib/ref.js

@@ -4,7 +4,7 @@ exports.validBranch = exports.validRef = void 0;
 const bad = /(^|[/.])([/.]|$)|^@$|@{|[\x00-\x20\x7f~^:?*[\\]|\.lock(\/|$)/;
 const badBranch = /^(-|HEAD$)/;
 function validRef(name, onelevel) {
-    return !bad.test(name) && (onelevel || name.includes('/'));
+    return !bad.test(name) && (onelevel || name.includes("/"));
 }
 exports.validRef = validRef;
 function validBranch(name) {

package/lib/repository.d.ts

@@ -1,30 +1,68 @@
-import { History } from './interfaces';
-import { Commit } from './commit';
+import { Operation } from "fast-json-patch";
+import { Commit } from "./commit";
+import { History } from "./interfaces";
 export declare const REFS_HEAD_KEY = "HEAD";
 export declare const REFS_MAIN_KEY: string;
-export interface RepositoryOptions<T> {
-    history?: History;
+export interface RepositoryOptions<T extends {
+    [k: string]: any;
+}> {
+    history?: History<T>;
 }
-export interface RepositoryObject<T> {
+export interface RepositoryObject<T extends {
+    [k: string]: any;
+}> {
     data: T;
-    getHistory(): History;
+    getHistory(): History<T>;
+    /**
+     * Returns the diff between the current HEAD and provided shaish expression
+     *
+     * @param shaishFrom expression (e.g. refs (branches, tags), commitSha)
+     * @param shaishTo expression (e.g. refs (branches, tags), commitSha)
+     */
+    diff(shaishFrom: string, shaishTo?: string): Operation[];
     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[];
     createBranch(name: string): string;
-    merge(source: string | RepositoryObject<T> | History): string;
+    merge(source: string | RepositoryObject<T> | History<T>): string;
+    /**
+     * Branch returns the current branch name
+     */
     branch(): string;
     tag(tag: string): string;
 }
-export interface RespositoryObjectType {
-    new <T>(obj: T, options: RepositoryOptions<T>): RepositoryObject<T>;
-}
 /**
  * A repository recording and managing the state transitions of an object
  */
-export declare const Repository: RespositoryObjectType;
+export declare class Repository<T extends {
+    [k: PropertyKey]: any;
+}> implements RepositoryObject<T> {
+    constructor(obj: T, options: RepositoryOptions<T>);
+    private readonly original;
+    data: T;
+    private observer;
+    private readonly refs;
+    private readonly commits;
+    private moveTo;
+    branch(): string;
+    diff(shaishFrom: string, shaishTo?: string): Operation[];
+    checkout(shaish: string, createBranch?: boolean): void;
+    commit(message: string, author: string, amend?: boolean): Promise<string>;
+    commitAtHead(): Commit | undefined;
+    mustCommitAtHead(): Commit;
+    createBranch(name: string): string;
+    head(): string;
+    private collectCommits;
+    getHistory(): History<T>;
+    logs(numberOfCommits?: number): Commit[];
+    merge(source: string | RepositoryObject<T> | History<T>): string;
+    private moveRef;
+    private saveNewRef;
+    ref(reference: string): string | undefined;
+    tag(tag: string): string;
+}
 export declare const createHeadRefValue: (refKey: string) => string;
 export declare const isTagRef: (refKey: string) => boolean;
 export declare const cleanRefValue: (ref: string) => string;
@@ -36,4 +74,6 @@ export declare const validateRef: (name: string, oneLevel?: boolean) => void;
  * Prints the underlying changelog of a repository
  * @param repository
  */
-export declare const printChangeLog: <T>(repository: RepositoryObject<T>) => void;
+export declare const printChangeLog: <T extends {
+    [k: string]: any;
+}>(repository: RepositoryObject<T>) => void;