rustuse-cli 0.2.0-beta.1

Command-line tooling for adopting, managing, and maintaining RustUse crates.
Documentation
use std::path::{Path, PathBuf};

use anyhow::Result;

use crate::rustuse::facade::manifest::FacadeManifestReport;
use crate::rustuse::fleet::discover::{
    FleetFacadeEntry, FleetRepoEntry, discover_facades, discover_fleet_repos, resolve_existing_path,
};
use crate::rustuse::fleet::inspect::{RootSummary, display_name, inspect_root};
use crate::rustuse::fleet::manifest::analyze_fleet_manifests;

#[derive(Debug)]
pub(crate) struct FleetDiagnostics {
    pub(crate) fleet: PathBuf,
    pub(crate) name: String,
    root_summary: RootSummary,
    pub(crate) repos: Vec<FleetRepoEntry>,
    pub(crate) facades: Vec<FleetFacadeEntry>,
    pub(crate) manifests: Vec<FacadeManifestReport>,
}

impl FleetDiagnostics {
    pub(crate) fn inspect(path: &Path) -> Result<Self> {
        let fleet = resolve_existing_path(path);
        let name = display_name(&fleet).to_owned();
        let root_summary = inspect_root(&fleet)?;
        let repos = discover_fleet_repos(&fleet);
        let facades = discover_facades(&fleet)?;
        let manifests = analyze_fleet_manifests(&fleet, &facades)?;

        Ok(Self {
            fleet,
            name,
            root_summary,
            repos,
            facades,
            manifests,
        })
    }

    pub(crate) fn status(&self) -> &'static str {
        if self.manifest_error_count() > 0 {
            "error"
        } else if self.has_warning() {
            "warning"
        } else {
            "ok"
        }
    }

    pub(crate) fn facade_count(&self) -> usize {
        self.root_summary.use_dir_count
    }

    pub(crate) fn facade_git_count(&self) -> usize {
        self.root_summary.facade_git_count
    }

    pub(crate) fn missing_facade_git_count(&self) -> usize {
        self.root_summary.missing_git.len()
    }

    pub(crate) fn has_cli(&self) -> bool {
        self.root_summary.has_cli
    }

    pub(crate) fn has_docs(&self) -> bool {
        self.root_summary.has_docs
    }

    pub(crate) fn missing_facade_git_names(&self) -> impl Iterator<Item = &str> {
        self.root_summary
            .missing_git
            .iter()
            .map(|path| display_name(path))
    }

    pub(crate) fn child_crate_count(&self) -> usize {
        self.facades
            .iter()
            .map(|facade| facade.child_crate_count)
            .sum()
    }

    pub(crate) fn missing_fleet_repo_count(&self) -> usize {
        self.repos.iter().filter(|repo| !repo.present).count()
    }

    pub(crate) fn manifest_count(&self) -> usize {
        self.manifests
            .iter()
            .map(FacadeManifestReport::manifest_count)
            .sum()
    }

    pub(crate) fn manifest_issue_count(&self) -> usize {
        self.manifests
            .iter()
            .map(FacadeManifestReport::issue_count)
            .sum()
    }

    pub(crate) fn manifest_error_count(&self) -> usize {
        self.manifests
            .iter()
            .map(FacadeManifestReport::error_count)
            .sum()
    }

    pub(crate) fn manifest_warning_count(&self) -> usize {
        self.manifests
            .iter()
            .map(FacadeManifestReport::warning_count)
            .sum()
    }

    pub(crate) fn invalid_category_count(&self) -> usize {
        self.manifests
            .iter()
            .map(FacadeManifestReport::invalid_category_count)
            .sum()
    }

    fn has_warning(&self) -> bool {
        !self.has_cli()
            || !self.has_docs()
            || self.missing_fleet_repo_count() > 0
            || self.facade_count() == 0
            || self.missing_facade_git_count() > 0
            || self.manifest_warning_count() > 0
    }
}