Skip to main content

weavatrix_rust/language/tokenized/
mod.rs

1//! Lossless language adapters backed by `weavatrix-parse`.
2
3mod convert;
4mod domains;
5mod kinds;
6mod swift;
7#[cfg(test)]
8mod tests;
9
10use super::{FileFacts, Language, LanguageAdapter, SourceFile};
11use crate::model::Result;
12
13/// One language served by the lossless parser.
14pub struct TokenizedAdapter {
15    language: Language,
16    parse: weavatrix_parse::Language,
17    extensions: &'static [&'static str],
18}
19
20impl TokenizedAdapter {
21    /// Every language the lossless parser extracts structure from.
22    pub fn defaults() -> impl Iterator<Item = Self> {
23        use weavatrix_parse::Language as Parsed;
24        [
25            (
26                Language::JavaScript,
27                Parsed::JavaScript,
28                &["js", "jsx", "mjs", "cjs"][..],
29            ),
30            (
31                Language::TypeScript,
32                Parsed::TypeScript,
33                &["ts", "tsx", "mts", "cts"][..],
34            ),
35            // The syn adapter wins with `lang-rust`; this remains the
36            // dependency-light fallback for no-default-feature builds.
37            (Language::Rust, Parsed::Rust, &["rs"][..]),
38            (Language::Python, Parsed::Python, &["py", "pyi"][..]),
39            (Language::Go, Parsed::Go, &["go"][..]),
40            (Language::Java, Parsed::Java, &["java"][..]),
41            (Language::CSharp, Parsed::CSharp, &["cs"][..]),
42            (Language::C, Parsed::C, &["c", "h"][..]),
43            (
44                Language::Cpp,
45                Parsed::Cpp,
46                &["cc", "cpp", "cxx", "hh", "hpp", "hxx"][..],
47            ),
48            (Language::Sql, Parsed::Sql, &["sql", "psql"][..]),
49            (Language::Bash, Parsed::Bash, &["sh", "bash", "zsh"][..]),
50            (Language::Swift, Parsed::Swift, &["swift"][..]),
51            (
52                Language::Custom("solidity".to_owned()),
53                Parsed::Solidity,
54                &["sol"][..],
55            ),
56            (
57                Language::Custom("html".to_owned()),
58                Parsed::Html,
59                &["html", "htm", "xhtml", "vue", "svelte"][..],
60            ),
61            (
62                Language::Custom("css".to_owned()),
63                Parsed::Css,
64                &["css"][..],
65            ),
66            (
67                Language::Custom("css".to_owned()),
68                Parsed::Scss,
69                &["scss", "sass", "less"][..],
70            ),
71            (
72                Language::Custom("terraform".to_owned()),
73                Parsed::Terraform,
74                &["tf", "tfvars", "hcl"][..],
75            ),
76            (
77                Language::Custom("xml".to_owned()),
78                Parsed::Xml,
79                &[
80                    "xml", "xsd", "xsl", "xslt", "csproj", "props", "targets", "plist",
81                ][..],
82            ),
83            (
84                Language::Custom("markdown".to_owned()),
85                Parsed::Markdown,
86                &["md", "markdown", "mdown", "mkd", "mkdn"][..],
87            ),
88            (
89                Language::Custom("markdown".to_owned()),
90                Parsed::Mdx,
91                &["mdx"][..],
92            ),
93            (
94                Language::Custom("rst".to_owned()),
95                Parsed::ReStructuredText,
96                &["rst"][..],
97            ),
98            (
99                Language::Custom("asciidoc".to_owned()),
100                Parsed::AsciiDoc,
101                &["adoc", "asciidoc", "asc"][..],
102            ),
103        ]
104        .into_iter()
105        .map(|(language, parse, extensions)| Self {
106            language,
107            parse,
108            extensions,
109        })
110    }
111}
112
113impl LanguageAdapter for TokenizedAdapter {
114    fn language(&self) -> Language {
115        self.language.clone()
116    }
117
118    fn extensions(&self) -> &'static [&'static str] {
119        self.extensions
120    }
121
122    fn extractor(&self) -> &'static str {
123        "weavatrix.parse.tokens"
124    }
125
126    fn parse(&self, source: SourceFile<'_>) -> Result<FileFacts> {
127        Ok(convert::convert(
128            &weavatrix_parse::extract(source.text, self.parse),
129            source.path,
130        ))
131    }
132}