Extract common LSPs stuff into LanguageServer trait (#24)

vitallium · web-flow · commit 9fbf6323c54c · 2024-12-22T13:17:38.000+01:00
Extract common LSPs stuff into `LanguageServer` trait. There is a common
piece of code that is repeated across all LSPs. It can be extracted into
`LanguageServer` trait to make the code a bit more readable, in my
opinion. I also added some basic unit tests.
diff --git a/src/language_servers.rs b/src/language_servers.rs
@@ -1,7 +1,9 @@
+mod language_server;
 mod rubocop;
 mod ruby_lsp;
 mod solargraph;
 
+pub use language_server::LanguageServer;
 pub use rubocop::*;
 pub use ruby_lsp::*;
 pub use solargraph::*;
diff --git a/src/language_servers/language_server.rs b/src/language_servers/language_server.rs
@@ -0,0 +1,92 @@
+use zed_extension_api::{self as zed, settings::LspSettings, LanguageServerId, Result};
+
+#[derive(Clone, Debug)]
+pub struct LanguageServerBinary {
+    pub path: String,
+    pub args: Option<Vec<String>>,
+}
+
+pub trait LanguageServer {
+    const SERVER_ID: &str;
+    const EXECUTABLE_NAME: &str;
+
+    fn default_use_bundler() -> bool {
+        true // Default for most LSPs except Ruby LSP
+    }
+
+    fn get_executable_args() -> Vec<String> {
+        Vec::new()
+    }
+
+    fn language_server_binary(
+        &self,
+        language_server_id: &LanguageServerId,
+        worktree: &zed::Worktree,
+    ) -> Result<LanguageServerBinary> {
+        let lsp_settings = LspSettings::for_worktree(language_server_id.as_ref(), worktree)?;
+
+        if let Some(binary_settings) = lsp_settings.binary {
+            if let Some(path) = binary_settings.path {
+                return Ok(LanguageServerBinary {
+                    path,
+                    args: binary_settings.arguments,
+                });
+            }
+        }
+
+        let use_bundler = lsp_settings
+            .settings
+            .as_ref()
+            .and_then(|settings| settings["use_bundler"].as_bool())
+            .unwrap_or(Self::default_use_bundler());
+
+        if use_bundler {
+            worktree
+                .which("bundle")
+                .map(|path| LanguageServerBinary {
+                    path,
+                    args: Some(
+                        [
+                            vec!["exec".to_string(), Self::EXECUTABLE_NAME.to_string()],
+                            Self::get_executable_args(),
+                        ]
+                        .concat(),
+                    ),
+                })
+                .ok_or_else(|| "Unable to find the 'bundle' command.".into())
+        } else {
+            worktree
+                .which(Self::EXECUTABLE_NAME)
+                .map(|path| LanguageServerBinary {
+                    path,
+                    args: Some(Self::get_executable_args()),
+                })
+                .ok_or_else(|| format!("Unable to find the '{}' command.", Self::EXECUTABLE_NAME))
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    struct TestServer {}
+    impl LanguageServer for TestServer {
+        const SERVER_ID: &'static str = "test-server";
+        const EXECUTABLE_NAME: &'static str = "test-exe";
+
+        fn get_executable_args() -> Vec<String> {
+            vec!["--test-arg".into()]
+        }
+    }
+
+    #[test]
+    fn test_default_use_bundler() {
+        assert!(TestServer::default_use_bundler());
+    }
+
+    #[test]
+    fn test_default_executable_args() {
+        assert!(TestServer::get_executable_args() == vec!["--test-arg"]);
+    }
+}
diff --git a/src/language_servers/rubocop.rs b/src/language_servers/rubocop.rs
@@ -1,17 +1,19 @@
-use zed_extension_api::{self as zed, settings::LspSettings, LanguageServerId, Result};
+use zed_extension_api::{self as zed, LanguageServerId, Result};
 
-#[derive(Clone, Debug)]
-pub struct RubocopBinary {
-    pub path: String,
-    pub args: Option<Vec<String>>,
-}
+use super::LanguageServer;
 
 pub struct Rubocop {}
 
-impl Rubocop {
-    pub const LANGUAGE_SERVER_ID: &str = "rubocop";
-    pub const EXECUTABLE_NAME: &str = "rubocop";
+impl LanguageServer for Rubocop {
+    const SERVER_ID: &str = "rubocop";
+    const EXECUTABLE_NAME: &str = "rubocop";
+
+    fn get_executable_args() -> Vec<String> {
+        vec!["--lsp".to_string()]
+    }
+}
 
+impl Rubocop {
     pub fn new() -> Self {
         Self {}
     }
@@ -25,58 +27,33 @@ impl Rubocop {
 
         Ok(zed::Command {
             command: binary.path,
-            args: binary.args.unwrap_or(vec!["--lsp".into()]),
+            args: binary.args.unwrap_or(Self::get_executable_args()),
             env: Default::default(),
         })
     }
+}
 
-    fn language_server_binary(
-        &self,
-        language_server_id: &LanguageServerId,
-        worktree: &zed::Worktree,
-    ) -> Result<RubocopBinary> {
-        let lsp_settings = LspSettings::for_worktree(language_server_id.as_ref(), worktree)?;
+#[cfg(test)]
+mod tests {
+    use crate::language_servers::{LanguageServer, Rubocop};
 
-        let binary_settings = lsp_settings.binary;
-        let binary_args = binary_settings
-            .as_ref()
-            .and_then(|binary_settings| binary_settings.arguments.clone());
+    #[test]
+    fn test_server_id() {
+        assert_eq!(Rubocop::SERVER_ID, "rubocop");
+    }
 
-        if let Some(path) = binary_settings.and_then(|binary_settings| binary_settings.path) {
-            return Ok(RubocopBinary {
-                path,
-                args: binary_args,
-            });
-        }
+    #[test]
+    fn test_executable_name() {
+        assert_eq!(Rubocop::EXECUTABLE_NAME, "rubocop");
+    }
 
-        let use_bundler = lsp_settings
-            .settings
-            .as_ref()
-            .and_then(|settings| settings["use_bundler"].as_bool())
-            .unwrap_or(true);
+    #[test]
+    fn test_executable_args() {
+        assert_eq!(Rubocop::get_executable_args(), vec!["--lsp"]);
+    }
 
-        if use_bundler {
-            worktree
-                .which("bundle")
-                .map(|path| RubocopBinary {
-                    path,
-                    args: Some(vec![
-                        "exec".into(),
-                        Rubocop::EXECUTABLE_NAME.into(),
-                        "--lsp".into(),
-                    ]),
-                })
-                .ok_or_else(|| "Unable to find the 'bundle' command.".into())
-        } else {
-            worktree
-                .which(Rubocop::EXECUTABLE_NAME)
-                .map(|path| RubocopBinary {
-                    path,
-                    args: Some(vec!["--lsp".into()]),
-                })
-                .ok_or_else(|| {
-                    format!("Unable to find the '{}' command.", Rubocop::EXECUTABLE_NAME)
-                })
-        }
+    #[test]
+    fn test_default_use_bundler() {
+        assert!(Rubocop::default_use_bundler());
     }
 }
diff --git a/src/language_servers/ruby_lsp.rs b/src/language_servers/ruby_lsp.rs
@@ -1,21 +1,23 @@
 use zed_extension_api::{
     self as zed,
     lsp::{Completion, CompletionKind, Symbol, SymbolKind},
-    settings::LspSettings,
     CodeLabel, CodeLabelSpan, LanguageServerId, Result,
 };
 
-pub struct RubyLspBinary {
-    pub path: String,
-    pub args: Option<Vec<String>>,
-}
+use super::LanguageServer;
 
 pub struct RubyLsp {}
 
-impl RubyLsp {
-    pub const LANGUAGE_SERVER_ID: &str = "ruby-lsp";
-    pub const EXECUTABLE_NAME: &str = "ruby-lsp";
+impl LanguageServer for RubyLsp {
+    const SERVER_ID: &str = "ruby-lsp";
+    const EXECUTABLE_NAME: &str = "ruby-lsp";
 
+    fn default_use_bundler() -> bool {
+        false
+    }
+}
+
+impl RubyLsp {
     pub fn new() -> Self {
         Self {}
     }
@@ -29,57 +31,11 @@ impl RubyLsp {
 
         Ok(zed::Command {
             command: binary.path,
-            args: binary.args.unwrap_or(vec![]),
+            args: binary.args.unwrap_or(Self::get_executable_args()),
             env: Default::default(),
         })
     }
 
-    fn language_server_binary(
-        &self,
-        language_server_id: &LanguageServerId,
-        worktree: &zed::Worktree,
-    ) -> Result<RubyLspBinary> {
-        let lsp_settings = LspSettings::for_worktree(language_server_id.as_ref(), worktree)?;
-
-        let binary_settings = lsp_settings.binary;
-        let binary_args = binary_settings
-            .as_ref()
-            .and_then(|binary_settings| binary_settings.arguments.clone());
-
-        if let Some(path) = binary_settings.and_then(|binary_settings| binary_settings.path) {
-            return Ok(RubyLspBinary {
-                path,
-                args: binary_args,
-            });
-        }
-
-        let use_bundler = lsp_settings
-            .settings
-            .as_ref()
-            .and_then(|settings| settings["use_bundler"].as_bool())
-            .unwrap_or(false);
-
-        if use_bundler {
-            worktree
-                .which("bundle")
-                .map(|path| RubyLspBinary {
-                    path,
-                    args: Some(vec!["exec".into(), RubyLsp::EXECUTABLE_NAME.into()]),
-                })
-                .ok_or_else(|| "Unable to find the 'bundle' command.".into())
-        } else {
-            worktree
-                .which(RubyLsp::EXECUTABLE_NAME)
-                .map(|path| RubyLspBinary {
-                    path,
-                    args: Some(vec![]),
-                })
-                .ok_or_else(|| {
-                    format!("Unable to find the '{}' command.", RubyLsp::EXECUTABLE_NAME)
-                })
-        }
-    }
-
     pub fn label_for_completion(&self, completion: Completion) -> Option<CodeLabel> {
         let highlight_name = match completion.kind? {
             CompletionKind::Class | CompletionKind::Module => "type",
@@ -152,3 +108,28 @@ impl RubyLsp {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::language_servers::{LanguageServer, RubyLsp};
+
+    #[test]
+    fn test_server_id() {
+        assert_eq!(RubyLsp::SERVER_ID, "ruby-lsp");
+    }
+
+    #[test]
+    fn test_executable_name() {
+        assert_eq!(RubyLsp::EXECUTABLE_NAME, "ruby-lsp");
+    }
+
+    #[test]
+    fn test_executable_args() {
+        assert_eq!(RubyLsp::get_executable_args(), vec![] as Vec<String>);
+    }
+
+    #[test]
+    fn test_default_use_bundler() {
+        assert!(!RubyLsp::default_use_bundler());
+    }
+}
diff --git a/src/language_servers/solargraph.rs b/src/language_servers/solargraph.rs
diff --git a/src/ruby.rs b/src/ruby.rs
