knotra 0.32.0

knotra: multi-project VCS dashboard and bulk-operation tool.
//! Dependency topology screen state.

use knotra_vcs::{DependencyGraph, FreezeValidation, ImpactWarning};

#[derive(Debug, Clone, Default)]
pub enum TopologyPhase {
    #[default]
    Idle,
    Scanning,
    Ready(DependencyGraph),
}

#[derive(Debug, Default)]
pub struct TopologyState {
    pub phase: TopologyPhase,
}

impl TopologyState {
    /// Compute impact warnings for a set of projects about to be frozen.
    pub fn compute_warnings(
        &self,
        graph: &DependencyGraph,
        freezing: &[String],
    ) -> Vec<ImpactWarning> {
        freezing
            .iter()
            .filter_map(|name| {
                let direct = graph.direct_dependents(name);
                if direct.is_empty() {
                    return None;
                }
                let deps: Vec<String> =
                    direct.iter().map(|e| e.from_project_name.clone()).collect();
                Some(ImpactWarning {
                    frozen_project_name: name.clone(),
                    dependent_projects: deps,
                    is_transitive: false,
                })
            })
            .collect()
    }

    /// Impact warnings for the projects a `FreezeValidation` covers, plus
    /// whether topology data exists to check against at all (RFC-044
    /// D1/D3). `false` means "not checked" — distinct from `true` with an
    /// empty `Vec`, which means "checked, found nothing" — the distinction
    /// R3 requires the Freezer to state. Every entry in `validation` is
    /// already part of the freeze selection (RFC-065 D1), so there is no
    /// `included` filter left to apply here.
    pub fn warnings_for(&self, validation: &FreezeValidation) -> (Vec<ImpactWarning>, bool) {
        match &self.phase {
            TopologyPhase::Ready(graph) => {
                let freezing: Vec<String> = validation
                    .entries
                    .iter()
                    .map(|e| e.project_name.clone())
                    .collect();
                (self.compute_warnings(graph, &freezing), true)
            }
            TopologyPhase::Idle | TopologyPhase::Scanning => (Vec::new(), false),
        }
    }
}

// ---------------------------------------------------------------------------
// Tests
// ---------------------------------------------------------------------------

#[cfg(test)]
mod tests {
    use super::*;
    use knotra_vcs::{DependencyEdge, DependencyGraph, ProjectId};

    fn edge(from: &str, to: &str) -> DependencyEdge {
        DependencyEdge {
            from_project_id: ProjectId::new(),
            from_project_name: from.to_owned(),
            to_project_name: to.to_owned(),
            version_req: "^1.0".to_owned(),
            is_path_dep: true,
        }
    }

    #[test]
    fn warnings_generated_for_dependents() {
        let graph = DependencyGraph {
            edges: vec![edge("api", "shared-lib"), edge("worker", "shared-lib")],
        };
        let state = TopologyState::default();
        let warnings = state.compute_warnings(&graph, &["shared-lib".to_owned()]);
        assert_eq!(warnings.len(), 1);
        assert_eq!(warnings[0].dependent_projects.len(), 2);
    }

    #[test]
    fn no_warnings_when_no_dependents() {
        let graph = DependencyGraph {
            edges: vec![edge("api", "external-crate")],
        };
        let state = TopologyState::default();
        let warnings = state.compute_warnings(&graph, &["api".to_owned()]);
        assert!(warnings.is_empty());
    }

    #[test]
    fn warning_description_includes_names() {
        let w = ImpactWarning {
            frozen_project_name: "core".to_owned(),
            dependent_projects: vec!["frontend".to_owned()],
            is_transitive: false,
        };
        assert!(w.description().contains("core"));
        assert!(w.description().contains("frontend"));
    }

    fn validation_entry(name: &str) -> knotra_vcs::FreezeValidationEntry {
        knotra_vcs::FreezeValidationEntry {
            project_id: ProjectId::new(),
            project_name: name.to_owned(),
            notes: Vec::new(),
            blockers: Vec::new(),
        }
    }

    fn validation(entries: Vec<knotra_vcs::FreezeValidationEntry>) -> FreezeValidation {
        FreezeValidation {
            freeze_name: "v1.0.0".to_owned(),
            entries,
        }
    }

    #[test]
    fn warnings_for_reports_not_checked_when_topology_idle() {
        let state = TopologyState::default();
        let v = validation(vec![validation_entry("shared-lib")]);
        let (warnings, checked) = state.warnings_for(&v);
        assert!(!checked);
        assert!(warnings.is_empty());
    }

    #[test]
    fn warnings_for_reports_checked_with_no_dependents() {
        let graph = DependencyGraph {
            edges: vec![edge("api", "external-crate")],
        };
        let state = TopologyState {
            phase: TopologyPhase::Ready(graph),
        };
        let v = validation(vec![validation_entry("api")]);
        let (warnings, checked) = state.warnings_for(&v);
        assert!(checked);
        assert!(warnings.is_empty());
    }

    #[test]
    fn warnings_for_finds_dependents_of_selected_projects() {
        // RFC-065 D1: `validation.entries` only ever holds the freeze
        // selection now — there is no "included" flag left to filter on,
        // so every entry handed in is checked.
        let graph = DependencyGraph {
            edges: vec![edge("api", "shared-lib"), edge("worker", "shared-lib")],
        };
        let state = TopologyState {
            phase: TopologyPhase::Ready(graph),
        };
        let v = validation(vec![validation_entry("shared-lib")]);
        let (warnings, checked) = state.warnings_for(&v);
        assert!(checked);
        assert_eq!(warnings.len(), 1);
        assert_eq!(warnings[0].dependent_projects.len(), 2);
    }
}