infiniloom_engine/parser/
init.rs

1//! Language-specific parser initializers
2//!
3//! This module contains functions to initialize tree-sitter parsers for each
4//! supported programming language.
5
6use super::core::ParserError;
7use tree_sitter::Parser as TSParser;
8
9/// Initialize Python parser
10pub fn python() -> Result<TSParser, ParserError> {
11    let mut parser = TSParser::new();
12    parser
13        .set_language(&tree_sitter_python::LANGUAGE.into())
14        .map_err(|e| ParserError::ParseError(e.to_string()))?;
15    Ok(parser)
16}
17
18/// Initialize JavaScript parser
19pub fn javascript() -> Result<TSParser, ParserError> {
20    let mut parser = TSParser::new();
21    parser
22        .set_language(&tree_sitter_javascript::LANGUAGE.into())
23        .map_err(|e| ParserError::ParseError(e.to_string()))?;
24    Ok(parser)
25}
26
27/// Initialize TypeScript parser
28pub fn typescript() -> Result<TSParser, ParserError> {
29    let mut parser = TSParser::new();
30    parser
31        .set_language(&tree_sitter_typescript::LANGUAGE_TYPESCRIPT.into())
32        .map_err(|e| ParserError::ParseError(e.to_string()))?;
33    Ok(parser)
34}
35
36/// Initialize Rust parser
37pub fn rust() -> Result<TSParser, ParserError> {
38    let mut parser = TSParser::new();
39    parser
40        .set_language(&tree_sitter_rust::LANGUAGE.into())
41        .map_err(|e| ParserError::ParseError(e.to_string()))?;
42    Ok(parser)
43}
44
45/// Initialize Go parser
46pub fn go() -> Result<TSParser, ParserError> {
47    let mut parser = TSParser::new();
48    parser
49        .set_language(&tree_sitter_go::LANGUAGE.into())
50        .map_err(|e| ParserError::ParseError(e.to_string()))?;
51    Ok(parser)
52}
53
54/// Initialize Java parser
55pub fn java() -> Result<TSParser, ParserError> {
56    let mut parser = TSParser::new();
57    parser
58        .set_language(&tree_sitter_java::LANGUAGE.into())
59        .map_err(|e| ParserError::ParseError(e.to_string()))?;
60    Ok(parser)
61}
62
63/// Initialize C parser
64pub fn c() -> Result<TSParser, ParserError> {
65    let mut parser = TSParser::new();
66    parser
67        .set_language(&tree_sitter_c::LANGUAGE.into())
68        .map_err(|e| ParserError::ParseError(e.to_string()))?;
69    Ok(parser)
70}
71
72/// Initialize C++ parser
73pub fn cpp() -> Result<TSParser, ParserError> {
74    let mut parser = TSParser::new();
75    parser
76        .set_language(&tree_sitter_cpp::LANGUAGE.into())
77        .map_err(|e| ParserError::ParseError(e.to_string()))?;
78    Ok(parser)
79}
80
81/// Initialize C# parser
82pub fn csharp() -> Result<TSParser, ParserError> {
83    let mut parser = TSParser::new();
84    parser
85        .set_language(&tree_sitter_c_sharp::LANGUAGE.into())
86        .map_err(|e| ParserError::ParseError(e.to_string()))?;
87    Ok(parser)
88}
89
90/// Initialize Ruby parser
91pub fn ruby() -> Result<TSParser, ParserError> {
92    let mut parser = TSParser::new();
93    parser
94        .set_language(&tree_sitter_ruby::LANGUAGE.into())
95        .map_err(|e| ParserError::ParseError(e.to_string()))?;
96    Ok(parser)
97}
98
99/// Initialize Bash parser
100pub fn bash() -> Result<TSParser, ParserError> {
101    let mut parser = TSParser::new();
102    parser
103        .set_language(&tree_sitter_bash::LANGUAGE.into())
104        .map_err(|e| ParserError::ParseError(e.to_string()))?;
105    Ok(parser)
106}
107
108/// Initialize PHP parser
109pub fn php() -> Result<TSParser, ParserError> {
110    let mut parser = TSParser::new();
111    parser
112        .set_language(&tree_sitter_php::LANGUAGE_PHP.into())
113        .map_err(|e| ParserError::ParseError(e.to_string()))?;
114    Ok(parser)
115}
116
117/// Initialize Kotlin parser
118pub fn kotlin() -> Result<TSParser, ParserError> {
119    let mut parser = TSParser::new();
120    parser
121        .set_language(&tree_sitter_kotlin_ng::LANGUAGE.into())
122        .map_err(|e| ParserError::ParseError(e.to_string()))?;
123    Ok(parser)
124}
125
126/// Initialize Swift parser
127pub fn swift() -> Result<TSParser, ParserError> {
128    let mut parser = TSParser::new();
129    parser
130        .set_language(&tree_sitter_swift::LANGUAGE.into())
131        .map_err(|e| ParserError::ParseError(e.to_string()))?;
132    Ok(parser)
133}
134
135/// Initialize Scala parser
136pub fn scala() -> Result<TSParser, ParserError> {
137    let mut parser = TSParser::new();
138    parser
139        .set_language(&tree_sitter_scala::LANGUAGE.into())
140        .map_err(|e| ParserError::ParseError(e.to_string()))?;
141    Ok(parser)
142}
143
144/// Initialize Haskell parser
145pub fn haskell() -> Result<TSParser, ParserError> {
146    let mut parser = TSParser::new();
147    parser
148        .set_language(&tree_sitter_haskell::LANGUAGE.into())
149        .map_err(|e| ParserError::ParseError(e.to_string()))?;
150    Ok(parser)
151}
152
153/// Initialize Elixir parser
154pub fn elixir() -> Result<TSParser, ParserError> {
155    let mut parser = TSParser::new();
156    parser
157        .set_language(&tree_sitter_elixir::LANGUAGE.into())
158        .map_err(|e| ParserError::ParseError(e.to_string()))?;
159    Ok(parser)
160}
161
162/// Initialize Clojure parser
163pub fn clojure() -> Result<TSParser, ParserError> {
164    let mut parser = TSParser::new();
165    parser
166        .set_language(&tree_sitter_clojure::LANGUAGE.into())
167        .map_err(|e| ParserError::ParseError(e.to_string()))?;
168    Ok(parser)
169}
170
171/// Initialize OCaml parser
172pub fn ocaml() -> Result<TSParser, ParserError> {
173    let mut parser = TSParser::new();
174    parser
175        .set_language(&tree_sitter_ocaml::LANGUAGE_OCAML.into())
176        .map_err(|e| ParserError::ParseError(e.to_string()))?;
177    Ok(parser)
178}
179
180/// Initialize Lua parser
181pub fn lua() -> Result<TSParser, ParserError> {
182    let mut parser = TSParser::new();
183    parser
184        .set_language(&tree_sitter_lua::LANGUAGE.into())
185        .map_err(|e| ParserError::ParseError(e.to_string()))?;
186    Ok(parser)
187}
188
189/// Initialize R parser
190pub fn r() -> Result<TSParser, ParserError> {
191    let mut parser = TSParser::new();
192    parser
193        .set_language(&tree_sitter_r::LANGUAGE.into())
194        .map_err(|e| ParserError::ParseError(e.to_string()))?;
195    Ok(parser)
196}
197
198#[cfg(test)]
199mod tests {
200    use super::*;
201
202    #[test]
203    fn test_python_init() {
204        assert!(python().is_ok());
205    }
206
207    #[test]
208    fn test_javascript_init() {
209        assert!(javascript().is_ok());
210    }
211
212    #[test]
213    fn test_typescript_init() {
214        assert!(typescript().is_ok());
215    }
216
217    #[test]
218    fn test_rust_init() {
219        assert!(rust().is_ok());
220    }
221
222    #[test]
223    fn test_go_init() {
224        assert!(go().is_ok());
225    }
226
227    #[test]
228    fn test_java_init() {
229        assert!(java().is_ok());
230    }
231
232    #[test]
233    fn test_c_init() {
234        assert!(c().is_ok());
235    }
236
237    #[test]
238    fn test_cpp_init() {
239        assert!(cpp().is_ok());
240    }
241
242    #[test]
243    fn test_csharp_init() {
244        assert!(csharp().is_ok());
245    }
246
247    #[test]
248    fn test_ruby_init() {
249        assert!(ruby().is_ok());
250    }
251
252    #[test]
253    fn test_bash_init() {
254        assert!(bash().is_ok());
255    }
256
257    #[test]
258    fn test_php_init() {
259        assert!(php().is_ok());
260    }
261
262    #[test]
263    fn test_kotlin_init() {
264        assert!(kotlin().is_ok());
265    }
266
267    #[test]
268    fn test_swift_init() {
269        assert!(swift().is_ok());
270    }
271
272    #[test]
273    fn test_scala_init() {
274        assert!(scala().is_ok());
275    }
276
277    #[test]
278    fn test_haskell_init() {
279        assert!(haskell().is_ok());
280    }
281
282    #[test]
283    fn test_elixir_init() {
284        assert!(elixir().is_ok());
285    }
286
287    #[test]
288    fn test_clojure_init() {
289        assert!(clojure().is_ok());
290    }
291
292    #[test]
293    fn test_ocaml_init() {
294        assert!(ocaml().is_ok());
295    }
296
297    #[test]
298    fn test_lua_init() {
299        assert!(lua().is_ok());
300    }
301
302    #[test]
303    fn test_r_init() {
304        assert!(r().is_ok());
305    }
306}
infiniloom_engine/parser/init.rs

infiniloom_engine/parser/
init.rs
