mago-guard 1.2.2

A PHP dependencies guard that helps keep your architecture clean.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

use mago_codex::metadata::CodebaseMetadata;
use mago_names::ResolvedNames;
use mago_span::HasPosition;

use crate::report::FortressReport;
use crate::report::breach::BoundaryBreach;
use crate::report::flaw::StructuralFlaw;
use crate::settings::Settings;

/// Context for guard operations, providing access to resolved names and issue collection.
#[derive(Debug)]
pub struct GuardContext<'ctx, 'arena> {
    pub resolved_names: &'ctx ResolvedNames<'arena>,
    pub settings: &'ctx Settings,
    pub codebase: &'ctx CodebaseMetadata,
    pub boundary_breaches: Vec<BoundaryBreach>,
    pub structural_flaws: Vec<StructuralFlaw>,
    pub current_namespace: Option<&'arena str>,
}

impl<'ctx, 'arena> GuardContext<'ctx, 'arena> {
    #[allow(clippy::too_many_arguments)]
    pub fn new(
        resolved_names: &'ctx ResolvedNames<'arena>,
        settings: &'ctx Settings,
        codebase: &'ctx CodebaseMetadata,
    ) -> Self {
        Self {
            resolved_names,
            settings,
            codebase,
            boundary_breaches: vec![],
            structural_flaws: vec![],
            current_namespace: None,
        }
    }

    /// Sets the current namespace in the context.
    pub fn set_current_namespace(&mut self, namespace: Option<&'arena str>) {
        self.current_namespace = namespace;
    }

    /// Gets the current namespace from the context, or an empty string if none is set.
    pub fn get_current_namespace(&self) -> &'arena str {
        self.current_namespace.unwrap_or("")
    }

    /// Retrieves the fully qualified name associated with a given position in the code.
    ///
    /// # Panics
    ///
    /// Panics if no name is found at the specified position.
    pub fn lookup_name(&self, position: &impl HasPosition) -> &'arena str {
        self.resolved_names.get(&position.position())
    }

    /// Attempts to retrieve the fully qualified name associated with a given position.
    ///
    /// Returns `None` if no name is found at the specified position.
    pub fn try_lookup_name(&self, position: &impl HasPosition) -> Option<&'arena str> {
        let pos = position.position();
        if self.resolved_names.contains(&pos) { Some(self.resolved_names.get(&pos)) } else { None }
    }

    /// Consumes the context and generates a `FortressReport` containing all collected issues.
    pub fn report(self) -> FortressReport {
        FortressReport {
            boundary_breaches: self.boundary_breaches,
            structural_flaws: self.structural_flaws,
            missing_perimeter_configuration: false,
            missing_structural_configuration: false,
        }
    }
}