isomorphic-git 1.20.0 → 1.22.0

package/README.md

@@ -16,6 +16,16 @@ By providing functionality as individual functions, code bundlers can produce sm
 
 The project includes type definitions so you can enjoy static type-checking and intelligent code completion in editors like VS Code and [CodeSandbox](https://codesandbox.io).
 
+## Project status
+The original author of the project ([Billie Hilton](https://github.com/wmhilton)) left the project, but the project is still maintained by two volunteers:
+
+* [@jcubic](https://github.com/jcubic) (most active)
+* [@mojavelinux](https://github.com/mojavelinux)
+
+But they don't write much code, mainly do code review and try to answer to issues and on Gitter, they just don't want the project to die. So you can say that this project is community driven (as jcubic always reply to issues). Which means that if you want a feature to be implemented you need to do this yourself or find someone that is willing to write the code for you. The project have some money on [OpenCollective](https://opencollective.com/isomorphic-git) and we can spend it on some development, if you find somoene that is willing to code in exchange to some bucks (it may be you), but we don't have a lot so don't expect to have full sallary.
+
+If you want to help this project you're more than welcome to do so.
+
 ## Supported Environments
 
 The following environments are tested in CI and will continue to be supported until the next breaking version:
@@ -287,7 +297,7 @@ Thanks goes to these wonderful people ([emoji key](https://github.com/kentcdodds
     <td align="center"><a href="https://daniel-ruf.de"><img src="https://avatars1.githubusercontent.com/u/827205?v=4&s=60?s=60" width="60px;" alt=""/><br /><sub><b>Daniel Ruf</b></sub></a><br /><a href="https://github.com/isomorphic-git/isomorphic-git/commits?author=DanielRuf" title="Code">💻</a></td>
     <td align="center"><a href="http://blog.bokuweb.me/"><img src="https://avatars0.githubusercontent.com/u/10220449?v=4&s=60?s=60" width="60px;" alt=""/><br /><sub><b>bokuweb</b></sub></a><br /><a href="https://github.com/isomorphic-git/isomorphic-git/commits?author=bokuweb" title="Code">💻</a> <a href="https://github.com/isomorphic-git/isomorphic-git/commits?author=bokuweb" title="Documentation">📖</a> <a href="https://github.com/isomorphic-git/isomorphic-git/commits?author=bokuweb" title="Tests">⚠️</a></td>
     <td align="center"><a href="https://github.com/hirokiosame"><img src="https://avatars0.githubusercontent.com/u/1075694?v=4&s=60?s=60" width="60px;" alt=""/><br /><sub><b>Hiroki Osame</b></sub></a><br /><a href="https://github.com/isomorphic-git/isomorphic-git/commits?author=hirokiosame" title="Code">💻</a> <a href="https://github.com/isomorphic-git/isomorphic-git/commits?author=hirokiosame" title="Documentation">📖</a></td>
-    <td align="center"><a href="http://jcubic.pl/me"><img src="https://avatars1.githubusercontent.com/u/280241?v=4&s=60?s=60" width="60px;" alt=""/><br /><sub><b>Jakub Jankiewicz</b></sub></a><br /><a href="#question-jcubic" title="Answering Questions">💬</a> <a href="https://github.com/isomorphic-git/isomorphic-git/issues?q=author%3Ajcubic" title="Bug reports">🐛</a> <a href="https://github.com/isomorphic-git/isomorphic-git/commits?author=jcubic" title="Code">💻</a> <a href="#example-jcubic" title="Examples">💡</a> <a href="https://github.com/isomorphic-git/isomorphic-git/commits?author=jcubic" title="Tests">⚠️</a></td>
+    <td align="center"><a href="https://jcubic.pl/me"><img src="https://avatars1.githubusercontent.com/u/280241?v=4&s=60?s=60" width="60px;" alt=""/><br /><sub><b>Jakub Jankiewicz</b></sub></a><br /><a href="#question-jcubic" title="Answering Questions">💬</a> <a href="https://github.com/isomorphic-git/isomorphic-git/issues?q=author%3Ajcubic" title="Bug reports">🐛</a> <a href="https://github.com/isomorphic-git/isomorphic-git/commits?author=jcubic" title="Code">💻</a> <a href="#example-jcubic" title="Examples">💡</a> <a href="https://github.com/isomorphic-git/isomorphic-git/commits?author=jcubic" title="Tests">⚠️</a></td>
   </tr>
   <tr>
     <td align="center"><a href="https://github.com/howardgod"><img src="https://avatars1.githubusercontent.com/u/10459637?v=4&s=60?s=60" width="60px;" alt=""/><br /><sub><b>howardgod</b></sub></a><br /><a href="https://github.com/isomorphic-git/isomorphic-git/issues?q=author%3Ahowardgod" title="Bug reports">🐛</a> <a href="https://github.com/isomorphic-git/isomorphic-git/commits?author=howardgod" title="Code">💻</a></td>

package/browser-tests.json

@@ -1,7 +1,7 @@
 [
   "Chrome Headless 79.0.3945.0 (Linux x86_64)",
-  "Firefox 103.0 (Ubuntu 0.0.0)",
-  "Chrome 103.0.5060.53 (Android 10)",
+  "Firefox 110.0 (Ubuntu 0.0.0)",
+  "Chrome 108.0.0.0 (Android 10)",
   "Edge 79.0.309.65 (Windows 10)",
   "Safari 13.1 (Mac OS 10.15.4)",
   "Mobile Safari 13.0 (iOS 13.0)"

package/index.cjs

@@ -342,6 +342,21 @@ class BaseError extends Error {
   }
 }
 
+class UnmergedPathsError extends BaseError {
+  /**
+   * @param {Array<string>} filepaths
+   */
+  constructor(filepaths) {
+    super(
+      `Modifying the index is not possible because you have unmerged files: ${filepaths.toString}. Fix them up in the work tree, and then use 'git add/rm as appropriate to mark resolution and make a commit.`
+    );
+    this.code = this.name = UnmergedPathsError.code;
+    this.data = { filepaths };
+  }
+}
+/** @type {'UnmergedPathsError'} */
+UnmergedPathsError.code = 'UnmergedPathsError';
+
 class InternalError extends BaseError {
   /**
    * @param {string} message
@@ -627,11 +642,28 @@ class GitIndex {
    _entries: Map<string, CacheEntry>
    _dirty: boolean // Used to determine if index needs to be saved to filesystem
    */
-  constructor(entries) {
+  constructor(entries, unmergedPaths) {
     this._dirty = false;
+    this._unmergedPaths = unmergedPaths || new Set();
     this._entries = entries || new Map();
   }
 
+  _addEntry(entry) {
+    if (entry.flags.stage === 0) {
+      entry.stages = [entry];
+      this._entries.set(entry.path, entry);
+      this._unmergedPaths.delete(entry.path);
+    } else {
+      let existingEntry = this._entries.get(entry.path);
+      if (!existingEntry) {
+        this._entries.set(entry.path, entry);
+        existingEntry = entry;
+      }
+      existingEntry.stages[entry.flags.stage] = entry;
+      this._unmergedPaths.add(entry.path);
+    }
+  }
+
   static async from(buffer) {
     if (Buffer.isBuffer(buffer)) {
       return GitIndex.fromBuffer(buffer)
@@ -651,8 +683,8 @@ class GitIndex {
         `Invalid checksum in GitIndex buffer: expected ${shaClaimed} but saw ${shaComputed}`
       )
     }
+    const index = new GitIndex();
     const reader = new BufferCursor(buffer);
-    const _entries = new Map();
     const magic = reader.toString('utf8', 4);
     if (magic !== 'DIRC') {
       throw new InternalError(`Inavlid dircache magic file number: ${magic}`)
@@ -707,10 +739,17 @@ class GitIndex {
         }
       }
       // end of awkward part
-      _entries.set(entry.path, entry);
+      entry.stages = [];
+
+      index._addEntry(entry);
+
       i++;
     }
-    return new GitIndex(_entries)
+    return index
+  }
+
+  get unmergedPaths() {
+    return [...this._unmergedPaths]
   }
 
   get entries() {
@@ -721,13 +760,33 @@ class GitIndex {
     return this._entries
   }
 
+  get entriesFlat() {
+    return [...this.entries].flatMap(entry => {
+      return entry.stages.length > 1 ? entry.stages.filter(x => x) : entry
+    })
+  }
+
   *[Symbol.iterator]() {
     for (const entry of this.entries) {
       yield entry;
     }
   }
 
-  insert({ filepath, stats, oid }) {
+  insert({ filepath, stats, oid, stage = 0 }) {
+    if (!stats) {
+      stats = {
+        ctimeSeconds: 0,
+        ctimeNanoseconds: 0,
+        mtimeSeconds: 0,
+        mtimeNanoseconds: 0,
+        dev: 0,
+        ino: 0,
+        mode: 0,
+        uid: 0,
+        gid: 0,
+        size: 0,
+      };
+    }
     stats = normalizeStats(stats);
     const bfilepath = Buffer.from(filepath);
     const entry = {
@@ -749,11 +808,14 @@ class GitIndex {
       flags: {
         assumeValid: false,
         extended: false,
-        stage: 0,
+        stage,
         nameLength: bfilepath.length < 0xfff ? bfilepath.length : 0xfff,
       },
+      stages: [],
     };
-    this._entries.set(entry.path, entry);
+
+    this._addEntry(entry);
+
     this._dirty = true;
   }
 
@@ -767,6 +829,10 @@ class GitIndex {
         }
       }
     }
+
+    if (this._unmergedPaths.has(filepath)) {
+      this._unmergedPaths.delete(filepath);
+    }
     this._dirty = true;
   }
 
@@ -785,36 +851,50 @@ class GitIndex {
       .join('\n')
   }
 
+  static async _entryToBuffer(entry) {
+    const bpath = Buffer.from(entry.path);
+    // the fixed length + the filename + at least one null char => align by 8
+    const length = Math.ceil((62 + bpath.length + 1) / 8) * 8;
+    const written = Buffer.alloc(length);
+    const writer = new BufferCursor(written);
+    const stat = normalizeStats(entry);
+    writer.writeUInt32BE(stat.ctimeSeconds);
+    writer.writeUInt32BE(stat.ctimeNanoseconds);
+    writer.writeUInt32BE(stat.mtimeSeconds);
+    writer.writeUInt32BE(stat.mtimeNanoseconds);
+    writer.writeUInt32BE(stat.dev);
+    writer.writeUInt32BE(stat.ino);
+    writer.writeUInt32BE(stat.mode);
+    writer.writeUInt32BE(stat.uid);
+    writer.writeUInt32BE(stat.gid);
+    writer.writeUInt32BE(stat.size);
+    writer.write(entry.oid, 20, 'hex');
+    writer.writeUInt16BE(renderCacheEntryFlags(entry));
+    writer.write(entry.path, bpath.length, 'utf8');
+    return written
+  }
+
   async toObject() {
     const header = Buffer.alloc(12);
     const writer = new BufferCursor(header);
     writer.write('DIRC', 4, 'utf8');
     writer.writeUInt32BE(2);
-    writer.writeUInt32BE(this.entries.length);
-    const body = Buffer.concat(
-      this.entries.map(entry => {
-        const bpath = Buffer.from(entry.path);
-        // the fixed length + the filename + at least one null char => align by 8
-        const length = Math.ceil((62 + bpath.length + 1) / 8) * 8;
-        const written = Buffer.alloc(length);
-        const writer = new BufferCursor(written);
-        const stat = normalizeStats(entry);
-        writer.writeUInt32BE(stat.ctimeSeconds);
-        writer.writeUInt32BE(stat.ctimeNanoseconds);
-        writer.writeUInt32BE(stat.mtimeSeconds);
-        writer.writeUInt32BE(stat.mtimeNanoseconds);
-        writer.writeUInt32BE(stat.dev);
-        writer.writeUInt32BE(stat.ino);
-        writer.writeUInt32BE(stat.mode);
-        writer.writeUInt32BE(stat.uid);
-        writer.writeUInt32BE(stat.gid);
-        writer.writeUInt32BE(stat.size);
-        writer.write(entry.oid, 20, 'hex');
-        writer.writeUInt16BE(renderCacheEntryFlags(entry));
-        writer.write(entry.path, bpath.length, 'utf8');
-        return written
-      })
-    );
+    writer.writeUInt32BE(this.entriesFlat.length);
+
+    let entryBuffers = [];
+    for (const entry of this.entries) {
+      entryBuffers.push(GitIndex._entryToBuffer(entry));
+      if (entry.stages.length > 1) {
+        for (const stage of entry.stages) {
+          if (stage && stage !== entry) {
+            entryBuffers.push(GitIndex._entryToBuffer(stage));
+          }
+        }
+      }
+    }
+    entryBuffers = await Promise.all(entryBuffers);
+
+    const body = Buffer.concat(entryBuffers);
     const main = Buffer.concat([header, body]);
     const sum = await shasum(main);
     return Buffer.concat([main, Buffer.from(sum, 'hex')])
@@ -880,14 +960,16 @@ class GitIndexManager {
    * @param {import('../models/FileSystem.js').FileSystem} opts.fs
    * @param {string} opts.gitdir
    * @param {object} opts.cache
+   * @param {bool} opts.allowUnmerged
    * @param {function(GitIndex): any} closure
    */
-  static async acquire({ fs, gitdir, cache }, closure) {
+  static async acquire({ fs, gitdir, cache, allowUnmerged = true }, closure) {
     if (!cache[IndexCache]) cache[IndexCache] = createCache();
 
     const filepath = `${gitdir}/index`;
     if (lock === null) lock = new AsyncLock({ maxPending: Infinity });
     let result;
+    let unmergedPaths = [];
     await lock.acquire(filepath, async () => {
       // Acquire a file lock while we're reading the index
       // to make sure other processes aren't writing to it
@@ -897,6 +979,11 @@ class GitIndexManager {
         await updateCachedIndexFile(fs, filepath, cache[IndexCache]);
       }
       const index = cache[IndexCache].map.get(filepath);
+      unmergedPaths = index.unmergedPaths;
+
+      if (unmergedPaths.length && !allowUnmerged)
+        throw new UnmergedPathsError(unmergedPaths)
+
       result = await closure(index);
       if (index._dirty) {
         // Acquire a file lock while we're writing the index file
@@ -3415,7 +3502,8 @@ var Errors = /*#__PURE__*/Object.freeze({
   UnknownTransportError: UnknownTransportError,
   UnsafeFilepathError: UnsafeFilepathError,
   UrlParseError: UrlParseError,
-  UserCanceledError: UserCanceledError
+  UserCanceledError: UserCanceledError,
+  UnmergedPathsError: UnmergedPathsError
 });
 
 function formatAuthor({ name, email, timestamp, timezoneOffset }) {
@@ -4650,62 +4738,65 @@ async function _commit({
     });
   }
 
-  return GitIndexManager.acquire({ fs, gitdir, cache }, async function(index) {
-    const inodes = flatFileListToDirectoryStructure(index.entries);
-    const inode = inodes.get('.');
-    if (!tree) {
-      tree = await constructTree({ fs, gitdir, inode, dryRun });
-    }
-    if (!parent) {
-      try {
-        parent = [
-          await GitRefManager.resolve({
-            fs,
-            gitdir,
-            ref,
-          }),
-        ];
-      } catch (err) {
-        // Probably an initial commit
-        parent = [];
+  return GitIndexManager.acquire(
+    { fs, gitdir, cache, allowUnmerged: false },
+    async function(index) {
+      const inodes = flatFileListToDirectoryStructure(index.entries);
+      const inode = inodes.get('.');
+      if (!tree) {
+        tree = await constructTree({ fs, gitdir, inode, dryRun });
+      }
+      if (!parent) {
+        try {
+          parent = [
+            await GitRefManager.resolve({
+              fs,
+              gitdir,
+              ref,
+            }),
+          ];
+        } catch (err) {
+          // Probably an initial commit
+          parent = [];
+        }
+      } else {
+        // ensure that the parents are oids, not refs
+        parent = await Promise.all(
+          parent.map(p => {
+            return GitRefManager.resolve({ fs, gitdir, ref: p })
+          })
+        );
       }
-    } else {
-      // ensure that the parents are oids, not refs
-      parent = await Promise.all(
-        parent.map(p => {
-          return GitRefManager.resolve({ fs, gitdir, ref: p })
-        })
-      );
-    }
 
-    let comm = GitCommit.from({
-      tree,
-      parent,
-      author,
-      committer,
-      message,
-    });
-    if (signingKey) {
-      comm = await GitCommit.sign(comm, onSign, signingKey);
-    }
-    const oid = await _writeObject({
-      fs,
-      gitdir,
-      type: 'commit',
-      object: comm.toObject(),
-      dryRun,
-    });
-    if (!noUpdateBranch && !dryRun) {
-      // Update branch pointer
-      await GitRefManager.writeRef({
+      let comm = GitCommit.from({
+        tree,
+        parent,
+        author,
+        committer,
+        message,
+      });
+      if (signingKey) {
+        comm = await GitCommit.sign(comm, onSign, signingKey);
+      }
+      const oid = await _writeObject({
         fs,
         gitdir,
-        ref,
-        value: oid,
+        type: 'commit',
+        object: comm.toObject(),
+        dryRun,
       });
+      if (!noUpdateBranch && !dryRun) {
+        // Update branch pointer
+        await GitRefManager.writeRef({
+          fs,
+          gitdir,
+          ref,
+          value: oid,
+        });
+      }
+      return oid
     }
-    return oid
-  })
+  )
 }
 
 async function constructTree({ fs, gitdir, inode, dryRun }) {
@@ -4788,7 +4879,7 @@ async function _resolveFilepath({
           oid: entry.oid,
         });
         if (type !== 'tree') {
-          throw new ObjectTypeError(oid, type, 'blob', filepath)
+          throw new ObjectTypeError(oid, type, 'tree', filepath)
         }
         tree = GitTree.from(object);
         return _resolveFilepath({
@@ -5393,6 +5484,7 @@ async function annotatedTag({
  * @param {string} args.ref
  * @param {string} [args.object = 'HEAD']
  * @param {boolean} [args.checkout = false]
+ * @param {boolean} [args.force = false]
  *
  * @returns {Promise<void>} Resolves successfully when filesystem operations are complete
  *
@@ -5401,16 +5493,25 @@ async function annotatedTag({
  * console.log('done')
  *
  */
-async function _branch({ fs, gitdir, ref, object, checkout = false }) {
+async function _branch({
+  fs,
+  gitdir,
+  ref,
+  object,
+  checkout = false,
+  force = false,
+}) {
   if (ref !== cleanGitRef.clean(ref)) {
     throw new InvalidRefNameError(ref, cleanGitRef.clean(ref))
   }
 
   const fullref = `refs/heads/${ref}`;
 
-  const exist = await GitRefManager.exists({ fs, gitdir, ref: fullref });
-  if (exist) {
-    throw new AlreadyExistsError('branch', ref, false)
+  if (!force) {
+    const exist = await GitRefManager.exists({ fs, gitdir, ref: fullref });
+    if (exist) {
+      throw new AlreadyExistsError('branch', ref, false)
+    }
   }
 
   // Get current HEAD tree oid
@@ -5449,6 +5550,7 @@ async function _branch({ fs, gitdir, ref, object, checkout = false }) {
  * @param {string} args.ref - What to name the branch
  * @param {string} [args.object = 'HEAD'] - What oid to use as the start point. Accepts a symbolic ref.
  * @param {boolean} [args.checkout = false] - Update `HEAD` to point at the newly created branch
+ * @param {boolean} [args.force = false] - Instead of throwing an error if a branched named `ref` already exists, overwrite the existing branch.
  *
  * @returns {Promise<void>} Resolves successfully when filesystem operations are complete
  *
@@ -5464,6 +5566,7 @@ async function branch({
   ref,
   object,
   checkout = false,
+  force = false,
 }) {
   try {
     assertParameter('fs', fs);
@@ -5475,6 +5578,7 @@ async function branch({
       ref,
       object,
       checkout,
+      force,
     })
   } catch (err) {
     err.caller = 'git.branch';
@@ -6994,8 +7098,8 @@ function filterCapabilities(server, client) {
 
 const pkg = {
   name: 'isomorphic-git',
-  version: '1.20.0',
-  agent: 'git/isomorphic-git@1.20.0',
+  version: '1.22.0',
+  agent: 'git/isomorphic-git@1.22.0',
 };
 
 class FIFO {
@@ -8874,6 +8978,7 @@ async function _merge({
     oids: [ourOid, theirOid],
   });
   if (baseOids.length !== 1) {
+    // TODO: Recursive Merge strategy
     throw new MergeNotSupportedError()
   }
   const baseOid = baseOids[0];
@@ -8898,21 +9003,32 @@ async function _merge({
       throw new FastForwardError()
     }
     // try a fancier merge
-    const tree = await mergeTree({
-      fs,
-      cache,
-      dir,
-      gitdir,
-      ourOid,
-      theirOid,
-      baseOid,
-      ourName: abbreviateRef(ours),
-      baseName: 'base',
-      theirName: abbreviateRef(theirs),
-      dryRun,
-      abortOnConflict,
-      mergeDriver,
-    });
+    const tree = await GitIndexManager.acquire(
+      { fs, gitdir, cache, allowUnmerged: false },
+      async index => {
+        return mergeTree({
+          fs,
+          cache,
+          dir,
+          gitdir,
+          index,
+          ourOid,
+          theirOid,
+          baseOid,
+          ourName: abbreviateRef(ours),
+          baseName: 'base',
+          theirName: abbreviateRef(theirs),
+          dryRun,
+          abortOnConflict,
+          mergeDriver,
+        })
+      }
+    );
+
+    // Defer throwing error until the index lock is relinquished and index is
+    // written to filsesystem
+    if (tree instanceof MergeConflictError) throw tree
+
     if (!message) {
       message = `Merge branch '${abbreviateRef(theirs)}' into ${abbreviateRef(
         ours

package/index.d.ts

@@ -742,6 +742,7 @@ export var Errors: Readonly<{
     UnsafeFilepathError: typeof UnsafeFilepathError;
     UrlParseError: typeof UrlParseError;
     UserCanceledError: typeof UserCanceledError;
+    UnmergedPathsError: typeof UnmergedPathsError;
 }>;
 /**
  * @returns {Walker}
@@ -934,6 +935,7 @@ export function annotatedTag({ fs: _fs, onSign, dir, gitdir, ref, tagger: _tagge
  * @param {string} args.ref - What to name the branch
  * @param {string} [args.object = 'HEAD'] - What oid to use as the start point. Accepts a symbolic ref.
  * @param {boolean} [args.checkout = false] - Update `HEAD` to point at the newly created branch
+ * @param {boolean} [args.force = false] - Instead of throwing an error if a branched named `ref` already exists, overwrite the existing branch.
  *
  * @returns {Promise<void>} Resolves successfully when filesystem operations are complete
  *
@@ -942,13 +944,14 @@ export function annotatedTag({ fs: _fs, onSign, dir, gitdir, ref, tagger: _tagge
  * console.log('done')
  *
  */
-export function branch({ fs, dir, gitdir, ref, object, checkout, }: {
+export function branch({ fs, dir, gitdir, ref, object, checkout, force, }: {
     fs: CallbackFsClient | PromiseFsClient;
     dir?: string;
     gitdir?: string;
     ref: string;
     object?: string;
     checkout?: boolean;
+    force?: boolean;
 }): Promise<void>;
 /**
  * Checkout a branch
@@ -4174,6 +4177,21 @@ declare namespace UserCanceledError {
     const code_28: 'UserCanceledError';
     export { code_28 as code };
 }
+declare class UnmergedPathsError extends BaseError {
+    /**
+     * @param {Array<string>} filepaths
+     */
+    constructor(filepaths: string[]);
+    code: "UnmergedPathsError";
+    name: "UnmergedPathsError";
+    data: {
+        filepaths: string[];
+    };
+}
+declare namespace UnmergedPathsError {
+    const code_29: 'UnmergedPathsError';
+    export { code_29 as code };
+}
 /**
  * @typedef {Object} GitProgressEvent
  * @property {string} phase