feat: permission completion/hover/definition + route parameter completion

jdrupal-dev · jdrupal-dev · commit b0d49d695c72 · 2025-02-03T19:27:42.000+01:00
diff --git a/README.md b/README.md
@@ -10,20 +10,26 @@ WIP!
 - Route references
 - Route controller/form
 - Hook references
+- Permission references
 ### Go to definition
 - Service references
 - Service class
 - Route references
 - Route controller/form
 - Hook references
+- Permission references
 ### Completion
 - Services
 - Routes
 - Hook snippets
 - General snippets
+- Permissions
 
 ## Roadmap
 ### Completion
-- [ ] Autocomplete permissions.
 - [ ] Autocomplete plugin IDs (eg. queue workers, blocks, fields, migrate source/process/destination).
+- [ ] Autocomplete #theme functions.
 
+### Code actions
+- [ ] Generate __construct doc block.
+- [ ] Generate t function placeholder array.
diff --git a/src/document_store/document.rs b/src/document_store/document.rs
@@ -42,7 +42,7 @@ impl Document {
                 parser.get_tokens()
             }
             FileType::Yaml => {
-                let parser = YamlParser::new(&self.content);
+                let parser = YamlParser::new(&self.content, &self.uri);
                 parser.get_tokens()
             }
             FileType::Unknown => {
@@ -61,11 +61,11 @@ impl Document {
             FileType::Php => {
                 let parser = PhpParser::new(&self.content);
                 return parser.get_token_at_position(position);
-            },
+            }
             FileType::Yaml => {
-                let parser = YamlParser::new(&self.content);
+                let parser = YamlParser::new(&self.content, &self.uri);
                 return parser.get_token_at_position(position);
-            },
+            }
             _ => None,
         }
     }
diff --git a/src/document_store/mod.rs b/src/document_store/mod.rs
@@ -28,11 +28,15 @@ pub fn initialize_document_store(root_dir: String) {
     let mut override_builder = OverrideBuilder::new(&root_dir);
     override_builder.add("**/*.services.yml").unwrap();
     override_builder.add("**/*.routing.yml").unwrap();
+    override_builder.add("**/*.permissions.yml").unwrap();
+    override_builder.add("**/*.menu.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("!**/core/lib/**/*Interface.php")
+        .unwrap();
     override_builder.add("!**/Plugin/**/*.php").unwrap();
     override_builder.add("!vendor").unwrap();
     override_builder.add("!node_modules").unwrap();
@@ -80,7 +84,7 @@ pub fn initialize_document_store(root_dir: String) {
     log::info!(
         "Parsed {} files in {} seconds",
         documents.len(),
-        now.elapsed().unwrap().as_secs()
+        now.elapsed().unwrap().as_secs_f64()
     );
 
     DOCUMENT_STORE.lock().unwrap().add_documents(documents);
@@ -216,6 +220,23 @@ impl DocumentStore {
         })
     }
 
+    pub fn get_permission_definition(&self, permission_name: &str) -> Option<(&Document, &Token)> {
+        let files = self.get_documents_by_file_type(FileType::Yaml);
+        log::info!("{}", permission_name);
+
+        files.iter().find_map(|&document| {
+            Some((
+                document,
+                document.tokens.iter().find(|token| {
+                    if let TokenData::DrupalPermissionDefinition(permission) = &token.data {
+                        return permission.name == permission_name;
+                    }
+                    return false;
+                })?,
+            ))
+        })
+    }
+
     fn get_documents_by_file_type(&self, file_type: FileType) -> Vec<&Document> {
         self.documents
             .values()
diff --git a/src/documentation/mod.rs b/src/documentation/mod.rs
@@ -60,6 +60,22 @@ const HOOK_DEFINITION: &str = r#"
 ```
 "#;
 
+const PERMISSION_REFERENCE: &str = r#"
+# Permission reference: @name
+
+*Implementation:*
+```yaml
+@definition
+```
+
+@see [@uri](@uri)
+"#;
+
+const PERMISSION_DEFINITION: &str = r#"
+# Permission: @name
+Title: @title
+"#;
+
 pub fn get_documentation_for_token(token: &Token) -> Option<String> {
     match &token.data {
         TokenData::PhpClassReference(class) => {
@@ -137,6 +153,28 @@ pub fn get_documentation_for_token(token: &Token) -> Option<String> {
                 &hook.parameters.clone().unwrap_or(String::default()),
             ))
         }
+        TokenData::DrupalPermissionReference(permission_name) => {
+            let store = DOCUMENT_STORE.lock().unwrap();
+
+            let (source_document, token) = store.get_permission_definition(permission_name)?;
+            if let TokenData::DrupalPermissionDefinition(permission) = &token.data {
+                let definition =
+                    &source_document.content[token.range.start_byte..token.range.end_byte];
+
+                return Some(
+                    PERMISSION_REFERENCE
+                        .replace("@name", &permission.name)
+                        .replace("@uri", source_document.get_uri()?.as_str())
+                        .replace("@definition", definition),
+                );
+            }
+            None
+        }
+        TokenData::DrupalPermissionDefinition(permission) => Some(
+            PERMISSION_DEFINITION
+                .replace("@name", &permission.name)
+                .replace("@title", &permission.title),
+        ),
         _ => None,
     }
 }
diff --git a/src/parser/php.rs b/src/parser/php.rs
@@ -145,17 +145,23 @@ impl PhpParser {
         let name_node = node.child_by_field_name("name")?;
         let name = self.get_node_text(&name_node);
 
-        if name == "fromRoute" || name == "createFromRoute" {
+        if name == "fromRoute" || name == "createFromRoute" || name == "setRedirect" {
             return Some(Token::new(
                 TokenData::DrupalRouteReference(self.get_node_text(&string_content).to_string()),
                 node.range(),
             ));
-        }
-        if name == "service" {
+        } else if name == "service" {
             return Some(Token::new(
                 TokenData::DrupalServiceReference(self.get_node_text(&string_content).to_string()),
                 node.range(),
             ));
+        } else if name == "hasPermission" {
+            return Some(Token::new(
+                TokenData::DrupalPermissionReference(
+                    self.get_node_text(&string_content).to_string(),
+                ),
+                node.range(),
+            ));
         }
         // TODO: This is a quite primitive way to detect ContainerInterface::get.
         // Can we somehow get the interface of a given variable?
diff --git a/src/parser/tokens.rs b/src/parser/tokens.rs
@@ -1,3 +1,4 @@
+use regex::Regex;
 use std::collections::HashMap;
 use tree_sitter::Range;
 
@@ -25,6 +26,8 @@ pub enum TokenData {
     DrupalServiceDefinition(DrupalService),
     DrupalHookReference(String),
     DrupalHookDefinition(DrupalHook),
+    DrupalPermissionDefinition(DrupalPermission),
+    DrupalPermissionReference(String),
 }
 
 #[derive(Debug, PartialEq)]
@@ -82,6 +85,19 @@ pub struct DrupalRoute {
     pub defaults: DrupalRouteDefaults,
 }
 
+impl DrupalRoute {
+    pub fn get_route_parameters(&self) -> Vec<&str> {
+        let re = Regex::new(r"\{([^{}]+)\}");
+        match re {
+            Ok(re) => re
+                .captures_iter(&self.path)
+                .map(|c| c.get(1).unwrap().as_str())
+                .collect(),
+            Err(_) => vec![],
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct DrupalRouteDefaults {
     pub controller: Option<PhpMethod>,
@@ -103,6 +119,12 @@ pub struct DrupalHook {
     pub parameters: Option<String>,
 }
 
+#[derive(Debug)]
+pub struct DrupalPermission {
+    pub name: String,
+    pub title: String,
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/src/parser/yaml.rs b/src/parser/yaml.rs
@@ -4,17 +4,20 @@ use std::{usize, vec};
 use tree_sitter::{Node, Parser, Point, Tree};
 
 use super::tokens::{
-    DrupalRoute, DrupalRouteDefaults, DrupalService, PhpClassName, PhpMethod, Token, TokenData,
+    DrupalPermission, DrupalRoute, DrupalRouteDefaults, DrupalService, PhpClassName, PhpMethod,
+    Token, TokenData,
 };
 
 pub struct YamlParser {
     source: String,
+    uri: String,
 }
 
 impl YamlParser {
-    pub fn new(source: &str) -> Self {
+    pub fn new(source: &str, uri: &str) -> Self {
         Self {
             source: source.to_string(),
+            uri: uri.to_string(),
         }
     }
 
@@ -95,8 +98,20 @@ impl YamlParser {
         let value_node = node.child_by_field_name("value")?;
 
         if let Some(map) = self.get_block_node_map(&value_node) {
+            // Parse Drupal Permission.
+            if self.uri.ends_with(".permissions.yml") {
+                if let Some(title) = map.get("title") {
+                    return Some(Token::new(
+                        TokenData::DrupalPermissionDefinition(DrupalPermission {
+                            name: key.to_string(),
+                            title: self.get_node_text(title).to_string(),
+                        }),
+                        node.range(),
+                    ));
+                }
+            }
             // Parse Drupal Route.
-            if let (Some(path), Some(defaults)) = (map.get("path"), map.get("defaults")) {
+            else if let (Some(path), Some(defaults)) = (map.get("path"), map.get("defaults")) {
                 return Some(Token::new(
                     TokenData::DrupalRouteDefinition(DrupalRoute {
                         name: key.to_string(),
@@ -132,6 +147,18 @@ impl YamlParser {
                 TokenData::PhpClassReference(PhpClassName::from(self.get_node_text(&value_node))),
                 value_node.range(),
             )),
+            "_permission" => Some(Token::new(
+                TokenData::DrupalPermissionReference(
+                    self.get_node_text(&value_node).to_string().replace("'", ""),
+                ),
+                value_node.range(),
+            )),
+            "route_name" => Some(Token::new(
+                TokenData::DrupalRouteReference(
+                    self.get_node_text(&value_node).to_string().replace("'", ""),
+                ),
+                value_node.range(),
+            )),
             "arguments" => {
                 let argument = value_node.descendant_for_point_range(point?, point?)?;
                 if argument.kind() != "single_quote_scalar" {
diff --git a/src/server/handlers/completion/mod.rs b/src/server/handlers/completion/mod.rs
diff --git a/src/server/handlers/definition/mod.rs b/src/server/handlers/definition/mod.rs
diff --git a/src/server/mod.rs b/src/server/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ impl Document {`
`42`	`42`	`parser.get_tokens()`
`43`	`43`	`}`
`44`	`44`	`FileType::Yaml => {`
`45`		`- let parser = YamlParser::new(&self.content);`
	`45`	`+ let parser = YamlParser::new(&self.content, &self.uri);`
`46`	`46`	`parser.get_tokens()`
`47`	`47`	`}`
`48`	`48`	`FileType::Unknown => {`
`@@ -61,11 +61,11 @@ impl Document {`
`61`	`61`	`FileType::Php => {`
`62`	`62`	`let parser = PhpParser::new(&self.content);`
`63`	`63`	`return parser.get_token_at_position(position);`
`64`		`- },`
	`64`	`+ }`
`65`	`65`	`FileType::Yaml => {`
`66`		`- let parser = YamlParser::new(&self.content);`
	`66`	`+ let parser = YamlParser::new(&self.content, &self.uri);`
`67`	`67`	`return parser.get_token_at_position(position);`
`68`		`- },`
	`68`	`+ }`
`69`	`69`	`_ => None,`
`70`	`70`	`}`
`71`	`71`	`}`