lmrc_cargo_workspace/

lib.rs

//! # Cargo Workspace Manager
//!
//! A comprehensive library for managing Cargo workspaces programmatically.
//!
//! This library provides a high-level API for:
//! - Discovering and analyzing Cargo workspaces
//! - Detecting workspace members (binaries and libraries)
//! - Analyzing dependency relationships between crates
//! - Building and testing workspace members programmatically (including selective and parallel builds)
//! - Managing versions across workspace members using semver
//! - Parsing and updating Cargo.toml files while preserving formatting
//! - Cargo metadata integration for resolved dependency information
//! - Workspace validation and linting (formatting, clippy, dependencies)
//!
//! ## Quick Start
//!
//! ```no_run
//! use lmrc_cargo_workspace::{
//!     workspace::Workspace,
//!     build::{WorkspaceBuilder, BuildConfig},
//!     version::{VersionManager, BumpType, VersionUpdateStrategy},
//!     dependency::DependencyGraph,
//! };
//! use std::path::Path;
//!
//! # fn main() -> Result<(), Box<dyn std::error::Error>> {
//! // Discover workspace
//! let workspace = Workspace::discover(Path::new("."))?;
//! println!("Found workspace at: {}", workspace.root.display());
//! println!("Members: {}", workspace.members.len());
//!
//! // Analyze dependencies
//! let graph = DependencyGraph::from_workspace(&workspace)?;
//! let build_order = graph.topological_sort()?;
//! println!("Build order: {:?}", build_order);
//!
//! // Build workspace
//! let builder = WorkspaceBuilder::new(&workspace);
//! let result = builder.build_all(&BuildConfig::default())?;
//! if result.success {
//!     println!("Build succeeded!");
//! }
//!
//! // Bump versions
//! let version_mgr = VersionManager::new(&workspace);
//! let changes = version_mgr.preview_changes(
//!     VersionUpdateStrategy::BumpAll(BumpType::Patch)
//! )?;
//! for change in &changes {
//!     println!("{}", change.description());
//! }
//! # Ok(())
//! # }
//! ```
//!
//! ## Features
//!
//! ### Workspace Discovery
//!
//! Automatically find and parse Cargo workspaces:
//!
//! ```no_run
//! use lmrc_cargo_workspace::workspace::Workspace;
//! use std::path::Path;
//!
//! // Discover workspace from current directory
//! let workspace = Workspace::discover(Path::new("."))?;
//!
//! // Or load from specific path
//! let workspace = Workspace::from_path(Path::new("/path/to/workspace"))?;
//!
//! // Access workspace members
//! for member in &workspace.members {
//!     println!("Member: {} at {}", member.name, member.path.display());
//! }
//! # Ok::<(), lmrc_cargo_workspace::error::Error>(())
//! ```
//!
//! ### Dependency Analysis
//!
//! Analyze dependency relationships and build orders:
//!
//! ```no_run
//! use lmrc_cargo_workspace::{workspace::Workspace, dependency::DependencyGraph};
//! use std::path::Path;
//!
//! let workspace = Workspace::discover(Path::new("."))?;
//! let graph = DependencyGraph::from_workspace(&workspace)?;
//!
//! // Get dependencies of a crate
//! let deps = graph.workspace_dependencies("my-crate");
//! for dep in deps {
//!     println!("Depends on: {}", dep.name);
//! }
//!
//! // Get reverse dependencies
//! let dependents = graph.dependents("my-lib");
//! println!("Crates depending on my-lib: {:?}", dependents);
//!
//! // Get build order
//! let order = graph.topological_sort()?;
//! println!("Build in this order: {:?}", order);
//! # Ok::<(), lmrc_cargo_workspace::error::Error>(())
//! ```
//!
//! ### Version Management
//!
//! Manage versions across workspace members:
//!
//! ```no_run
//! use lmrc_cargo_workspace::{
//!     workspace::Workspace,
//!     version::{VersionManager, BumpType, VersionUpdateStrategy},
//! };
//! use std::path::Path;
//! use semver::Version;
//!
//! let workspace = Workspace::discover(Path::new("."))?;
//! let version_mgr = VersionManager::new(&workspace);
//!
//! // Bump all crates by patch version
//! let changes = version_mgr.update_versions(
//!     VersionUpdateStrategy::BumpAll(BumpType::Patch)
//! )?;
//!
//! // Apply changes
//! version_mgr.apply_changes(&changes)?;
//! # Ok::<(), lmrc_cargo_workspace::error::Error>(())
//! ```
//!
//! ### Build and Test
//!
//! Build and test workspace members programmatically:
//!
//! ```no_run
//! use lmrc_cargo_workspace::{
//!     workspace::Workspace,
//!     build::{WorkspaceBuilder, BuildConfig, TestConfig, BuildProfile},
//! };
//! use std::path::Path;
//!
//! let workspace = Workspace::discover(Path::new("."))?;
//! let builder = WorkspaceBuilder::new(&workspace);
//!
//! // Build in release mode
//! let mut config = BuildConfig::default();
//! config.profile = BuildProfile::Release;
//! let result = builder.build_all(&config)?;
//!
//! // Run tests
//! let test_result = builder.test_all(&TestConfig::default())?;
//! # Ok::<(), lmrc_cargo_workspace::error::Error>(())
//! ```
//!
//! ### Manifest Manipulation
//!
//! Parse and update Cargo.toml files while preserving formatting:
//!
//! ```no_run
//! use lmrc_cargo_workspace::manifest::Manifest;
//! use std::path::Path;
//! use semver::Version;
//!
//! let mut manifest = Manifest::from_path(Path::new("Cargo.toml"))?;
//!
//! // Update version
//! manifest.set_package_version(&Version::new(2, 0, 0))?;
//!
//! // Update dependency
//! manifest.update_dependency("serde", "2.0", "dependencies")?;
//!
//! // Save (preserves formatting and comments)
//! manifest.save()?;
//! # Ok::<(), lmrc_cargo_workspace::error::Error>(())
//! ```
//!
//! ## Error Handling
//!
//! All operations return a [`Result<T, Error>`](error::Error) with comprehensive error types:
//!
//! ```no_run
//! use lmrc_cargo_workspace::{workspace::Workspace, error::Error};
//! use std::path::Path;
//!
//! match Workspace::discover(Path::new(".")) {
//!     Ok(workspace) => println!("Found workspace!"),
//!     Err(Error::WorkspaceNotFound(path)) => {
//!         eprintln!("No workspace found at: {}", path.display());
//!     }
//!     Err(e) => eprintln!("Error: {}", e),
//! }
//! ```

pub mod build;
pub mod dependency;
pub mod error;
pub mod manifest;
pub mod metadata;
pub mod selective;
pub mod validation;
pub mod version;
pub mod workspace;

// Re-export commonly used types
pub use error::{Error, Result};

#[cfg(test)]
mod tests {
    #[test]
    fn test_version() {
        // Ensure crate version is valid
        let version = env!("CARGO_PKG_VERSION");
        assert!(!version.is_empty());
    }
}