codanna 0.9.19

Code Intelligence for Large Language Models
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
87
88
89
90
91
92
93

//! Clojure language definition for the registry
//!
//! Provides the Clojure language implementation that self-registers
//! with the global registry.

use std::sync::Arc;

use super::{ClojureBehavior, ClojureParser};
use crate::parsing::{LanguageBehavior, LanguageDefinition, LanguageId, LanguageParser};
use crate::{IndexError, IndexResult, Settings};

/// Clojure language definition
pub struct ClojureLanguage;

impl ClojureLanguage {
    /// Language identifier constant
    pub const ID: LanguageId = LanguageId::new("clojure");
}

impl LanguageDefinition for ClojureLanguage {
    fn id(&self) -> LanguageId {
        Self::ID
    }

    fn name(&self) -> &'static str {
        "Clojure"
    }

    fn extensions(&self) -> &'static [&'static str] {
        &["clj", "cljc", "cljs", "edn"]
    }

    fn create_parser(&self, _settings: &Settings) -> IndexResult<Box<dyn LanguageParser>> {
        let parser = ClojureParser::new().map_err(|e| IndexError::General(e.to_string()))?;
        Ok(Box::new(parser))
    }

    fn create_behavior(&self) -> Box<dyn LanguageBehavior> {
        Box::new(ClojureBehavior::new())
    }

    fn default_enabled(&self) -> bool {
        true // Clojure is enabled by default
    }

    fn is_enabled(&self, settings: &Settings) -> bool {
        settings
            .languages
            .get(self.id().as_str())
            .map(|config| config.enabled)
            .unwrap_or(true) // Clojure is enabled by default
    }
}

/// Register Clojure language with the global registry
pub(crate) fn register(registry: &mut crate::parsing::LanguageRegistry) {
    registry.register(Arc::new(ClojureLanguage));
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::parsing::{LanguageId, get_registry};

    #[test]
    fn test_clojure_definition() {
        let clojure = ClojureLanguage;

        assert_eq!(clojure.id(), LanguageId::new("clojure"));
        assert_eq!(clojure.name(), "Clojure");
        assert!(clojure.extensions().contains(&"clj"));
        assert!(clojure.extensions().contains(&"cljc"));
        assert!(clojure.extensions().contains(&"cljs"));
        assert!(clojure.extensions().contains(&"edn"));
    }

    #[test]
    fn test_clojure_enabled_by_default() {
        let clojure = ClojureLanguage;
        let settings = Settings::default();

        // Clojure is enabled by default
        assert!(clojure.default_enabled());
        assert!(clojure.is_enabled(&settings));
    }

    #[test]
    fn test_clojure_in_registry() {
        let registry = get_registry();
        let registry = registry.lock().unwrap();
        assert!(registry.is_available(LanguageId::new("clojure")));
    }
}