isomorphic-git 1.40.0 → 1.40.2

package/index.cjs

@@ -1332,6 +1332,23 @@ class InvalidOidError extends BaseError {
 /** @type {'InvalidOidError'} */
 InvalidOidError.code = 'InvalidOidError';
 
+class InvalidRefNameError extends BaseError {
+  /**
+   * @param {string} ref
+   * @param {string} suggestion
+   * @param {boolean} canForce
+   */
+  constructor(ref, suggestion) {
+    super(
+      `"${ref}" would be an invalid git reference. (Hint: a valid alternative would be "${suggestion}".)`
+    );
+    this.code = this.name = InvalidRefNameError.code;
+    this.data = { ref, suggestion };
+  }
+}
+/** @type {'InvalidRefNameError'} */
+InvalidRefNameError.code = 'InvalidRefNameError';
+
 class NoRefspecError extends BaseError {
   /**
    * @param {string} remote
@@ -2003,6 +2020,16 @@ const refpaths = ref => [
 // @see https://git-scm.com/docs/gitrepository-layout
 const GIT_FILES = ['config', 'description', 'index', 'shallow', 'commondir'];
 
+// These names are legal one-level ref names, so nothing upstream of here
+// rejects them, and writing to one lands on the repository file itself.
+// Canonical git refuses too: `git update-ref index <oid>` fails with
+// "cannot lock ref 'index': reference broken" and leaves the file alone.
+function assertWritableRef(ref) {
+  if (GIT_FILES.includes(ref)) {
+    throw new InvalidRefNameError(ref, `refs/heads/${ref}`)
+  }
+}
+
 let lock$1;
 
 async function acquireLock(ref, callback) {
@@ -2057,6 +2084,31 @@ class GitRefManager {
     }
     const refspec = GitRefSpecSet.from(refspecs);
     const actualRefsToWrite = new Map();
+    // Work out every destination this call will write, before touching the
+    // repository. Translating is pure, so it can happen up here; the writes
+    // themselves stay at the end of the function.
+    const refTranslations = refspec.translate([...refs.keys()]);
+    const symrefTranslations = [];
+    for (const [serverRef, translatedRef] of refspec.translate([
+      ...symrefs.keys(),
+    ])) {
+      const symtarget = refspec.translateOne(symrefs.get(serverRef));
+      if (symtarget) {
+        symrefTranslations.push([translatedRef, `ref: ${symtarget}`]);
+      }
+    }
+    // The local side of a refspec is whatever `remote.<name>.fetch` says, so a
+    // config like `+refs/heads/main:index` lands a write on `.git/index`.
+    // Refuse it here rather than at the write loop: `pruneTags` and `prune`
+    // delete refs in between, so a later throw leaves the repository pruned
+    // and not updated. The tags added below are always `refs/tags/...`, which
+    // is never a system file, so nothing is missed by checking this early.
+    for (const [, translatedRef] of refTranslations) {
+      assertWritableRef(translatedRef);
+    }
+    for (const [translatedRef] of symrefTranslations) {
+      assertWritableRef(translatedRef);
+    }
     // Delete all current tags if the pruneTags argument is true.
     if (pruneTags) {
       const tags = await GitRefManager.listRefs({
@@ -2084,18 +2136,12 @@ class GitRefManager {
       }
     }
     // Combine refs and symrefs giving symrefs priority
-    const refTranslations = refspec.translate([...refs.keys()]);
     for (const [serverRef, translatedRef] of refTranslations) {
       const value = refs.get(serverRef);
       actualRefsToWrite.set(translatedRef, value);
     }
-    const symrefTranslations = refspec.translate([...symrefs.keys()]);
-    for (const [serverRef, translatedRef] of symrefTranslations) {
-      const value = symrefs.get(serverRef);
-      const symtarget = refspec.translateOne(value);
-      if (symtarget) {
-        actualRefsToWrite.set(translatedRef, `ref: ${symtarget}`);
-      }
+    for (const [translatedRef, value] of symrefTranslations) {
+      actualRefsToWrite.set(translatedRef, value);
     }
     // If `prune` argument is true, clear out the existing local refspec roots
     const pruned = [];
@@ -2154,6 +2200,7 @@ class GitRefManager {
   // TODO: make this less crude?
   static async writeRef({ fs, gitdir, ref, value }) {
     // Validate input
+    assertWritableRef(ref);
     if (!value.match(/[0-9a-f]{40}/)) {
       throw new InvalidOidError(value)
     }
@@ -2173,6 +2220,7 @@ class GitRefManager {
    * @returns {Promise<void>}
    */
   static async writeSymbolicRef({ fs, gitdir, ref, value }) {
+    assertWritableRef(ref);
     await acquireLock(ref, async () =>
       fs.write(join(gitdir, ref), 'ref: ' + `${value.trim()}\n`, 'utf8')
     );
@@ -2201,6 +2249,8 @@ class GitRefManager {
    * @returns {Promise<void>}
    */
   static async deleteRefs({ fs, gitdir, refs }) {
+    // Validate input
+    refs.forEach(assertWritableRef);
     // Delete regular ref
     await Promise.all(refs.map(ref => fs.rm(join(gitdir, ref))));
     // Delete any packed ref
@@ -2324,7 +2374,7 @@ class GitRefManager {
     // We need to alternate between the file system and the packed-refs
     const packedMap = await GitRefManager.packedRefs({ fs, gitdir });
     // Look in all the proper paths, in this order
-    const allpaths = refpaths(ref);
+    const allpaths = refpaths(ref).filter(p => !GIT_FILES.includes(p)); // exclude git system files (#709)
     for (const ref of allpaths) {
       const refExists = await acquireLock(ref, async () =>
         fs.exists(`${gitdir}/${ref}`)
@@ -3824,23 +3874,6 @@ class InvalidFilepathError extends BaseError {
 /** @type {'InvalidFilepathError'} */
 InvalidFilepathError.code = 'InvalidFilepathError';
 
-class InvalidRefNameError extends BaseError {
-  /**
-   * @param {string} ref
-   * @param {string} suggestion
-   * @param {boolean} canForce
-   */
-  constructor(ref, suggestion) {
-    super(
-      `"${ref}" would be an invalid git reference. (Hint: a valid alternative would be "${suggestion}".)`
-    );
-    this.code = this.name = InvalidRefNameError.code;
-    this.data = { ref, suggestion };
-  }
-}
-/** @type {'InvalidRefNameError'} */
-InvalidRefNameError.code = 'InvalidRefNameError';
-
 class MaxDepthError extends BaseError {
   /**
    * @param {number} depth
@@ -5732,6 +5765,18 @@ async function add({
   }
 }
 
+// True for a path the index already holds, and for a folder holding one. The
+// exact lookup is a Map hit; the prefix scan only runs for folders, since a
+// tracked file always answers on the first check.
+function isTracked(index, filepath) {
+  if (index.has({ filepath })) return true
+  const prefix = `${filepath}/`;
+  for (const entry of index.entriesMap.keys()) {
+    if (entry.startsWith(prefix)) return true
+  }
+  return false
+}
+
 async function addToIndex({
   dir,
   gitdir,
@@ -5742,10 +5787,13 @@ async function addToIndex({
   parallel,
   autocrlf,
 }) {
-  // TODO: Should ignore UNLESS it's already in the index.
   filepath = Array.isArray(filepath) ? filepath : [filepath];
   const promises = filepath.map(async currentFilepath => {
-    if (!force) {
+    // .gitignore governs untracked paths. Once a path is in the index, adding a
+    // matching rule does not stop canonical git from staging further changes,
+    // and an ignored folder is still walked for the sake of what it tracks:
+    // the recursion below re-checks every child, so only tracked ones get in.
+    if (!force && !isTracked(index, currentFilepath)) {
       const ignored = await GitIgnoreManager.isIgnored({
         fs,
         dir,
@@ -9524,8 +9572,8 @@ function filterCapabilities(server, client) {
 
 const pkg = {
   name: 'isomorphic-git',
-  version: '1.40.0',
-  agent: 'git/isomorphic-git@1.40.0',
+  version: '1.40.2',
+  agent: 'git/isomorphic-git@1.40.2',
 };
 
 class FIFO {
@@ -16308,15 +16356,6 @@ async function status({
 
     const fs = new FileSystem(_fs);
     const updatedGitdir = await discoverGitdir({ fsp: fs, dotgit: gitdir });
-    const ignored = await GitIgnoreManager.isIgnored({
-      fs,
-      gitdir: updatedGitdir,
-      dir,
-      filepath,
-    });
-    if (ignored) {
-      return 'ignored'
-    }
     const headTree = await getHeadTree({ fs, cache, gitdir: updatedGitdir });
     const treeOid = await getOidAtPath({
       fs,
@@ -16334,6 +16373,20 @@ async function status({
         return null
       }
     );
+    // .gitignore governs untracked files. A file in HEAD or in the index is
+    // tracked, so canonical git keeps reporting its real state, and
+    // `git check-ignore` does not match it. statusMatrix already does this.
+    if (treeOid === null && indexEntry === null) {
+      const ignored = await GitIgnoreManager.isIgnored({
+        fs,
+        gitdir: updatedGitdir,
+        dir,
+        filepath,
+      });
+      if (ignored) {
+        return 'ignored'
+      }
+    }
     const stats = await fs.lstat(join(dir, filepath));
 
     const H = treeOid !== null; // head

package/index.js

@@ -1325,6 +1325,23 @@ class InvalidOidError extends BaseError {
 /** @type {'InvalidOidError'} */
 InvalidOidError.code = 'InvalidOidError';
 
+class InvalidRefNameError extends BaseError {
+  /**
+   * @param {string} ref
+   * @param {string} suggestion
+   * @param {boolean} canForce
+   */
+  constructor(ref, suggestion) {
+    super(
+      `"${ref}" would be an invalid git reference. (Hint: a valid alternative would be "${suggestion}".)`
+    );
+    this.code = this.name = InvalidRefNameError.code;
+    this.data = { ref, suggestion };
+  }
+}
+/** @type {'InvalidRefNameError'} */
+InvalidRefNameError.code = 'InvalidRefNameError';
+
 class NoRefspecError extends BaseError {
   /**
    * @param {string} remote
@@ -1996,6 +2013,16 @@ const refpaths = ref => [
 // @see https://git-scm.com/docs/gitrepository-layout
 const GIT_FILES = ['config', 'description', 'index', 'shallow', 'commondir'];
 
+// These names are legal one-level ref names, so nothing upstream of here
+// rejects them, and writing to one lands on the repository file itself.
+// Canonical git refuses too: `git update-ref index <oid>` fails with
+// "cannot lock ref 'index': reference broken" and leaves the file alone.
+function assertWritableRef(ref) {
+  if (GIT_FILES.includes(ref)) {
+    throw new InvalidRefNameError(ref, `refs/heads/${ref}`)
+  }
+}
+
 let lock$1;
 
 async function acquireLock(ref, callback) {
@@ -2050,6 +2077,31 @@ class GitRefManager {
     }
     const refspec = GitRefSpecSet.from(refspecs);
     const actualRefsToWrite = new Map();
+    // Work out every destination this call will write, before touching the
+    // repository. Translating is pure, so it can happen up here; the writes
+    // themselves stay at the end of the function.
+    const refTranslations = refspec.translate([...refs.keys()]);
+    const symrefTranslations = [];
+    for (const [serverRef, translatedRef] of refspec.translate([
+      ...symrefs.keys(),
+    ])) {
+      const symtarget = refspec.translateOne(symrefs.get(serverRef));
+      if (symtarget) {
+        symrefTranslations.push([translatedRef, `ref: ${symtarget}`]);
+      }
+    }
+    // The local side of a refspec is whatever `remote.<name>.fetch` says, so a
+    // config like `+refs/heads/main:index` lands a write on `.git/index`.
+    // Refuse it here rather than at the write loop: `pruneTags` and `prune`
+    // delete refs in between, so a later throw leaves the repository pruned
+    // and not updated. The tags added below are always `refs/tags/...`, which
+    // is never a system file, so nothing is missed by checking this early.
+    for (const [, translatedRef] of refTranslations) {
+      assertWritableRef(translatedRef);
+    }
+    for (const [translatedRef] of symrefTranslations) {
+      assertWritableRef(translatedRef);
+    }
     // Delete all current tags if the pruneTags argument is true.
     if (pruneTags) {
       const tags = await GitRefManager.listRefs({
@@ -2077,18 +2129,12 @@ class GitRefManager {
       }
     }
     // Combine refs and symrefs giving symrefs priority
-    const refTranslations = refspec.translate([...refs.keys()]);
     for (const [serverRef, translatedRef] of refTranslations) {
       const value = refs.get(serverRef);
       actualRefsToWrite.set(translatedRef, value);
     }
-    const symrefTranslations = refspec.translate([...symrefs.keys()]);
-    for (const [serverRef, translatedRef] of symrefTranslations) {
-      const value = symrefs.get(serverRef);
-      const symtarget = refspec.translateOne(value);
-      if (symtarget) {
-        actualRefsToWrite.set(translatedRef, `ref: ${symtarget}`);
-      }
+    for (const [translatedRef, value] of symrefTranslations) {
+      actualRefsToWrite.set(translatedRef, value);
     }
     // If `prune` argument is true, clear out the existing local refspec roots
     const pruned = [];
@@ -2147,6 +2193,7 @@ class GitRefManager {
   // TODO: make this less crude?
   static async writeRef({ fs, gitdir, ref, value }) {
     // Validate input
+    assertWritableRef(ref);
     if (!value.match(/[0-9a-f]{40}/)) {
       throw new InvalidOidError(value)
     }
@@ -2166,6 +2213,7 @@ class GitRefManager {
    * @returns {Promise<void>}
    */
   static async writeSymbolicRef({ fs, gitdir, ref, value }) {
+    assertWritableRef(ref);
     await acquireLock(ref, async () =>
       fs.write(join(gitdir, ref), 'ref: ' + `${value.trim()}\n`, 'utf8')
     );
@@ -2194,6 +2242,8 @@ class GitRefManager {
    * @returns {Promise<void>}
    */
   static async deleteRefs({ fs, gitdir, refs }) {
+    // Validate input
+    refs.forEach(assertWritableRef);
     // Delete regular ref
     await Promise.all(refs.map(ref => fs.rm(join(gitdir, ref))));
     // Delete any packed ref
@@ -2317,7 +2367,7 @@ class GitRefManager {
     // We need to alternate between the file system and the packed-refs
     const packedMap = await GitRefManager.packedRefs({ fs, gitdir });
     // Look in all the proper paths, in this order
-    const allpaths = refpaths(ref);
+    const allpaths = refpaths(ref).filter(p => !GIT_FILES.includes(p)); // exclude git system files (#709)
     for (const ref of allpaths) {
       const refExists = await acquireLock(ref, async () =>
         fs.exists(`${gitdir}/${ref}`)
@@ -3811,23 +3861,6 @@ class InvalidFilepathError extends BaseError {
 /** @type {'InvalidFilepathError'} */
 InvalidFilepathError.code = 'InvalidFilepathError';
 
-class InvalidRefNameError extends BaseError {
-  /**
-   * @param {string} ref
-   * @param {string} suggestion
-   * @param {boolean} canForce
-   */
-  constructor(ref, suggestion) {
-    super(
-      `"${ref}" would be an invalid git reference. (Hint: a valid alternative would be "${suggestion}".)`
-    );
-    this.code = this.name = InvalidRefNameError.code;
-    this.data = { ref, suggestion };
-  }
-}
-/** @type {'InvalidRefNameError'} */
-InvalidRefNameError.code = 'InvalidRefNameError';
-
 class MaxDepthError extends BaseError {
   /**
    * @param {number} depth
@@ -5719,6 +5752,18 @@ async function add({
   }
 }
 
+// True for a path the index already holds, and for a folder holding one. The
+// exact lookup is a Map hit; the prefix scan only runs for folders, since a
+// tracked file always answers on the first check.
+function isTracked(index, filepath) {
+  if (index.has({ filepath })) return true
+  const prefix = `${filepath}/`;
+  for (const entry of index.entriesMap.keys()) {
+    if (entry.startsWith(prefix)) return true
+  }
+  return false
+}
+
 async function addToIndex({
   dir,
   gitdir,
@@ -5729,10 +5774,13 @@ async function addToIndex({
   parallel,
   autocrlf,
 }) {
-  // TODO: Should ignore UNLESS it's already in the index.
   filepath = Array.isArray(filepath) ? filepath : [filepath];
   const promises = filepath.map(async currentFilepath => {
-    if (!force) {
+    // .gitignore governs untracked paths. Once a path is in the index, adding a
+    // matching rule does not stop canonical git from staging further changes,
+    // and an ignored folder is still walked for the sake of what it tracks:
+    // the recursion below re-checks every child, so only tracked ones get in.
+    if (!force && !isTracked(index, currentFilepath)) {
       const ignored = await GitIgnoreManager.isIgnored({
         fs,
         dir,
@@ -9511,8 +9559,8 @@ function filterCapabilities(server, client) {
 
 const pkg = {
   name: 'isomorphic-git',
-  version: '1.40.0',
-  agent: 'git/isomorphic-git@1.40.0',
+  version: '1.40.2',
+  agent: 'git/isomorphic-git@1.40.2',
 };
 
 class FIFO {
@@ -16295,15 +16343,6 @@ async function status({
 
     const fs = new FileSystem(_fs);
     const updatedGitdir = await discoverGitdir({ fsp: fs, dotgit: gitdir });
-    const ignored = await GitIgnoreManager.isIgnored({
-      fs,
-      gitdir: updatedGitdir,
-      dir,
-      filepath,
-    });
-    if (ignored) {
-      return 'ignored'
-    }
     const headTree = await getHeadTree({ fs, cache, gitdir: updatedGitdir });
     const treeOid = await getOidAtPath({
       fs,
@@ -16321,6 +16360,20 @@ async function status({
         return null
       }
     );
+    // .gitignore governs untracked files. A file in HEAD or in the index is
+    // tracked, so canonical git keeps reporting its real state, and
+    // `git check-ignore` does not match it. statusMatrix already does this.
+    if (treeOid === null && indexEntry === null) {
+      const ignored = await GitIgnoreManager.isIgnored({
+        fs,
+        gitdir: updatedGitdir,
+        dir,
+        filepath,
+      });
+      if (ignored) {
+        return 'ignored'
+      }
+    }
     const stats = await fs.lstat(join(dir, filepath));
 
     const H = treeOid !== null; // head