cargo-rail: fixing the failed integration tests by adjusting the 'unify'

task to require resolved metadata. We might come back later for an
offline mode.

Author: loadingalias

next_phase.md

@@ -68,6 +68,7 @@ cargo-rail becomes the default answer to:
     - `CargoRailOutputCtx` is initialized once in `src/main.rs` based on global `--quiet` + `--json` / per-command `--format`.
     - `WorkspaceContext::build(..., output)` stores the output context and exposes it via `ctx.output()`.
     - Commands and subsystems write status/progress/warnings via `ctx.output()` (stdout remains reserved for command results).
+    - `cargo rail unify` now fails fast with actionable errors if resolved metadata cannot be loaded (e.g., offline with missing cache).
   - Deliverable: a single initialization point for output mode; no duplicated init calls in command handlers.
   - Docs: `docs/output.md`
   - Exit criteria: `just check && just test`

src/cargo/unify_analyzer.rs

@@ -38,9 +38,11 @@ pub struct UnifyAnalyzer {
 impl UnifyAnalyzer {
   /// Create a new analyzer from workspace context
   pub fn new(ctx: &WorkspaceContext) -> RailResult<Self> {
-    // Get multi-target metadata (lazily loaded on first access)
-    // This clones the inner data (required for ownership by this analyzer)
-    let metadata = (*ctx.multi_target_metadata()?).clone();
+    // Unify requires resolved cargo metadata to be safe and correct.
+    let metadata = (*ctx.multi_target_metadata().with_context(|| {
+      "unify requires resolved cargo metadata; run `cargo fetch` (or disable offline) and try again".to_string()
+    })?)
+    .clone();
 
     // Parse all manifests once
     let workspace_packages = metadata.workspace_packages();
@@ -231,9 +233,7 @@ impl UnifyAnalyzer {
           .cloned()
           .unwrap_or_else(|| format!("={}", version));
         // Try exact version first, fall back to caret format, then ultimate fallback
-        VersionReq::parse(&exact_version)
-          .or_else(|_| VersionReq::parse(&format!("^{}", version)))
-          .unwrap_or_else(|_| VersionReq::default())
+        VersionReq::parse(&exact_version).unwrap_or_else(|_| VersionReq::default())
       } else {
         // Try caret format first, fall back to plain version, then ultimate fallback
         VersionReq::parse(&format!("^{}", version))
@@ -319,14 +319,15 @@ impl UnifyAnalyzer {
         }
       };
 
-      // Check if target-specific
-      let targets_with_dep = self.metadata.targets_with_dep(&dep_key.name);
-      let all_targets = self.metadata.targets();
-      let target = if targets_with_dep.len() < all_targets.len() {
-        // This is target-specific, try to infer cfg
-        Some(self.infer_target_cfg(&targets_with_dep))
-      } else {
+      // Best-effort target constraint display.
+      // Feature computation already excludes target-specific usages from workspace-level features.
+      let target_cfgs: HashSet<String> = usage_sites.iter().filter_map(|u| u.target.clone()).collect();
+      let target = if target_cfgs.is_empty() {
         None
+      } else if target_cfgs.len() == 1 {
+        target_cfgs.into_iter().next()
+      } else {
+        Some("multiple target cfgs".to_string())
       };
 
       // Get users - convert Arc<str> to String for output
@@ -612,26 +613,6 @@ impl UnifyAnalyzer {
     Ok(results)
   }
 
-  /// Infer a cfg expression from a list of targets
-  fn infer_target_cfg(&self, targets: &[String]) -> String {
-    // Simple heuristic: if all Unix-like, use cfg(unix)
-    if targets.iter().all(|t| t.contains("linux") || t.contains("darwin")) {
-      "cfg(unix)".to_string()
-    } else if targets.iter().all(|t| t.contains("windows")) {
-      "cfg(windows)".to_string()
-    } else {
-      // Fall back to listing all targets
-      format!(
-        "cfg(any({}))",
-        targets
-          .iter()
-          .map(|t| format!("target = \"{}\"", t))
-          .collect::<Vec<_>>()
-          .join(", ")
-      )
-    }
-  }
-
   /// Detect dependencies where resolved features exceed declared features
   ///
   /// This catches cases where a crate relies on Cargo's feature unification to

tests/integration/helpers.rs

@@ -436,8 +436,6 @@ pub fn run_cargo_rail(cwd: &Path, args: &[&str]) -> Result<Output> {
 
   let output = Command::new(cargo_rail_bin)
     .current_dir(cwd)
-    // Keep integration tests hermetic: prevent Cargo from attempting network access for metadata/resolution.
-    .env("CARGO_NET_OFFLINE", "true")
     .args(args)
     .output()
     .context("Failed to run cargo-rail")?;

tests/integration/test_cli_api.rs

@@ -19,7 +19,6 @@ fn run_cargo_rail(cwd: &Path, args: &[&str], envs: &[(&str, &str)]) -> Result<Ou
   let cargo_rail_bin = env!("CARGO_BIN_EXE_cargo-rail");
   let mut cmd = Command::new(cargo_rail_bin);
   cmd.current_dir(cwd).args(args);
-  cmd.env("CARGO_NET_OFFLINE", "true");
   for (k, v) in envs {
     cmd.env(k, v);
   }