isomorphic-git 1.17.1 → 1.18.0

package/README.md

@@ -345,6 +345,7 @@ Thanks goes to these wonderful people ([emoji key](https://github.com/kentcdodds
   </tr>
   <tr>
     <td align="center"><a href="https://github.com/seanpoulter"><img src="https://avatars.githubusercontent.com/u/2585460?v=4?s=60" width="60px;" alt=""/><br /><sub><b>Sean Poulter</b></sub></a><br /><a href="#maintenance-seanpoulter" title="Maintenance">🚧</a></td>
+    <td align="center"><a href="https://github.com/araknast"><img src="https://avatars.githubusercontent.com/u/84164531?v=4?s=60" width="60px;" alt=""/><br /><sub><b>\\</b></sub></a><br /><a href="https://github.com/isomorphic-git/isomorphic-git/commits?author=araknast" title="Code">💻</a> <a href="https://github.com/isomorphic-git/isomorphic-git/commits?author=araknast" title="Tests">⚠️</a></td>
   </tr>
 </table>
 

package/browser-tests.json

@@ -1,9 +1,8 @@
 [
-  "X Chrome Mobile 99.0.4844 (Android 0.0.0)",
-  "HeadlessChrome 0.0.0 (Linux 0.0.0)",
-  "Firefox 99.0.0 (Ubuntu 0.0.0)",
-  "Chrome 79.0.3945 (Windows 10 0.0.0)",
-  "Safari 13.1.0 (Mac OS X 10.15.4)",
-  "Mobile Safari 13.0.0 (iOS 13.0.0)",
-  "Chrome Mobile 99.0.4844 (Android 0.0.0)"
+  "Chrome Headless 79.0.3945.0 (Linux x86_64)",
+  "Firefox 100.0 (Ubuntu 0.0.0)",
+  "Chrome 100.0.4896.127 (Android 10)",
+  "Edge 79.0.309.65 (Windows 10)",
+  "Mobile Safari 13.0 (iOS 13.0)",
+  "Safari 13.1 (Mac OS 10.15.4)"
 ]

package/index.cjs

@@ -239,6 +239,19 @@ var diff3Merge = _interopDefault(require('diff3'));
  * @return {{signature: string} | Promise<{signature: string}>} - an 'ASCII armor' encoded "detached" signature
  */
 
+/**
+ * @typedef {Object} MergeDriverParams
+ * @property {Array<string>} branches
+ * @property {Array<string>} contents
+ * @property {string} path
+ */
+
+/**
+ * @callback MergeDriverCallback
+ * @param {MergeDriverParams} args
+ * @return {{cleanMerge: boolean, mergedText: string} | Promise<{cleanMerge: boolean, mergedText: string}>}
+ */
+
 /**
  * @callback WalkerMap
  * @param {string} filename
@@ -1474,6 +1487,21 @@ const getPath = (section, subsection, name) => {
     .join('.')
 };
 
+const normalizePath$1 = path => {
+  const pathSegments = path.split('.');
+  const section = pathSegments.shift();
+  const name = pathSegments.pop();
+  const subsection = pathSegments.length ? pathSegments.join('.') : undefined;
+
+  return {
+    section,
+    subsection,
+    name,
+    path: getPath(section, subsection, name),
+    sectionPath: getPath(section, subsection, null),
+  }
+};
+
 const findLastIndex = (array, callback) => {
   return array.reduce((lastIndex, item, index) => {
     return callback(item) ? index : lastIndex
@@ -1513,8 +1541,9 @@ class GitConfig {
   }
 
   async get(path, getall = false) {
+    const normalizedPath = normalizePath$1(path).path;
     const allValues = this.parsedConfig
-      .filter(config => config.path === path.toLowerCase())
+      .filter(config => config.path === normalizedPath)
       .map(({ section, name, value }) => {
         const fn = schema[section] && schema[section][name];
         return fn ? fn(value) : value
@@ -1544,9 +1573,16 @@ class GitConfig {
   }
 
   async set(path, value, append = false) {
+    const {
+      section,
+      subsection,
+      name,
+      path: normalizedPath,
+      sectionPath,
+    } = normalizePath$1(path);
     const configIndex = findLastIndex(
       this.parsedConfig,
-      config => config.path === path.toLowerCase()
+      config => config.path === normalizedPath
     );
     if (value == null) {
       if (configIndex !== -1) {
@@ -1555,7 +1591,9 @@ class GitConfig {
     } else {
       if (configIndex !== -1) {
         const config = this.parsedConfig[configIndex];
+        // Name should be overwritten in case the casing changed
         const modifiedConfig = Object.assign({}, config, {
+          name,
           value,
           modified: true,
         });
@@ -1565,13 +1603,6 @@ class GitConfig {
           this.parsedConfig[configIndex] = modifiedConfig;
         }
       } else {
-        const pathSegments = path.split('.');
-        const section = pathSegments.shift().toLowerCase();
-        const name = pathSegments.pop();
-        const subsection = pathSegments.length
-          ? pathSegments.join('.').toLowerCase()
-          : undefined;
-        const sectionPath = subsection ? section + '.' + subsection : section;
         const sectionIndex = this.parsedConfig.findIndex(
           config => config.path === sectionPath
         );
@@ -1581,7 +1612,7 @@ class GitConfig {
           name,
           value,
           modified: true,
-          path: getPath(section, subsection, name),
+          path: normalizedPath,
         };
         if (SECTION_REGEX.test(section) && VARIABLE_NAME_REGEX.test(name)) {
           if (sectionIndex >= 0) {
@@ -1593,7 +1624,7 @@ class GitConfig {
               section,
               subsection,
               modified: true,
-              path: getPath(section, subsection, null),
+              path: sectionPath,
             };
             this.parsedConfig.push(newSection, newConfig);
           }
@@ -1609,6 +1640,10 @@ class GitConfig {
           return line
         }
         if (name != null && value != null) {
+          if (typeof value === 'string' && /[#;]/.test(value)) {
+            // A `#` or `;` symbol denotes a comment, so we have to wrap it in double quotes
+            return `\t${name} = "${value}"`
+          }
           return `\t${name} = ${value}`
         }
         if (subsection != null) {
@@ -3180,6 +3215,21 @@ class MergeNotSupportedError extends BaseError {
 /** @type {'MergeNotSupportedError'} */
 MergeNotSupportedError.code = 'MergeNotSupportedError';
 
+class MergeConflictError extends BaseError {
+  /**
+   * @param {Array<string>} filepaths
+   */
+  constructor(filepaths) {
+    super(
+      `Automatic merge failed with one or more merge conflicts in the following files: ${filepaths.toString()}. Fix conflicts then commit the result.`
+    );
+    this.code = this.name = MergeConflictError.code;
+    this.data = { filepaths };
+  }
+}
+/** @type {'MergeConflictError'} */
+MergeConflictError.code = 'MergeConflictError';
+
 class MissingNameError extends BaseError {
   /**
    * @param {'author'|'committer'|'tagger'} role
@@ -3350,6 +3400,7 @@ var Errors = /*#__PURE__*/Object.freeze({
   InvalidRefNameError: InvalidRefNameError,
   MaxDepthError: MaxDepthError,
   MergeNotSupportedError: MergeNotSupportedError,
+  MergeConflictError: MergeConflictError,
   MissingNameError: MissingNameError,
   MissingParameterError: MissingParameterError,
   MultipleGitError: MultipleGitError,
@@ -4611,7 +4662,15 @@ async function _commit({
         // 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 })
+        })
+      );
     }
+
     let comm = GitCommit.from({
       tree,
       parent,
@@ -6924,8 +6983,8 @@ function filterCapabilities(server, client) {
 
 const pkg = {
   name: 'isomorphic-git',
-  version: '1.17.1',
-  agent: 'git/isomorphic-git@1.17.1',
+  version: '1.18.0',
+  agent: 'git/isomorphic-git@1.18.0',
 };
 
 class FIFO {
@@ -8401,16 +8460,14 @@ async function _findMergeBase({ fs, cache, gitdir, oids }) {
 
 const LINEBREAKS = /^.*(\r?\n|$)/gm;
 
-function mergeFile({
-  ourContent,
-  baseContent,
-  theirContent,
-  ourName = 'ours',
-  baseName = 'base',
-  theirName = 'theirs',
-  format = 'diff',
-  markerSize = 7,
-}) {
+function mergeFile({ branches, contents }) {
+  const ourName = branches[1];
+  const theirName = branches[2];
+
+  const baseContent = contents[0];
+  const ourContent = contents[1];
+  const theirContent = contents[2];
+
   const ours = ourContent.match(LINEBREAKS);
   const base = baseContent.match(LINEBREAKS);
   const theirs = theirContent.match(LINEBREAKS);
@@ -8418,9 +8475,12 @@ function mergeFile({
   // Here we let the diff3 library do the heavy lifting.
   const result = diff3Merge(ours, base, theirs);
 
+  const markerSize = 7;
+
   // Here we note whether there are conflicts and format the results
   let mergedText = '';
   let cleanMerge = true;
+
   for (const item of result) {
     if (item.ok) {
       mergedText += item.ok.join('');
@@ -8429,10 +8489,7 @@ function mergeFile({
       cleanMerge = false;
       mergedText += `${'<'.repeat(markerSize)} ${ourName}\n`;
       mergedText += item.conflict.a.join('');
-      if (format === 'diff3') {
-        mergedText += `${'|'.repeat(markerSize)} ${baseName}\n`;
-        mergedText += item.conflict.o.join('');
-      }
+
       mergedText += `${'='.repeat(markerSize)}\n`;
       mergedText += item.conflict.b.join('');
       mergedText += `${'>'.repeat(markerSize)} ${theirName}\n`;
@@ -8458,6 +8515,8 @@ function mergeFile({
  * @param {string} [args.baseName='base'] - The name to use in conflicted files (in diff3 format) for the base hunks
  * @param {string} [args.theirName='theirs'] - The name to use in conflicted files for their hunks
  * @param {boolean} [args.dryRun=false]
+ * @param {boolean} [args.abortOnConflict=false]
+ * @param {MergeDriverCallback} [args.mergeDriver]
  *
  * @returns {Promise<string>} - The SHA-1 object id of the merged tree
  *
@@ -8474,11 +8533,17 @@ async function mergeTree({
   baseName = 'base',
   theirName = 'theirs',
   dryRun = false,
+  abortOnConflict = true,
+  mergeDriver,
 }) {
   const ourTree = TREE({ ref: ourOid });
   const baseTree = TREE({ ref: baseOid });
   const theirTree = TREE({ ref: theirOid });
 
+  const unmergedFiles = [];
+
+  let cleanMerge = true;
+
   const results = await _walk({
     fs,
     cache,
@@ -8539,6 +8604,11 @@ async function mergeTree({
               ourName,
               baseName,
               theirName,
+              mergeDriver,
+            }).then(r => {
+              cleanMerge = r.cleanMerge;
+              unmergedFiles.push(filepath);
+              return r.mergeResult
             })
           }
           // all other types of conflicts fail
@@ -8574,6 +8644,29 @@ async function mergeTree({
       return parent
     },
   });
+
+  if (!cleanMerge) {
+    if (dir && !abortOnConflict) {
+      await _walk({
+        fs,
+        cache,
+        dir,
+        gitdir,
+        trees: [TREE({ ref: results.oid })],
+        map: async function(filepath, [entry]) {
+          const path = `${dir}/${filepath}`;
+          if ((await entry.type()) === 'blob') {
+            const mode = await entry.mode();
+            const content = new TextDecoder().decode(await entry.content());
+            await fs.write(path, content, { mode });
+          }
+          return true
+        },
+      });
+    }
+    throw new MergeConflictError(unmergedFiles)
+  }
+
   return results.oid
 }
 
@@ -8612,9 +8705,8 @@ async function modified(entry, base) {
  * @param {string} [args.ourName]
  * @param {string} [args.baseName]
  * @param {string} [args.theirName]
- * @param {string} [args.format]
- * @param {number} [args.markerSize]
  * @param {boolean} [args.dryRun = false]
+ * @param {MergeDriverCallback} [args.mergeDriver]
  *
  */
 async function mergeBlobs({
@@ -8627,9 +8719,8 @@ async function mergeBlobs({
   ourName,
   theirName,
   baseName,
-  format,
-  markerSize,
   dryRun,
+  mergeDriver = mergeFile,
 }) {
   const type = 'blob';
   // Compute the new mode.
@@ -8640,30 +8731,33 @@ async function mergeBlobs({
       : await ours.mode();
   // The trivial case: nothing to merge except maybe mode
   if ((await ours.oid()) === (await theirs.oid())) {
-    return { mode, path, oid: await ours.oid(), type }
+    return {
+      cleanMerge: true,
+      mergeResult: { mode, path, oid: await ours.oid(), type },
+    }
   }
   // if only one side made oid changes, return that side's oid
   if ((await ours.oid()) === (await base.oid())) {
-    return { mode, path, oid: await theirs.oid(), type }
+    return {
+      cleanMerge: true,
+      mergeResult: { mode, path, oid: await theirs.oid(), type },
+    }
   }
   if ((await theirs.oid()) === (await base.oid())) {
-    return { mode, path, oid: await ours.oid(), type }
+    return {
+      cleanMerge: true,
+      mergeResult: { mode, path, oid: await ours.oid(), type },
+    }
   }
   // if both sides made changes do a merge
-  const { mergedText, cleanMerge } = mergeFile({
-    ourContent: Buffer.from(await ours.content()).toString('utf8'),
-    baseContent: Buffer.from(await base.content()).toString('utf8'),
-    theirContent: Buffer.from(await theirs.content()).toString('utf8'),
-    ourName,
-    theirName,
-    baseName,
-    format,
-    markerSize,
+  const ourContent = Buffer.from(await ours.content()).toString('utf8');
+  const baseContent = Buffer.from(await base.content()).toString('utf8');
+  const theirContent = Buffer.from(await theirs.content()).toString('utf8');
+  const { mergedText, cleanMerge } = await mergeDriver({
+    branches: [baseName, ourName, theirName],
+    contents: [baseContent, ourContent, theirContent],
+    path,
   });
-  if (!cleanMerge) {
-    // all other types of conflicts fail
-    throw new MergeNotSupportedError()
-  }
   const oid = await _writeObject({
     fs,
     gitdir,
@@ -8671,7 +8765,8 @@ async function mergeBlobs({
     object: Buffer.from(mergedText, 'utf8'),
     dryRun,
   });
-  return { mode, path, oid, type }
+
+  return { cleanMerge, mergeResult: { mode, path, oid, type } }
 }
 
 // @ts-check
@@ -8699,6 +8794,7 @@ async function mergeBlobs({
  * @param {boolean} args.fastForwardOnly
  * @param {boolean} args.dryRun
  * @param {boolean} args.noUpdateBranch
+ * @param {boolean} args.abortOnConflict
  * @param {string} [args.message]
  * @param {Object} args.author
  * @param {string} args.author.name
@@ -8712,6 +8808,7 @@ async function mergeBlobs({
  * @param {number} args.committer.timezoneOffset
  * @param {string} [args.signingKey]
  * @param {SignCallback} [args.onSign] - a PGP signing implementation
+ * @param {MergeDriverCallback} [args.mergeDriver]
  *
  * @returns {Promise<MergeResult>} Resolves to a description of the merge operation
  *
@@ -8719,6 +8816,7 @@ async function mergeBlobs({
 async function _merge({
   fs,
   cache,
+  dir,
   gitdir,
   ours,
   theirs,
@@ -8726,11 +8824,13 @@ async function _merge({
   fastForwardOnly = false,
   dryRun = false,
   noUpdateBranch = false,
+  abortOnConflict = true,
   message,
   author,
   committer,
   signingKey,
   onSign,
+  mergeDriver,
 }) {
   if (ours === undefined) {
     ours = await _currentBranch({ fs, gitdir, fullname: true });
@@ -8790,14 +8890,17 @@ async function _merge({
     const tree = await mergeTree({
       fs,
       cache,
+      dir,
       gitdir,
       ourOid,
       theirOid,
       baseOid,
-      ourName: ours,
+      ourName: abbreviateRef(ours),
       baseName: 'base',
-      theirName: theirs,
+      theirName: abbreviateRef(theirs),
       dryRun,
+      abortOnConflict,
+      mergeDriver,
     });
     if (!message) {
       message = `Merge branch '${abbreviateRef(theirs)}' into ${abbreviateRef(
@@ -10765,11 +10868,11 @@ async function _log({
             }
           }
           if (!found) {
-            if (!force && !follow) throw e
             if (isOk && lastFileOid) {
               commits.push(lastCommit);
-              // break
+              if (!force) break
             }
+            if (!force && !follow) throw e
           }
           lastCommit = commit;
           isOk = false;
@@ -10889,15 +10992,63 @@ async function log({
 /**
  * Merge two branches
  *
- * ## Limitations
- *
- * Currently it does not support incomplete merges. That is, if there are merge conflicts it cannot solve
- * with the built in diff3 algorithm it will not modify the working dir, and will throw a [`MergeNotSupportedError`](./errors.md#mergenotsupportedError) error.
- *
  * Currently it will fail if multiple candidate merge bases are found. (It doesn't yet implement the recursive merge strategy.)
  *
  * Currently it does not support selecting alternative merge strategies.
  *
+ * Currently it is not possible to abort an incomplete merge. To restore the worktree to a clean state, you will need to checkout an earlier commit.
+ *
+ * Currently it does not directly support the behavior of `git merge --continue`. To complete a merge after manual conflict resolution, you will need to add and commit the files manually, and specify the appropriate parent commits.
+ *
+ * ## Manually resolving merge conflicts
+ * By default, if isomorphic-git encounters a merge conflict it cannot resolve using the builtin diff3 algorithm or provided merge driver, it will abort and throw a `MergeNotSupportedError`.
+ * This leaves the index and working tree untouched.
+ *
+ * When `abortOnConflict` is set to `false`, and a merge conflict cannot be automatically resolved, a `MergeConflictError` is thrown and the results of the incomplete merge will be written to the working directory.
+ * This includes conflict markers in files with unresolved merge conflicts.
+ *
+ * To complete the merge, edit the conflicting files as you see fit, and then add and commit the resolved merge.
+ *
+ * For a proper merge commit, be sure to specify the branches or commits you are merging in the `parent` argument to `git.commit`.
+ * For example, say we are merging the branch `feature` into the branch `main` and there is a conflict we want to resolve manually.
+ * The flow would look like this:
+ *
+ * ```
+ * await git.merge({
+ *   fs,
+ *   dir,
+ *   ours: 'main',
+ *   theirs: 'feature',
+ *   abortOnConflict: false,
+ * }).catch(e => {
+ *   if (e instanceof Errors.MergeConflictError) {
+ *     console.log(
+ *       'Automatic merge failed for the following files: '
+ *       + `${e.data}. `
+ *       + 'Resolve these conflicts and then commit your changes.'
+ *     )
+ *   } else throw e
+ * })
+ *
+ * // This is the where we manually edit the files that have been written to the working directory
+ * // ...
+ * // Files have been edited and we are ready to commit
+ *
+ * await git.add({
+ *   fs,
+ *   dir,
+ *   filepath: '.',
+ * })
+ *
+ * await git.commit({
+ *   fs,
+ *   dir,
+ *   ref: 'main',
+ *   message: "Merge branch 'feature' into main",
+ *   parent: ['main', 'feature'], // Be sure to specify the parents when creating a merge commit
+ * })
+ * ```
+ *
  * @param {object} args
  * @param {FsClient} args.fs - a file system client
  * @param {SignCallback} [args.onSign] - a PGP signing implementation
@@ -10909,6 +11060,7 @@ async function log({
  * @param {boolean} [args.fastForwardOnly = false] - If true, then non-fast-forward merges will throw an Error instead of performing a merge.
  * @param {boolean} [args.dryRun = false] - If true, simulates a merge so you can test whether it would succeed.
  * @param {boolean} [args.noUpdateBranch = false] - If true, does not update the branch pointer after creating the commit.
+ * @param {boolean} [args.abortOnConflict = true] - If true, merges with conflicts will not update the worktree or index.
  * @param {string} [args.message] - Overrides the default auto-generated merge commit message
  * @param {Object} [args.author] - passed to [commit](commit.md) when creating a merge commit
  * @param {string} [args.author.name] - Default is `user.name` config.
@@ -10922,6 +11074,7 @@ async function log({
  * @param {number} [args.committer.timezoneOffset] - Set the committer timezone offset field. This is the difference, in minutes, from the current timezone to UTC. Default is `(new Date()).getTimezoneOffset()`.
  * @param {string} [args.signingKey] - passed to [commit](commit.md) when creating a merge commit
  * @param {object} [args.cache] - a [cache](cache.md) object
+ * @param {MergeDriverCallback} [args.mergeDriver] - a [merge driver](mergeDriver.md) implementation
  *
  * @returns {Promise<MergeResult>} Resolves to a description of the merge operation
  * @see MergeResult
@@ -10947,11 +11100,13 @@ async function merge({
   fastForwardOnly = false,
   dryRun = false,
   noUpdateBranch = false,
+  abortOnConflict = true,
   message,
   author: _author,
   committer: _committer,
   signingKey,
   cache = {},
+  mergeDriver,
 }) {
   try {
     assertParameter('fs', _fs);
@@ -10978,6 +11133,7 @@ async function merge({
     return await _merge({
       fs,
       cache,
+      dir,
       gitdir,
       ours,
       theirs,
@@ -10985,11 +11141,13 @@ async function merge({
       fastForwardOnly,
       dryRun,
       noUpdateBranch,
+      abortOnConflict,
       message,
       author,
       committer,
       signingKey,
       onSign,
+      mergeDriver,
     })
   } catch (err) {
     err.caller = 'git.merge';