Compare gem manifest dirs by file identity

Address review of the symlink fix: decide directory identity with
same-file (device and inode) so a bind mount or Windows junction also
counts, check it once per classify, and keep an in-memory project's
paths lexical so the host's own directories never decide its verdict.

Refs #896

Assisted-by: Claude Code:claude-opus-5-5

Author: claude

crates/socket-patch-core/src/crawlers/ruby_crawler.rs

@@ -1703,7 +1703,8 @@ pub(crate) async fn bundler_loaded_manifest_in(
         ProjectView::Snapshot(snap) => {
             // The only files the probe reads: the app config, the global
             // config and `gems.rb` (the environment it also reads is fixed
-            // for the run).
+            // for the run, and the directory identity of a configured
+            // absolute path is not a file the snapshot fingerprints).
             let root = snap.root_reading(bundler_config_files(snap.root_reading::<&Path>([])));
             bundler_loaded_manifest(root).await
         }
@@ -1713,7 +1714,7 @@ pub(crate) async fn bundler_loaded_manifest_in(
             let lockfile = config.as_deref().and_then(manifest::config_lockfile);
             let root = Path::new("/");
             let gems_rb = view.is_file("gems.rb");
-            let loaded = manifest::classify(root, None, gemfile.as_deref(), None);
+            let loaded = manifest::classify_lexical(root, gemfile.as_deref());
             // `/` only stands in for the project root: bundler opens an
             // absolute lockfile as is, never the project's own lock, so
             // it must not compare equal to the pair's lock at `/`.
@@ -1725,7 +1726,7 @@ pub(crate) async fn bundler_loaded_manifest_in(
                     };
                 }
             }
-            loaded.with_lockfile(root, None, lockfile.as_deref(), None, gems_rb)
+            loaded.with_lockfile_lexical(root, lockfile.as_deref(), gems_rb)
         }
     }
 }

crates/socket-patch-core/src/formats/gem/manifest.rs

@@ -187,6 +187,44 @@ impl LoadedManifest {
         lockfile_config: Option<&str>,
         lockfile_global: Option<&str>,
         gems_rb_present: bool,
+    ) -> LoadedManifest {
+        self.with_lockfile_by(
+            root,
+            lockfile_env,
+            lockfile_config,
+            lockfile_global,
+            gems_rb_present,
+            same_dir_on_disk,
+        )
+    }
+
+    /// [`LoadedManifest::with_lockfile`] for a `root` that only stands in
+    /// for a project not on this disk (an in-memory view): paths compare
+    /// lexically, never through this host's directories.
+    pub(crate) fn with_lockfile_lexical(
+        self,
+        root: &Path,
+        lockfile_config: Option<&str>,
+        gems_rb_present: bool,
+    ) -> LoadedManifest {
+        self.with_lockfile_by(
+            root,
+            None,
+            lockfile_config,
+            None,
+            gems_rb_present,
+            |a, b| a == b,
+        )
+    }
+
+    fn with_lockfile_by(
+        self,
+        root: &Path,
+        lockfile_env: Option<&OsStr>,
+        lockfile_config: Option<&str>,
+        lockfile_global: Option<&str>,
+        gems_rb_present: bool,
+        same_dir: SameDir,
     ) -> LoadedManifest {
         let Some((_, lock)) = self.pair(gems_rb_present) else {
             return self;
@@ -206,7 +244,7 @@ impl LoadedManifest {
         let target = resolve_against(root, &value);
         let expected = resolve_against(root, Path::new(lock));
         if let (Some(target), Some(expected)) = (target, expected) {
-            if same_entry(&target, &expected) {
+            if same_entry(&target, &expected, same_dir) {
                 return self;
             }
         }
@@ -259,22 +297,22 @@ fn resolve_against(root: &Path, value: &Path) -> Option<PathBuf> {
         .and_then(|p| normalize_lexically(&p))
 }
 
-/// Whether two resolved directories are the same directory: equal, or both
-/// resolving to the same physical path through symlinks.
-fn same_dir(a: &Path, b: &Path) -> bool {
-    a == b
-        || matches!(
-            (std::fs::canonicalize(a), std::fs::canonicalize(b)),
-            (Ok(a), Ok(b)) if a == b
-        )
+/// How two resolved directories are judged the same directory.
+type SameDir = fn(&Path, &Path) -> bool;
+
+/// Whether two resolved directories are the same directory on this disk:
+/// equal, or the same directory by file identity (a symlinked spelling, a
+/// bind mount, a Windows junction).
+fn same_dir_on_disk(a: &Path, b: &Path) -> bool {
+    a == b || same_file::is_same_file(a, b).unwrap_or(false)
 }
 
 /// Whether two resolved paths name the same directory entry: the same file
-/// name in the [`same_dir`] directory. Only the directory is resolved, so a
+/// name in the `same_dir` directory. Only the directory is resolved, so a
 /// root `Gemfile` that is itself a symlink to another manifest stays
 /// distinct from that manifest, as bundler's root follows the spelled
 /// directory.
-fn same_entry(a: &Path, b: &Path) -> bool {
+fn same_entry(a: &Path, b: &Path, same_dir: SameDir) -> bool {
     a == b
         || (a.file_name() == b.file_name()
             && matches!((a.parent(), b.parent()), (Some(a), Some(b)) if same_dir(a, b)))
@@ -291,6 +329,29 @@ pub fn classify(
     gemfile_env: Option<&OsStr>,
     config_value: Option<&str>,
     global_value: Option<&str>,
+) -> LoadedManifest {
+    classify_by(
+        root,
+        gemfile_env,
+        config_value,
+        global_value,
+        same_dir_on_disk,
+    )
+}
+
+/// [`classify`] of an app config value for a `root` that only stands in
+/// for a project not on this disk (an in-memory view): paths compare
+/// lexically, never through this host's directories.
+pub(crate) fn classify_lexical(root: &Path, config_value: Option<&str>) -> LoadedManifest {
+    classify_by(root, None, config_value, None, |a, b| a == b)
+}
+
+fn classify_by(
+    root: &Path,
+    gemfile_env: Option<&OsStr>,
+    config_value: Option<&str>,
+    global_value: Option<&str>,
+    same_dir: SameDir,
 ) -> LoadedManifest {
     let env = gemfile_env.filter(|v| !v.is_empty()).map(PathBuf::from);
     let config = config_value.filter(|v| !v.is_empty()).map(PathBuf::from);
@@ -321,8 +382,11 @@ pub fn classify(
     let target = resolve_against(root, &value);
     let root = resolve_against(root, Path::new(""));
     if let (Some(target), Some(root)) = (target, root) {
-        for manifest in ["Gemfile", "gems.rb"] {
-            if same_entry(&target, &root.join(manifest)) {
+        let manifest = ["Gemfile", "gems.rb"]
+            .into_iter()
+            .find(|m| target.file_name() == Some(OsStr::new(m)));
+        if let Some(manifest) = manifest {
+            if same_entry(&target, &root.join(manifest), same_dir) {
                 return LoadedManifest::Configured { manifest, by };
             }
         }
@@ -702,6 +766,39 @@ mod tests {
         }
     }
 
+    /// An in-memory view's root only stands in for a project that is not on
+    /// this disk, so its paths never resolve through this host's
+    /// directories: a symlinked spelling stays another manifest there.
+    #[cfg(unix)]
+    #[test]
+    fn the_lexical_variants_never_read_this_hosts_directories() {
+        let tmp = tempfile::tempdir().unwrap();
+        let real = tmp.path().join("real/app");
+        std::fs::create_dir_all(&real).unwrap();
+        std::os::unix::fs::symlink(tmp.path().join("real"), tmp.path().join("link")).unwrap();
+        let link = tmp.path().join("link/app");
+        let value = link.join("Gemfile");
+        assert_eq!(
+            classify_lexical(&real, value.to_str()),
+            LoadedManifest::Unsupported {
+                value: value.display().to_string(),
+                by: GemfileSetting::AppConfig
+            }
+        );
+        assert_eq!(
+            classify_lexical(&real, Some("Gemfile")),
+            LoadedManifest::Configured {
+                manifest: "Gemfile",
+                by: GemfileSetting::AppConfig
+            }
+        );
+        let lock = link.join("Gemfile.lock");
+        assert!(matches!(
+            LoadedManifest::Default.with_lockfile_lexical(&real, lock.to_str(), false),
+            LoadedManifest::UnsupportedLockfile { .. }
+        ));
+    }
+
     /// Only the DIRECTORY is resolved: a root `Gemfile` that is itself a
     /// symlink to a manifest elsewhere does not make that manifest the
     /// project's, since bundler's root (and its lock) follow the spelled