Keep the Bundler manifest model free of I/O

The formats modules are pure by contract, and an architecture test
enforces that. Move the disk and environment reads for the manifest
Bundler loads into the ruby crawler, next to the BUNDLE_PATH config
reader. formats::gem::manifest keeps only the classification.

Refs #341, #390

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

Author: claude

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

@@ -944,6 +944,34 @@ fn expand_tilde(value: &Path, home: Option<&Path>) -> PathBuf {
     value.to_path_buf()
 }
 
+/// [`crate::formats::gem::manifest::classify`] for `root` on disk: the
+/// manifest bundler loads, reading the ambient `BUNDLE_GEMFILE` /
+/// `BUNDLE_APP_CONFIG` and the app config file.
+pub async fn bundler_loaded_manifest(root: &Path) -> crate::formats::gem::manifest::LoadedManifest {
+    bundler_loaded_manifest_with_env(
+        root,
+        std::env::var_os("BUNDLE_GEMFILE").as_deref(),
+        std::env::var_os("BUNDLE_APP_CONFIG").as_deref(),
+    )
+    .await
+}
+
+/// [`bundler_loaded_manifest`] with the environment passed explicitly (hermetic
+/// tests).
+pub async fn bundler_loaded_manifest_with_env(
+    root: &Path,
+    gemfile_env: Option<&OsStr>,
+    app_config_env: Option<&OsStr>,
+) -> crate::formats::gem::manifest::LoadedManifest {
+    let config = bundler_app_config_dir(root, app_config_env).join("config");
+    let config_value = crate::utils::fs::read_regular_to_string(&config)
+        .await
+        .ok()
+        .and_then(|text| crate::formats::gem::manifest::config_gemfile(&text));
+    let cwd = std::env::current_dir().unwrap_or_default();
+    crate::formats::gem::manifest::classify(root, &cwd, gemfile_env, config_value.as_deref())
+}
+
 /// Bundler's app-config dir for `root`, following `Bundler.app_config_path`
 /// exactly: `$BUNDLE_APP_CONFIG` when set (a relative value resolves against
 /// the project root, NOT the process cwd), else `<root>/.bundle` — e.g. the
@@ -1097,6 +1125,33 @@ fn is_safe_gem_coordinate(name: &str, version: &str) -> bool {
 mod tests {
     use super::*;
 
+    #[tokio::test]
+    async fn loaded_manifest_reads_the_app_config_file() {
+        let dir = tempfile::tempdir().unwrap();
+        std::fs::create_dir(dir.path().join(".bundle")).unwrap();
+        std::fs::write(
+            dir.path().join(".bundle/config"),
+            "---\nBUNDLE_GEMFILE: \"Gemfile.next\"\n",
+        )
+        .unwrap();
+        let m = bundler_loaded_manifest_with_env(dir.path(), None, None).await;
+        assert!(matches!(
+            m,
+            crate::formats::gem::manifest::LoadedManifest::Unsupported {
+                by: crate::formats::gem::manifest::GemfileSetting::AppConfig,
+                ..
+            }
+        ));
+        // BUNDLE_APP_CONFIG moves the config file away from `.bundle`.
+        let m = bundler_loaded_manifest_with_env(
+            dir.path(),
+            None,
+            Some(std::ffi::OsStr::new("elsewhere")),
+        )
+        .await;
+        assert_eq!(m, crate::formats::gem::manifest::LoadedManifest::Default);
+    }
+
     #[test]
     fn test_parse_gem_dir_name() {
         assert_eq!(

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

@@ -19,12 +19,14 @@
 //! directory, a missing file) is [`LoadedManifest::Unsupported`]: the
 //! rewriters and the lock readers only know the two default pairs, so the
 //! callers fail closed rather than wire a manifest Bundler never reads.
-//! The user-level `~/.bundle/config` is not consulted.
+//! The user-level `~/.bundle/config` is not consulted. The model is pure:
+//! the disk and environment reads live in
+//! [`crate::crawlers::ruby_crawler::bundler_loaded_manifest`].
 
 use std::ffi::OsStr;
 use std::path::{Path, PathBuf};
 
-use crate::crawlers::ruby_crawler::{bundler_app_config_dir, unquote_bundle_config_value};
+use crate::crawlers::ruby_crawler::unquote_bundle_config_value;
 use crate::utils::fs::normalize_lexically;
 
 /// Where a configured `BUNDLE_GEMFILE` came from.
@@ -94,33 +96,6 @@ impl LoadedManifest {
     }
 }
 
-/// [`classify`] for `root` on disk, reading the ambient `BUNDLE_GEMFILE` /
-/// `BUNDLE_APP_CONFIG` and the app config file.
-pub async fn loaded_manifest(root: &Path) -> LoadedManifest {
-    loaded_manifest_with_env(
-        root,
-        std::env::var_os("BUNDLE_GEMFILE").as_deref(),
-        std::env::var_os("BUNDLE_APP_CONFIG").as_deref(),
-    )
-    .await
-}
-
-/// [`loaded_manifest`] with the environment passed explicitly (hermetic
-/// tests).
-pub async fn loaded_manifest_with_env(
-    root: &Path,
-    gemfile_env: Option<&OsStr>,
-    app_config_env: Option<&OsStr>,
-) -> LoadedManifest {
-    let config = bundler_app_config_dir(root, app_config_env).join("config");
-    let config_value = crate::utils::fs::read_regular_to_string(&config)
-        .await
-        .ok()
-        .and_then(|text| config_gemfile(&text));
-    let cwd = std::env::current_dir().unwrap_or_default();
-    classify(root, &cwd, gemfile_env, config_value.as_deref())
-}
-
 /// The `BUNDLE_GEMFILE:` value of a bundler app config file (flat YAML that
 /// bundler writes itself; an empty value counts as unset).
 pub fn config_gemfile(contents: &str) -> Option<String> {
@@ -264,26 +239,4 @@ mod tests {
         assert_eq!(config_gemfile("---\nBUNDLE_GEMFILE: \"\"\n"), None);
         assert_eq!(config_gemfile("---\nBUNDLE_PATH: \"x\"\n"), None);
     }
-
-    #[tokio::test]
-    async fn loaded_manifest_reads_the_app_config_file() {
-        let dir = tempfile::tempdir().unwrap();
-        std::fs::create_dir(dir.path().join(".bundle")).unwrap();
-        std::fs::write(
-            dir.path().join(".bundle/config"),
-            "---\nBUNDLE_GEMFILE: \"Gemfile.next\"\n",
-        )
-        .unwrap();
-        let m = loaded_manifest_with_env(dir.path(), None, None).await;
-        assert!(matches!(
-            m,
-            LoadedManifest::Unsupported {
-                by: GemfileSetting::AppConfig,
-                ..
-            }
-        ));
-        // BUNDLE_APP_CONFIG moves the config file away from `.bundle`.
-        let m = loaded_manifest_with_env(dir.path(), None, Some(OsStr::new("elsewhere"))).await;
-        assert_eq!(m, LoadedManifest::Default);
-    }
 }

crates/socket-patch-core/src/hosted/engine.rs

@@ -476,7 +476,7 @@ async fn keep_bundler_loaded_gem_files(view: &ProjectView<'_>, out: &mut Candida
     let loaded = match view {
         ProjectView::Disk(root)
         | ProjectView::Snapshot(crate::vendor::lock_inventory::DiskSnapshot { root, .. }) => {
-            manifest::loaded_manifest(root).await
+            crate::crawlers::ruby_crawler::bundler_loaded_manifest(root).await
         }
         ProjectView::Memory(_) => {
             let config = view.read_text(".bundle/config").await.ok();

crates/socket-patch-core/src/vendor/gem.rs

@@ -146,7 +146,7 @@ struct GemPrelude {
 /// its hosted wiring instead of ending up unpatched in both modes.
 pub async fn gem_manifest_refusal(project_root: &Path) -> Option<(&'static str, String)> {
     use crate::formats::gem::manifest::LoadedManifest;
-    let loaded = crate::formats::gem::manifest::loaded_manifest(project_root).await;
+    let loaded = crate::crawlers::ruby_crawler::bundler_loaded_manifest(project_root).await;
     let gems_rb_present = tokio::fs::symlink_metadata(project_root.join("gems.rb"))
         .await
         .is_ok();