ricecoder_external_lsp/registry/
defaults.rs

1//! Default LSP server configurations for Tier 1 servers
2
3use crate::types::{GlobalLspSettings, LspServerConfig, LspServerRegistry};
4use std::collections::HashMap;
5
6/// Provides default configurations for built-in LSP servers
7pub struct DefaultServerConfigs;
8
9impl DefaultServerConfigs {
10    /// Get default registry with Tier 1 servers pre-configured
11    pub fn tier1_registry() -> LspServerRegistry {
12        LspServerRegistry {
13            servers: HashMap::from([
14                ("rust".to_string(), vec![Self::rust_analyzer()]),
15                ("typescript".to_string(), vec![Self::typescript_language_server()]),
16                ("python".to_string(), vec![Self::pylsp()]),
17            ]),
18            global: GlobalLspSettings::default(),
19        }
20    }
21
22    /// Get default registry with Tier 1 and Tier 2 servers
23    pub fn tier1_and_tier2_registry() -> LspServerRegistry {
24        let mut registry = Self::tier1_registry();
25
26        registry.servers.insert("go".to_string(), vec![Self::gopls()]);
27        registry.servers.insert("java".to_string(), vec![Self::jdtls()]);
28        registry.servers.insert("kotlin".to_string(), vec![Self::kotlin_language_server()]);
29        registry.servers.insert("dart".to_string(), vec![Self::dart_language_server()]);
30
31        registry
32    }
33
34    /// Get default registry with all Tier 1, 2, and 3 servers
35    pub fn all_tiers_registry() -> LspServerRegistry {
36        let mut registry = Self::tier1_and_tier2_registry();
37
38        registry.servers.insert("c".to_string(), vec![Self::clangd()]);
39        registry.servers.insert("cpp".to_string(), vec![Self::clangd()]);
40        registry.servers.insert("csharp".to_string(), vec![Self::omnisharp()]);
41        registry.servers.insert("ruby".to_string(), vec![Self::solargraph()]);
42        registry.servers.insert("php".to_string(), vec![Self::intelephense()]);
43
44        registry
45    }
46
47    // Tier 1 Servers
48
49    /// Rust-analyzer configuration
50    pub fn rust_analyzer() -> LspServerConfig {
51        LspServerConfig {
52            language: "rust".to_string(),
53            extensions: vec![".rs".to_string()],
54            executable: "rust-analyzer".to_string(),
55            args: vec![],
56            env: HashMap::new(),
57            init_options: None,
58            enabled: true,
59            timeout_ms: 10000,
60            max_restarts: 3,
61            idle_timeout_ms: 300000,
62            output_mapping: None,
63        }
64    }
65
66    /// TypeScript Language Server configuration
67    pub fn typescript_language_server() -> LspServerConfig {
68        LspServerConfig {
69            language: "typescript".to_string(),
70            extensions: vec![".ts".to_string(), ".tsx".to_string(), ".js".to_string(), ".jsx".to_string()],
71            executable: "typescript-language-server".to_string(),
72            args: vec!["--stdio".to_string()],
73            env: HashMap::new(),
74            init_options: None,
75            enabled: true,
76            timeout_ms: 5000,
77            max_restarts: 3,
78            idle_timeout_ms: 300000,
79            output_mapping: None,
80        }
81    }
82
83    /// Python Language Server (pylsp) configuration
84    pub fn pylsp() -> LspServerConfig {
85        LspServerConfig {
86            language: "python".to_string(),
87            extensions: vec![".py".to_string()],
88            executable: "pylsp".to_string(),
89            args: vec![],
90            env: HashMap::new(),
91            init_options: None,
92            enabled: true,
93            timeout_ms: 5000,
94            max_restarts: 3,
95            idle_timeout_ms: 300000,
96            output_mapping: None,
97        }
98    }
99
100    // Tier 2 Servers
101
102    /// Go Language Server (gopls) configuration
103    fn gopls() -> LspServerConfig {
104        LspServerConfig {
105            language: "go".to_string(),
106            extensions: vec![".go".to_string()],
107            executable: "gopls".to_string(),
108            args: vec!["serve".to_string()],
109            env: HashMap::new(),
110            init_options: None,
111            enabled: true,
112            timeout_ms: 5000,
113            max_restarts: 3,
114            idle_timeout_ms: 300000,
115            output_mapping: None,
116        }
117    }
118
119    /// Java Development Tools Language Server configuration
120    fn jdtls() -> LspServerConfig {
121        LspServerConfig {
122            language: "java".to_string(),
123            extensions: vec![".java".to_string()],
124            executable: "jdtls".to_string(),
125            args: vec![],
126            env: HashMap::new(),
127            init_options: None,
128            enabled: true,
129            timeout_ms: 10000,
130            max_restarts: 3,
131            idle_timeout_ms: 300000,
132            output_mapping: None,
133        }
134    }
135
136    /// Kotlin Language Server configuration
137    fn kotlin_language_server() -> LspServerConfig {
138        LspServerConfig {
139            language: "kotlin".to_string(),
140            extensions: vec![".kt".to_string(), ".kts".to_string()],
141            executable: "kotlin-language-server".to_string(),
142            args: vec![],
143            env: HashMap::new(),
144            init_options: None,
145            enabled: true,
146            timeout_ms: 10000,
147            max_restarts: 3,
148            idle_timeout_ms: 300000,
149            output_mapping: None,
150        }
151    }
152
153    /// Dart Language Server configuration
154    fn dart_language_server() -> LspServerConfig {
155        LspServerConfig {
156            language: "dart".to_string(),
157            extensions: vec![".dart".to_string()],
158            executable: "dart".to_string(),
159            args: vec!["language-server".to_string()],
160            env: HashMap::new(),
161            init_options: None,
162            enabled: true,
163            timeout_ms: 5000,
164            max_restarts: 3,
165            idle_timeout_ms: 300000,
166            output_mapping: None,
167        }
168    }
169
170    // Tier 3 Servers
171
172    /// Clang Language Server configuration
173    fn clangd() -> LspServerConfig {
174        LspServerConfig {
175            language: "c".to_string(),
176            extensions: vec![".c".to_string(), ".h".to_string()],
177            executable: "clangd".to_string(),
178            args: vec![],
179            env: HashMap::new(),
180            init_options: None,
181            enabled: true,
182            timeout_ms: 10000,
183            max_restarts: 3,
184            idle_timeout_ms: 300000,
185            output_mapping: None,
186        }
187    }
188
189    /// OmniSharp (.NET) Language Server configuration
190    fn omnisharp() -> LspServerConfig {
191        LspServerConfig {
192            language: "csharp".to_string(),
193            extensions: vec![".cs".to_string()],
194            executable: "OmniSharp".to_string(),
195            args: vec!["-lsp".to_string()],
196            env: HashMap::new(),
197            init_options: None,
198            enabled: true,
199            timeout_ms: 10000,
200            max_restarts: 3,
201            idle_timeout_ms: 300000,
202            output_mapping: None,
203        }
204    }
205
206    /// Solargraph (Ruby) Language Server configuration
207    fn solargraph() -> LspServerConfig {
208        LspServerConfig {
209            language: "ruby".to_string(),
210            extensions: vec![".rb".to_string()],
211            executable: "solargraph".to_string(),
212            args: vec!["stdio".to_string()],
213            env: HashMap::new(),
214            init_options: None,
215            enabled: true,
216            timeout_ms: 5000,
217            max_restarts: 3,
218            idle_timeout_ms: 300000,
219            output_mapping: None,
220        }
221    }
222
223    /// Intelephense (PHP) Language Server configuration
224    fn intelephense() -> LspServerConfig {
225        LspServerConfig {
226            language: "php".to_string(),
227            extensions: vec![".php".to_string()],
228            executable: "intelephense".to_string(),
229            args: vec!["--stdio".to_string()],
230            env: HashMap::new(),
231            init_options: None,
232            enabled: true,
233            timeout_ms: 5000,
234            max_restarts: 3,
235            idle_timeout_ms: 300000,
236            output_mapping: None,
237        }
238    }
239}
240
241#[cfg(test)]
242mod tests {
243    use super::*;
244
245    #[test]
246    fn test_tier1_registry() {
247        let registry = DefaultServerConfigs::tier1_registry();
248        assert_eq!(registry.servers.len(), 3);
249        assert!(registry.servers.contains_key("rust"));
250        assert!(registry.servers.contains_key("typescript"));
251        assert!(registry.servers.contains_key("python"));
252    }
253
254    #[test]
255    fn test_tier1_and_tier2_registry() {
256        let registry = DefaultServerConfigs::tier1_and_tier2_registry();
257        assert_eq!(registry.servers.len(), 7);
258        assert!(registry.servers.contains_key("go"));
259        assert!(registry.servers.contains_key("java"));
260        assert!(registry.servers.contains_key("kotlin"));
261        assert!(registry.servers.contains_key("dart"));
262    }
263
264    #[test]
265    fn test_all_tiers_registry() {
266        let registry = DefaultServerConfigs::all_tiers_registry();
267        assert_eq!(registry.servers.len(), 12);
268        assert!(registry.servers.contains_key("c"));
269        assert!(registry.servers.contains_key("cpp"));
270        assert!(registry.servers.contains_key("csharp"));
271        assert!(registry.servers.contains_key("ruby"));
272        assert!(registry.servers.contains_key("php"));
273    }
274
275    #[test]
276    fn test_rust_analyzer_config() {
277        let config = DefaultServerConfigs::rust_analyzer();
278        assert_eq!(config.language, "rust");
279        assert_eq!(config.executable, "rust-analyzer");
280        assert!(config.extensions.contains(&".rs".to_string()));
281        assert_eq!(config.timeout_ms, 10000);
282    }
283
284    #[test]
285    fn test_typescript_config() {
286        let config = DefaultServerConfigs::typescript_language_server();
287        assert_eq!(config.language, "typescript");
288        assert_eq!(config.executable, "typescript-language-server");
289        assert!(config.extensions.contains(&".ts".to_string()));
290        assert!(config.extensions.contains(&".js".to_string()));
291    }
292
293    #[test]
294    fn test_python_config() {
295        let config = DefaultServerConfigs::pylsp();
296        assert_eq!(config.language, "python");
297        assert_eq!(config.executable, "pylsp");
298        assert!(config.extensions.contains(&".py".to_string()));
299    }
300}
ricecoder_external_lsp/registry/defaults.rs

ricecoder_external_lsp/registry/
defaults.rs
