nargo_workspace/

lib.rs

//! Workspace management for Nargo package manager.
//!
//! This crate provides workspace discovery, member management, and
//! task orchestration for multi-package projects.

#![warn(missing_docs)]

use nargo_types::{Error, Result, Span};
use serde::{Deserialize, Serialize};
use std::{
    collections::{HashMap, HashSet},
    fs,
    path::{Path, PathBuf},
};
use tracing::{debug, info, warn};

/// Represents a workspace member package.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WorkspaceMember {
    /// Member package name.
    pub name: String,
    /// Path to the member package.
    pub path: PathBuf,
    /// Member package version.
    pub version: String,
    /// Whether this is the root package.
    pub is_root: bool,
    /// Dependencies of this member.
    pub dependencies: Vec<String>,
    /// Dev dependencies of this member.
    pub dev_dependencies: Vec<String>,
}

impl WorkspaceMember {
    /// Creates a new workspace member.
    pub fn new(name: impl Into<String>, path: impl Into<PathBuf>) -> Self {
        Self { name: name.into(), path: path.into(), version: "0.0.0".to_string(), is_root: false, dependencies: Vec::new(), dev_dependencies: Vec::new() }
    }

    /// Sets the version.
    pub fn with_version(mut self, version: impl Into<String>) -> Self {
        self.version = version.into();
        self
    }

    /// Marks as root package.
    pub fn as_root(mut self) -> Self {
        self.is_root = true;
        self
    }

    /// Adds a dependency.
    pub fn add_dependency(&mut self, dep: impl Into<String>) {
        self.dependencies.push(dep.into());
    }

    /// Adds a dev dependency.
    pub fn add_dev_dependency(&mut self, dep: impl Into<String>) {
        self.dev_dependencies.push(dep.into());
    }
}

/// Workspace configuration and state.
#[derive(Debug, Clone)]
pub struct Workspace {
    /// Root directory of the workspace.
    pub root: PathBuf,
    /// All member packages.
    pub members: HashMap<String, WorkspaceMember>,
    /// Member discovery order (for builds).
    pub member_order: Vec<String>,
    /// Shared workspace configuration.
    pub shared_config: Option<SharedConfig>,
}

/// Shared configuration inherited by all members.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SharedConfig {
    /// Shared version.
    pub version: Option<String>,
    /// Shared authors.
    pub authors: Vec<String>,
    /// Shared license.
    pub license: Option<String>,
    /// Shared repository.
    pub repository: Option<String>,
    /// Shared dependencies.
    pub dependencies: HashMap<String, String>,
    /// Shared dev dependencies.
    pub dev_dependencies: HashMap<String, String>,
}

impl Default for Workspace {
    fn default() -> Self {
        Self { root: PathBuf::from("."), members: HashMap::new(), member_order: Vec::new(), shared_config: None }
    }
}

impl Workspace {
    /// Creates a new empty workspace.
    pub fn new(root: impl Into<PathBuf>) -> Self {
        Self { root: root.into(), ..Default::default() }
    }

    /// Discovers workspace from a root directory.
    pub fn discover(root: &Path) -> Result<Self> {
        let nargo_toml = root.join("Nargo.toml");

        if !nargo_toml.exists() {
            return Err(Error::external_error("workspace".to_string(), format!("No Nargo.toml found in {:?}", root), Span::unknown()));
        }

        // 简化实现，实际需要根据 nargo_config 的 API 进行调整
        let mut workspace = Self::new(root);

        // 添加一个默认成员
        let member = WorkspaceMember::new("default", root.to_path_buf()).with_version("0.0.0").as_root();

        workspace.members.insert(member.name.clone(), member.clone());
        workspace.member_order.push(member.name);

        info!("Discovered workspace with {} members", workspace.members.len());
        Ok(workspace)
    }

    /// Discovers workspace or returns a single-package workspace.
    pub fn discover_or_single(root: &Path) -> Result<Self> {
        Self::discover(root).or_else(|_| {
            let nargo_toml = root.join("Nargo.toml");
            if nargo_toml.exists() {
                // 简化实现，实际需要根据 nargo_config 的 API 进行调整
                let member = WorkspaceMember::new("default", root.to_path_buf()).with_version("0.0.0").as_root();

                let mut workspace = Self::new(root);
                workspace.members.insert(member.name.clone(), member.clone());
                workspace.member_order.push(member.name);

                Ok(workspace)
            }
            else {
                Err(Error::external_error("workspace".to_string(), format!("No Nargo.toml found in {:?}", root), Span::unknown()))
            }
        })
    }

    fn discover_members(&mut self, root: &Path, pattern: &str) -> Result<()> {
        if pattern.ends_with("/*") {
            let base = root.join(pattern.trim_end_matches("/*"));
            if base.is_dir() {
                for entry in fs::read_dir(&base)? {
                    let entry = entry?;
                    let path = entry.path();
                    if path.is_dir() && path.join("Nargo.toml").exists() {
                        self.add_member_from_path(&path)?;
                    }
                }
            }
        }
        else {
            let path = root.join(pattern);
            if path.is_dir() && path.join("Nargo.toml").exists() {
                self.add_member_from_path(&path)?;
            }
        }
        Ok(())
    }

    fn add_member_from_path(&mut self, path: &Path) -> Result<()> {
        let nargo_toml = path.join("Nargo.toml");
        let _content = fs::read_to_string(&nargo_toml).map_err(|e| Error::external_error("workspace".to_string(), format!("Failed to read {:?}: {}", nargo_toml, e), Span::unknown()))?;

        // 简化实现，实际需要根据 nargo_config 的 API 进行调整
        let name = path.file_name().unwrap_or_default().to_string_lossy().to_string();
        let member = WorkspaceMember::new(&name, path).with_version("0.0.0");

        self.members.insert(name.clone(), member);
        Ok(())
    }

    fn compute_dependency_order(&mut self) -> Result<()> {
        let mut order = Vec::new();
        let mut visited = HashSet::new();
        let mut temp_marks = HashSet::new();

        fn visit(name: &str, members: &HashMap<String, WorkspaceMember>, visited: &mut HashSet<String>, temp_marks: &mut HashSet<String>, order: &mut Vec<String>) -> Result<()> {
            if visited.contains(name) {
                return Ok(());
            }
            if temp_marks.contains(name) {
                return Err(Error::external_error("workspace".to_string(), format!("Circular dependency detected involving {}", name), Span::unknown()));
            }

            temp_marks.insert(name.to_string());

            if let Some(member) = members.get(name) {
                for dep in &member.dependencies {
                    if members.contains_key(dep) {
                        visit(dep, members, visited, temp_marks, order)?;
                    }
                }
            }

            temp_marks.remove(name);
            visited.insert(name.to_string());
            order.push(name.to_string());

            Ok(())
        }

        for name in self.members.keys() {
            visit(name, &self.members, &mut visited, &mut temp_marks, &mut order)?;
        }

        self.member_order = order;
        Ok(())
    }

    /// Gets a member by name.
    pub fn get_member(&self, name: &str) -> Option<&WorkspaceMember> {
        self.members.get(name)
    }

    /// Gets a member by path.
    pub fn get_member_by_path(&self, path: &Path) -> Option<&WorkspaceMember> {
        self.members.values().find(|m| m.path == path)
    }

    /// Returns all member names in dependency order.
    pub fn member_names(&self) -> &[String] {
        &self.member_order
    }

    /// Returns the number of members.
    pub fn len(&self) -> usize {
        self.members.len()
    }

    /// Checks if the workspace is empty.
    pub fn is_empty(&self) -> bool {
        self.members.is_empty()
    }

    /// Checks if this is a single-package workspace.
    pub fn is_single(&self) -> bool {
        self.members.len() == 1
    }

    /// Returns the root member if this is a single-package workspace.
    pub fn root_member(&self) -> Option<&WorkspaceMember> {
        self.members.values().find(|m| m.is_root)
    }

    /// Lists all members.
    pub fn list_members(&self) {
        println!("Workspace members:");
        for name in &self.member_order {
            if let Some(member) = self.members.get(name) {
                let rel_path = member.path.strip_prefix(&self.root).unwrap_or(&member.path);
                println!("  {} @ {} ({})", name, member.version, rel_path.display());
            }
        }
    }

    /// Returns members that depend on a given package.
    pub fn dependents_of(&self, package_name: &str) -> Vec<&WorkspaceMember> {
        self.members.values().filter(|m| m.dependencies.contains(&package_name.to_string())).collect()
    }

    /// Returns members that a given package depends on.
    pub fn dependencies_of(&self, package_name: &str) -> Vec<&WorkspaceMember> {
        if let Some(member) = self.members.get(package_name) {
            member.dependencies.iter().filter_map(|dep| self.members.get(dep)).collect()
        }
        else {
            Vec::new()
        }
    }

    /// Filters members by a predicate.
    pub fn filter_members<F>(&self, predicate: F) -> Vec<&WorkspaceMember>
    where
        F: Fn(&WorkspaceMember) -> bool,
    {
        self.member_order
            .iter()
            .filter_map(|name| {
                let member = self.members.get(name)?;
                if predicate(member) {
                    Some(member)
                }
                else {
                    None
                }
            })
            .collect()
    }

    /// Returns the workspace root path.
    pub fn root(&self) -> &Path {
        &self.root
    }

    /// Returns the target directory for the workspace.
    pub fn target_dir(&self) -> PathBuf {
        self.root.join("target")
    }

    /// Returns the shared configuration.
    pub fn shared_config(&self) -> Option<&SharedConfig> {
        self.shared_config.as_ref()
    }
}