Refactor: move workspace registry to core

This allows for adding a new type of `DiscoverStart` that uses
the workspace registry to find the pixi manifest.

Author: soapy1

Cargo.lock

@@ -39,11 +39,9 @@ rattler_repodata_gateway = { workspace = true, features = [
 regex = { workspace = true }
 same-file = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
-serde_ignored = { workspace = true }
 strsim = { workspace = true }
 tempfile = { workspace = true }
 tokio = { workspace = true, features = ["fs"] }
-toml_edit = { workspace = true, features = ["serde"] }
 tracing = { workspace = true }
 url = { workspace = true }
 uv-normalize = { workspace = true }

crates/pixi_api/Cargo.toml

@@ -18,6 +18,3 @@ pub(crate) mod task;
 #[allow(clippy::module_inception)]
 pub(crate) mod workspace;
 pub use workspace::channel::ChannelOptions;
-
-pub(crate) mod registry;
-pub use registry::WorkspaceRegistry;

crates/pixi_api/src/workspace/mod.rs

@@ -1,6 +1,6 @@
-use pixi_api::workspace::WorkspaceRegistry;
 use pixi_consts::consts;
 use pixi_core::WorkspaceLocator;
+use pixi_core::workspace::WorkspaceRegistry;
 use pixi_manifest::EnvironmentName;
 use std::path::PathBuf;
 use std::time::Duration;

crates/pixi_cli/src/clean.rs

@@ -5,7 +5,6 @@ use indexmap::IndexSet;
 use itertools::Itertools;
 use miette::IntoDiagnostic;
 use pep508_rs::Requirement;
-use pixi_api::workspace::WorkspaceRegistry;
 use pixi_build_frontend::BackendOverride;
 use pixi_config::Config;
 use pixi_consts::consts;
@@ -48,12 +47,7 @@ impl WorkspaceConfig {
         if let Some(manifest_path) = &self.manifest_path {
             DiscoveryStart::ExplicitManifest(manifest_path.clone())
         } else if let Some(workspace) = &self.workspace {
-            let workspace_registry =
-                WorkspaceRegistry::load().expect("Unable to load workspace registry");
-            let path = workspace_registry
-                .named_workspace(workspace)
-                .expect("Unable to find workspace");
-            DiscoveryStart::ExplicitManifest(path)
+            DiscoveryStart::WorkspaceRegistry(workspace.clone())
         } else {
             DiscoveryStart::CurrentDir
         }

crates/pixi_cli/src/cli_config.rs

@@ -4,8 +4,8 @@ use std::path::PathBuf;
 use crate::cli_config::WorkspaceConfig;
 use clap::Parser;
 use miette::IntoDiagnostic;
-use pixi_api::workspace::WorkspaceRegistry;
 use pixi_core::WorkspaceLocator;
+use pixi_core::workspace::WorkspaceRegistry;
 
 /// Commands to manage the registry of workspaces. Default command will add a new workspace
 #[derive(Parser, Debug, Clone)]

crates/pixi_cli/src/workspace/register.rs

@@ -68,9 +68,11 @@ rattler_solve = { workspace = true }
 rattler_virtual_packages = { workspace = true }
 rstest = { workspace = true }
 serde = { workspace = true }
+serde_ignored = { workspace = true }
 serde_json = { workspace = true }
 tabwriter = { workspace = true }
 tempfile = { workspace = true }
+temp-env = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true }
 toml_edit = { workspace = true }

crates/pixi_core/Cargo.toml

@@ -10,6 +10,7 @@ use pixi_manifest::{
 use thiserror::Error;
 
 use crate::workspace::Workspace;
+use crate::workspace::WorkspaceRegistry;
 
 /// Defines where the search for the workspace should start.
 #[derive(Debug, Clone, Default)]
@@ -30,6 +31,11 @@ pub enum DiscoveryStart {
     ///
     /// If no manifest is found at the given path the search will abort.
     ExplicitManifest(PathBuf),
+
+    /// Search by name in the workspace registry.
+    ///
+    /// If the name is not found in the registry, abort.
+    WorkspaceRegistry(String),
 }
 
 impl DiscoveryStart {
@@ -39,6 +45,14 @@ impl DiscoveryStart {
             DiscoveryStart::CurrentDir => std::env::current_dir(),
             DiscoveryStart::SearchRoot(path) => Ok(path.clone()),
             DiscoveryStart::ExplicitManifest(path) => Ok(path.clone()),
+            DiscoveryStart::WorkspaceRegistry(name) => {
+                let registry = WorkspaceRegistry::load()
+                    .map_err(|_| WorkspaceLocatorError::MissingRegistry())?;
+                let path = registry
+                    .named_workspace(name)
+                    .map_err(|_| WorkspaceLocatorError::MissingWorkspace(name.clone()))?;
+                Ok(path)
+            }
         }
     }
 }
@@ -97,6 +111,19 @@ pub enum WorkspaceLocatorError {
     #[error(transparent)]
     #[diagnostic(transparent)]
     ExplicitManifestError(#[from] ExplicitManifestError),
+
+    #[error("unable to load the workspace registry")]
+    MissingRegistry(),
+
+    #[error("could not find workspace '{}'", .0)]
+    MissingWorkspace(String),
+}
+
+impl From<WorkspaceLocatorError> for std::io::Error {
+    fn from(err: WorkspaceLocatorError) -> Self {
+        // Create a new std::io::Error, using Other kind and the source error
+        std::io::Error::other(err)
+    }
 }
 
 impl WorkspaceLocator {
@@ -160,6 +187,14 @@ impl WorkspaceLocator {
                 std::env::current_dir().map_err(WorkspaceLocatorError::CurrentDir)?,
             ),
             DiscoveryStart::SearchRoot(path) => pixi_manifest::DiscoveryStart::SearchRoot(path),
+            DiscoveryStart::WorkspaceRegistry(name) => {
+                let registry = WorkspaceRegistry::load()
+                    .map_err(|_| WorkspaceLocatorError::MissingRegistry())?;
+                let path = registry
+                    .named_workspace(&name)
+                    .map_err(|_| WorkspaceLocatorError::MissingWorkspace(name.clone()))?;
+                pixi_manifest::DiscoveryStart::ExplicitManifest(path)
+            }
         };
 
         let discovery_source = discovery_start.root().to_path_buf();
@@ -290,6 +325,9 @@ impl WorkspaceLocator {
 mod test {
     use std::path::Path;
 
+    use temp_env;
+    use tempfile::tempdir;
+
     use super::*;
 
     #[test]
@@ -323,6 +361,52 @@ mod test {
         assert_eq!(workspace.root, project_root);
     }
 
+    #[tokio::test]
+    async fn test_workspace_locator_registered_workspace() {
+        // Equivalent to `pixi xxx --workspace ws`
+        let temp_dir = tempdir().unwrap();
+        let pixi_home_dir = temp_dir.path().join("pixi-home");
+        let crate_root = std::env::var("CARGO_MANIFEST_DIR").unwrap();
+        let project_root = Path::new(&crate_root).parent().unwrap().parent().unwrap();
+        temp_env::async_with_vars(
+            [("PIXI_HOME", Some(pixi_home_dir.to_str().unwrap()))],
+            async {
+                WorkspaceRegistry::default()
+                    .add_workspace("ws".to_string(), project_root.to_path_buf())
+                    .await
+                    .unwrap();
+
+                let workspace_locator = WorkspaceLocator::default()
+                    .with_search_start(DiscoveryStart::WorkspaceRegistry("ws".to_string()));
+                let workspace = workspace_locator.locate().unwrap();
+                assert_eq!(workspace.root, project_root);
+            },
+        )
+        .await;
+    }
+
+    #[test]
+    fn test_workspace_locator_registered_workspace_does_not_exist() {
+        // Equivalent to `pixi xxx --workspace idontexist`
+        let temp_dir = tempdir().unwrap();
+        let pixi_home_dir = temp_dir.path().join("pixi-home");
+        temp_env::with_var("PIXI_HOME", Some(pixi_home_dir.to_str().unwrap()), || {
+            let workspace_locator = WorkspaceLocator::default()
+                .with_search_start(DiscoveryStart::WorkspaceRegistry("idontexist".to_string()));
+
+            let result = workspace_locator.locate();
+            assert!(result.is_err());
+
+            let error = result.unwrap_err();
+            assert!(matches!(error, WorkspaceLocatorError::MissingWorkspace(_)));
+
+            // Check that the error message contains the suggestion
+            let error_message = error.to_string();
+            assert!(error_message.contains("could not find workspace "));
+            assert!(error_message.contains("idontexist"));
+        });
+    }
+
     #[test]
     fn test_workspace_locator_explicit_simple() {
         // Equivalent to `pixi xxx --manifest pixi.toml`

crates/pixi_core/src/workspace/discovery.rs

@@ -3,6 +3,7 @@ mod environment;
 pub mod errors;
 pub mod grouped_environment;
 mod has_project_ref;
+pub mod registry;
 mod repodata;
 mod solve_group;
 pub mod virtual_packages;
@@ -58,6 +59,7 @@ use rattler_lock::{LockFile, LockedPackageRef};
 use rattler_networking::{LazyClient, s3_middleware};
 use rattler_repodata_gateway::Gateway;
 use rattler_virtual_packages::{VirtualPackageOverrides, VirtualPackages};
+pub use registry::WorkspaceRegistry;
 pub use solve_group::SolveGroup;
 use tokio::sync::Semaphore;
 use url::Url;

crates/pixi_core/src/workspace/mod.rs

@@ -1,12 +1,10 @@
 use std::collections::HashMap;
-
-use miette::{Context, IntoDiagnostic};
-use serde::{Deserialize, Serialize};
-
 use std::path::PathBuf;
 
+use miette::{Context, IntoDiagnostic};
 use pixi_config::pixi_home;
 use pixi_consts::consts;
+use serde::{Deserialize, Serialize};
 
 /// Returns the path to the workspace registry file
 pub fn workspace_registry_path() -> Option<PathBuf> {
@@ -161,7 +159,6 @@ mod tests {
         assert_eq!(result.unwrap(), path);
     }
 
-
     #[test]
     fn test_named_workspace_not_found() {
         let registry = WorkspaceRegistry::default();