pmat 3.16.0

PMAT - Zero-config AI context generation and code quality toolkit (CLI, MCP, HTTP)
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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

#![cfg_attr(coverage_nightly, coverage(off))]
// Toyota Way: C/C++ Strategy Implementation for AST Service Layer
//
// This adapter module implements the services::ast::AstStrategy trait
// for the ast::languages::c_cpp::CStrategy and CppStrategy types.

use anyhow::Result;
use async_trait::async_trait;
use std::path::Path;

// Re-export these types to make them available to consumers of this module
pub use crate::ast::languages::c_cpp::{CStrategy, CppStrategy};
use crate::services::context::FileContext;
use crate::services::file_classifier::FileClassifier;

// Import service-layer AST Strategy trait
use crate::services::ast::AstStrategy;

// Import our own C/C++ analyzers
use super::c;
use super::cpp;

#[async_trait]
impl AstStrategy for CStrategy {
    /// Analyze a C source file and extract AST information
    async fn analyze(&self, file_path: &Path, _classifier: &FileClassifier) -> Result<FileContext> {
        // Use our comprehensive C analyzer
        let file_context = c::analyze_c_file(file_path)
            .await
            .map_err(|e| anyhow::anyhow!("C analysis error: {}", e))?;

        Ok(file_context)
    }

    /// Get the primary file extension this strategy handles
    fn primary_extension(&self) -> &'static str {
        "c"
    }

    /// Get all file extensions this strategy can handle
    fn supported_extensions(&self) -> Vec<&'static str> {
        vec!["c", "h"]
    }

    /// Get the language name
    fn language_name(&self) -> &'static str {
        "C"
    }
}

#[async_trait]
impl AstStrategy for CppStrategy {
    /// Analyze a C++ source file and extract AST information
    async fn analyze(&self, file_path: &Path, _classifier: &FileClassifier) -> Result<FileContext> {
        // Use our comprehensive C++ analyzer
        let file_context = cpp::analyze_cpp_file(file_path)
            .await
            .map_err(|e| anyhow::anyhow!("C++ analysis error: {}", e))?;

        Ok(file_context)
    }

    /// Get the primary file extension this strategy handles
    fn primary_extension(&self) -> &'static str {
        "cpp"
    }

    /// Get all file extensions this strategy can handle
    fn supported_extensions(&self) -> Vec<&'static str> {
        vec!["cpp", "cc", "cxx", "hpp", "hxx", "hh"]
    }

    /// Get the language name
    fn language_name(&self) -> &'static str {
        "C++"
    }
}

#[cfg_attr(coverage_nightly, coverage(off))]
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_c_strategy_supported_extensions() {
        let strategy = CStrategy::new();
        assert_eq!(strategy.primary_extension(), "c");
        assert!(strategy.supported_extensions().contains(&"c"));
        assert!(strategy.supported_extensions().contains(&"h"));
        assert_eq!(strategy.language_name(), "C");
    }

    #[test]
    fn test_cpp_strategy_supported_extensions() {
        let strategy = CppStrategy::new();
        assert_eq!(strategy.primary_extension(), "cpp");
        assert!(strategy.supported_extensions().contains(&"cpp"));
        assert!(strategy.supported_extensions().contains(&"hpp"));
        assert_eq!(strategy.language_name(), "C++");
    }

    #[test]
    fn test_c_strategy_can_handle() {
        let strategy = CStrategy::new();
        assert!(strategy.can_handle("c"));
        assert!(strategy.can_handle("h"));
        assert!(!strategy.can_handle("cpp"));
    }

    #[test]
    fn test_cpp_strategy_can_handle() {
        let strategy = CppStrategy::new();
        assert!(strategy.can_handle("cpp"));
        assert!(strategy.can_handle("hpp"));
        assert!(strategy.can_handle("cxx"));
        assert!(!strategy.can_handle("c"));
    }
}