archmap 1.0.2

Static architectural analysis of codebases.
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
75
76
77
78
79
80
81
82
83
84
85
86

mod common;
mod python;
mod rust;
mod typescript;

use crate::model::Module;
use std::path::Path;
use thiserror::Error;

pub use common::{extract_full_definition, extract_signature_to_brace};
pub use python::PythonParser;
pub use rust::RustParser;
pub use typescript::TypeScriptParser;

#[derive(Debug, Error)]
pub enum ParseError {
    #[error("Failed to read file: {0}")]
    Io(#[from] std::io::Error),
    #[error("Failed to parse: {0}")]
    Parse(String),
    #[error("Unsupported language for file: {0}")]
    UnsupportedLanguage(String),
}

pub trait LanguageParser: Send + Sync {
    fn extensions(&self) -> &[&str];
    fn parse_module(&self, path: &Path, source: &str) -> Result<Module, ParseError>;
}

pub struct ParserRegistry {
    parsers: Vec<Box<dyn LanguageParser>>,
}

impl ParserRegistry {
    pub fn new() -> Self {
        Self {
            parsers: vec![
                Box::new(RustParser::new()),
                Box::new(TypeScriptParser::new()),
                Box::new(PythonParser::new()),
            ],
        }
    }

    pub fn with_languages(languages: &[String]) -> Self {
        let mut parsers: Vec<Box<dyn LanguageParser>> = Vec::new();

        for lang in languages {
            match lang.to_lowercase().as_str() {
                "rust" | "rs" => parsers.push(Box::new(RustParser::new())),
                "typescript" | "ts" | "javascript" | "js" => {
                    parsers.push(Box::new(TypeScriptParser::new()))
                }
                "python" | "py" => parsers.push(Box::new(PythonParser::new())),
                _ => {}
            }
        }

        if parsers.is_empty() {
            return Self::new();
        }

        Self { parsers }
    }

    pub fn find_parser(&self, path: &Path) -> Option<&dyn LanguageParser> {
        let ext = path.extension()?.to_str()?;
        self.parsers
            .iter()
            .find(|p| p.extensions().contains(&ext))
            .map(|p| p.as_ref())
    }

    pub fn supported_extensions(&self) -> Vec<&str> {
        self.parsers
            .iter()
            .flat_map(|p| p.extensions().iter().copied())
            .collect()
    }
}

impl Default for ParserRegistry {
    fn default() -> Self {
        Self::new()
    }
}