feat: general improvements and better hook snippets

Author: jdrupal-dev

Cargo.lock

@@ -12,6 +12,7 @@ log = "0.4.22"
 lsp-server = "0.7.7"
 lsp-types = "0.97.0"
 rayon = "1.10.0"
+regex = "1.11.1"
 serde = { version = "1.0.214", features = ["derive"] }
 serde_json = "1.0.132"
 structured-logger = "1.0.3"

Cargo.toml

@@ -30,8 +30,13 @@ pub fn initialize_document_store(root_dir: String) {
     override_builder.add("**/*.routing.yml").unwrap();
     override_builder.add("**/src/**/*.php").unwrap();
     override_builder.add("**/core/lib/**/*.php").unwrap();
+    // For now we don't care about interfaces at all.
+    override_builder.add("!**/src/**/*Interface.php").unwrap();
+    override_builder.add("!**/core/lib/**/*Interface.php").unwrap();
+    override_builder.add("!**/Plugin/**/*.php").unwrap();
     override_builder.add("!vendor").unwrap();
     override_builder.add("!node_modules").unwrap();
+    override_builder.add("!libraries").unwrap();
     builder.overrides(override_builder.build().unwrap());
 
     // Find all of the documents that we are interested in parsing by walking the file tree using a

src/document_store/mod.rs

@@ -34,8 +34,19 @@ impl PhpParser {
 
     pub fn get_token_at_position(&self, position: Position) -> Option<Token> {
         let tree = self.get_tree()?;
-        let node = self.get_node_at_position(&tree, position)?;
-        self.parse_node(node, Some(self.position_to_point(position)))
+        let mut node = self.get_node_at_position(&tree, position)?;
+        let point = self.position_to_point(position);
+
+        // Return the first "parseable" token in the parent chain.
+        let mut parsed_node: Option<Token>;
+        loop {
+            parsed_node = self.parse_node(node, Some(point));
+            if parsed_node.is_some() {
+                break;
+            }
+            node = node.parent()?;
+        }
+        parsed_node
     }
 
     fn get_node_at_position<'a>(&self, tree: &'a Tree, position: Position) -> Option<Node<'a>> {
@@ -61,8 +72,11 @@ impl PhpParser {
                 match self.parse_node(node, None) {
                     Some(token) => tokens.push(token),
                     None => {
-                        let mut cursor = node.walk();
-                        new_nodes.append(&mut node.children(&mut cursor).collect::<Vec<Node>>());
+                        if node.child_count() > 0 {
+                            let mut cursor = node.walk();
+                            new_nodes
+                                .append(&mut node.children(&mut cursor).collect::<Vec<Node>>());
+                        }
                     }
                 };
             }
@@ -80,7 +94,7 @@ impl PhpParser {
             }
             "function_definition" => self.parse_function_definition(node),
             "comment" => self.parse_comment(node),
-            _ => self.parse_node(node.parent()?, point),
+            _ => None,
         }
     }
 

src/parser/php.rs

@@ -4,7 +4,7 @@ use std::{usize, vec};
 use tree_sitter::{Node, Parser, Point, Tree};
 
 use super::tokens::{
-    DrupalRoute, DrupalRouteDefaults, DrupalService, PhpClassName, PhpMethod, Token, TokenData
+    DrupalRoute, DrupalRouteDefaults, DrupalService, PhpClassName, PhpMethod, Token, TokenData,
 };
 
 pub struct YamlParser {
@@ -31,8 +31,19 @@ impl YamlParser {
 
     pub fn get_token_at_position<'a>(&self, position: Position) -> Option<Token> {
         let tree = self.get_tree()?;
-        let node = self.get_node_at_position(&tree, position)?;
-        self.parse_node(node, Some(self.position_to_point(position)))
+        let mut node = self.get_node_at_position(&tree, position)?;
+        let point = self.position_to_point(position);
+
+        // Return the first "parseable" token in the parent chain.
+        let mut parsed_node: Option<Token>;
+        loop {
+            parsed_node = self.parse_node(node, Some(point));
+            if parsed_node.is_some() {
+                break;
+            }
+            node = node.parent()?;
+        }
+        parsed_node
     }
 
     fn get_node_at_position<'a>(&self, tree: &'a Tree, position: Position) -> Option<Node<'a>> {
@@ -58,8 +69,11 @@ impl YamlParser {
                 match self.parse_node(node, None) {
                     Some(token) => tokens.push(token),
                     None => {
-                        let mut cursor = node.walk();
-                        new_nodes.append(&mut node.children(&mut cursor).collect::<Vec<Node>>());
+                        if node.child_count() > 0 {
+                            let mut cursor = node.walk();
+                            new_nodes
+                                .append(&mut node.children(&mut cursor).collect::<Vec<Node>>());
+                        }
                     }
                 };
             }
@@ -71,7 +85,7 @@ impl YamlParser {
     fn parse_node<'a>(&self, node: Node, point: Option<Point>) -> Option<Token> {
         match node.kind() {
             "block_mapping_pair" => self.parse_block_mapping_pair(node, point),
-            _ => self.parse_node(node.parent()?, point),
+            _ => None,
         }
     }
 

src/parser/yaml.rs

@@ -11,6 +11,7 @@ pub fn handle_notification(notification: Notification) -> () {
         "textDocument/didOpen" => handle_text_document_did_open(notification.params),
         "textDocument/didChange" => handle_text_document_did_change(notification.params),
         "textDocument/didClose" => (),
+        "textDocument/didSave" => (),
         _ => log::warn!("Unhandled notification {:?}", notification),
     };
 }

src/server/handle_notification.rs

@@ -4,17 +4,28 @@ use super::handlers::completion::handle_text_document_completion;
 use super::handlers::definition::handle_text_document_definition;
 use super::handlers::hover::handle_text_document_hover;
 
-pub fn handle_request(request: Request) -> Option<Response> {
+pub fn handle_request(request: Request) -> Response {
     log::trace!("Handling request: {:?}", request);
 
-    match request.method.as_str() {
+    let request_id = request.id.clone();
+    let response = match request.method.as_str() {
         "textDocument/hover" => handle_text_document_hover(request),
         "textDocument/definition" => handle_text_document_definition(request),
         "textDocument/completion" => handle_text_document_completion(request),
         _ => {
             log::warn!("Unhandled request {:?}", request);
             None
         }
+    };
+
+    // The LSP spec requires the result to be null for empty responses.
+    match response {
+        Some(res) => res,
+        None => Response {
+            id: request_id,
+            result: Some(serde_json::Value::Null),
+            error: None,
+        },
     }
 }
 

src/server/handle_request.rs

@@ -2,9 +2,9 @@ use std::collections::HashMap;
 
 use lsp_server::{ErrorCode, Request, Response};
 use lsp_types::{
-    CompletionItem, CompletionItemKind, CompletionList, CompletionParams, Documentation,
-    InsertTextFormat,
+    CompletionItem, CompletionItemKind, CompletionItemLabelDetails, CompletionList, CompletionParams, Documentation, InsertTextFormat
 };
+use regex::Regex;
 
 use crate::document_store::DOCUMENT_STORE;
 use crate::documentation::get_documentation_for_token;
@@ -88,8 +88,8 @@ pub fn handle_text_document_completion(request: Request) -> Option<Response> {
         }
     }
 
-    // TODO: Refine this.
-    if uri.ends_with(".module") || uri.ends_with(".theme") {
+    let (file_name, extension) = uri.split('/').last()?.split_once('.')?;
+    if extension == "module" || extension == "theme" {
         DOCUMENT_STORE
             .lock()
             .unwrap()
@@ -102,14 +102,23 @@ pub fn handle_text_document_completion(request: Request) -> Option<Response> {
                         if let Some(documentation_string) = get_documentation_for_token(token) {
                             documentation = Some(Documentation::String(documentation_string));
                         }
+                        // Regex to replace placeholders in hook names.
+                        let re = Regex::new(r"([A-Z][A-Z_]+[A-Z])").unwrap();
                         completion_items.push(CompletionItem {
                             label: hook.name.clone(),
-                            kind: Some(CompletionItemKind::FUNCTION),
+                            label_details: Some(CompletionItemLabelDetails {
+                                description: Some("hook".to_string()),
+                                detail: None,
+                            }),
+                            kind: Some(CompletionItemKind::SNIPPET),
+                            insert_text_format: Some(InsertTextFormat::SNIPPET),
                             insert_text: Some(
                                 format!(
-                                    "{}({})",
+                                    "/**\n * Implements {}().\n */\nfunction {}_{}({}) {{\n  $0\n}}",
                                     hook.name,
-                                    hook.parameters.clone().unwrap_or("".to_string())
+                                    file_name,
+                                    re.replace_all(hook.name.replace("hook_", "").as_str(), r"$${$1}"),
+                                    hook.parameters.clone().unwrap_or("".to_string()).replace("$", "\\$")
                                 )
                                 .to_string(),
                             ),

src/server/handlers/completion/mod.rs

@@ -29,10 +29,17 @@ pub fn handle_text_document_definition(request: Request) -> Option<Response> {
     }
 
     let Some(token) = token else {
+        return Some(Response {
+            id: request.id,
+            result: Some(serde_json::Value::Null),
+            error: None,
+        });
+    };
+
+    let Some(definition_result) = provide_definition_for_token(&token) else {
         return None;
     };
 
-    let definition_result = provide_definition_for_token(&token);
     return match serde_json::to_value(definition_result) {
         Ok(result) => Some(Response {
             id: request.id,

src/server/handlers/definition/mod.rs

@@ -22,10 +22,9 @@ async fn main_loop(connection: Connection) -> () {
         match msg {
             Message::Notification(notification) => handle_notification(notification),
             Message::Request(request) => {
-                if let Some(response) = handle_request(request) {
-                    if let Err(e) = connection.sender.send(Message::Response(response)) {
-                        log::error!("Failed to send response: {:?}", e);
-                    }
+                let response = handle_request(request);
+                if let Err(e) = connection.sender.send(Message::Response(response)) {
+                    log::error!("Failed to send response: {:?}", e);
                 }
             }
             _ => log::error!("Unable to process message: {:?}", msg),