Enum SingleOrWorkspace

pub enum SingleOrWorkspace {
    Single(CrateHandle),
    Workspace(Workspace<PathBuf, CrateHandle>),
}

An enum representing either a “single crate” handle or an entire workspace. Use SingleOrWorkspace::detect(...) to try loading a workspace, and if it fails specifically with WorkspaceError::ActuallyInSingleCrate {..} we fallback to a single crate handle.

Variants

Single(CrateHandle)

Workspace(Workspace<PathBuf, CrateHandle>)

Implementations

impl SingleOrWorkspace

pub async fn detect(path: &Path) -> Result<Self, WorkspaceError>

Attempt to detect if path is a valid workspace. If so, return SingleOrWorkspace::Workspace. If the error is ActuallyInSingleCrate, fallback to single crate. Otherwise, return the original error.

pub async fn ensure_git_clean(&self) -> Result<(), WorkspaceError>

Check that Git is clean (if you so desire). We do so by calling git status --porcelain and verifying no output. This is the same logic you’d do for either single crate or entire workspace, so there’s no difference inside here.

pub async fn validate_integrity(&mut self) -> Result<(), WorkspaceError>

Validate integrity for either a single crate or a workspace.

pub async fn run_operation<R, F>( &mut self, operation: F, ) -> Result<R, WorkspaceError>

where R: Send + 'static, F: for<'a> FnOnce(&'a mut SingleOrWorkspace) -> Pin<Box<dyn Future<Output = Result<R, WorkspaceError>> + Send + 'a>> + Send + 'static,

A convenience function for hooking into your existing “run_with_crate” or “run_with_workspace” approach. You pass a closure that takes either a &mut CrateHandle or a &mut Workspace, depending on the variant.

For example:

single_or_ws.run_operation(|handle_or_ws| async move {
    match handle_or_ws {
        SingleOrWorkspace::Single(ch) => {
            // do crate-specific code
        },
        SingleOrWorkspace::Workspace(ws) => {
            // do workspace code
        }
    }
    Ok(())
}).await?;