Completion depends

.gitignore

@@ -1 +1,2 @@
 target
+TODO.md

Cargo.toml

@@ -4,6 +4,7 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+anyhow = "1.0.95"
 lsp-server = "0.7.8"
 lsp-types = "0.97.0"
 serde_json = "1.0.133"

src/handler.rs

@@ -1,22 +1,43 @@
 use lsp_server::{Notification, Request, RequestId};
+use lsp_types::CompletionParams;
 use lsp_types::{
     lsif::DefinitionResultType, request::GotoTypeDefinitionParams, DidChangeTextDocumentParams,
     DidOpenTextDocumentParams, Location, Range,
 };
 
 use crate::state::State;
-use crate::treesitter::{extract_filename, is_mixin_root_node};
+use crate::treesitter::{extract_filename, get_commands, get_current_command, get_position_type, Command, PositionType};
 
 #[derive(Debug)]
 pub struct DefinitionResult {
     pub id: RequestId,
     pub value: DefinitionResultType,
 }
 
+#[derive(Debug)]
+pub struct LSPCompletion {
+    pub label: String,
+    pub details: Option<String>,
+    pub location: Option<LSPLocation>, // to support textEdit
+}
+
+#[derive(Debug, Default)]
+pub struct LSPLocation {
+    pub uri: String,
+    pub range: Range,
+}
+
+#[derive(Debug)]
+pub struct CompletionResult {
+    pub id: RequestId,
+    pub list: Vec<LSPCompletion>,
+}
+
 #[derive(Debug)]
 pub enum LspResult {
     OK,
     Definition(DefinitionResult),
+    Completion(CompletionResult),
 }
 
 #[allow(non_snake_case)]
@@ -55,11 +76,12 @@ pub fn handle_definition(req: Request, state: &mut State) -> Option<LspResult> {
     let doc = state.get_document(uri)?;
     let pos = params.text_document_position_params.position;
 
-    if !is_mixin_root_node(doc, &pos) {
+    if !matches!(get_position_type(doc, &pos), PositionType::Mixins) {
         return None;
     }
 
     let filename = extract_filename(doc, &pos)?;
+    // TODO: check if file exists
 
     let uri = go_to_def_filename(uri, &filename).parse().ok();
     match uri {
@@ -75,3 +97,97 @@ pub fn handle_definition(req: Request, state: &mut State) -> Option<LspResult> {
         None => None,
     }
 }
+
+pub fn handle_completion(req: Request, state: &mut State) -> Option<LspResult> {
+    let params: CompletionParams = serde_json::from_value(req.params).ok()?;
+    let uri = params.text_document_position.text_document.uri.as_str();
+    let doc = state.get_document(uri)?;
+    let position = params.text_document_position.position;
+
+    let items = match get_position_type(doc, &position) {
+        PositionType::Depends => {
+            let commands = get_commands(doc);
+            let current_command = get_current_command(doc, &position)?;
+            on_completion_depends(&current_command, &commands).ok()?
+        },
+        PositionType::Mixins => {
+            on_completion_mixins().ok()?
+        },
+        _ => return None,
+    };
+    Some(LspResult::Completion(CompletionResult {
+        id: req.id,
+        list: items,
+    }))
+}
+
+fn on_completion_depends(current_command: &Command, commands: &[Command]) -> anyhow::Result<Vec<LSPCompletion>> {
+    commands
+    .iter()
+    // TODO: do not complete already added commands to depends list
+    .filter(|cmd| cmd.name != current_command.name)
+    .map(|cmd| -> anyhow::Result<LSPCompletion> {
+        Ok(LSPCompletion {
+            label: cmd.name.clone(),
+            details: None,
+            location: None,
+        })
+    })
+    .collect()
+}
+
+fn on_completion_mixins() -> anyhow::Result<Vec<LSPCompletion>> {
+    // walk current dir or take word as dir if with /
+    Ok(vec![])
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use lsp_types::Position;
+
+    #[test]
+    fn test_complete_depends_block_sequence() {
+        let doc = r#"
+shell: bash
+commands:
+  test:
+    cmd: echo Test
+    depends:
+      -
+  test2:
+    cmd: echo Test2"#
+            .trim();
+
+        let position = Position::new(5, 7);
+        let commands = get_commands(doc);
+        let command = get_current_command(doc, &position).expect("Command not found");
+        let result = on_completion_depends(&command, &commands).expect("Completion failed");
+
+        assert_eq!(result.len(), 1);
+        assert_eq!(result[0].label, "test2");
+        assert!(result[0].location.is_none());
+    }
+
+    #[test]
+    fn test_complete_depends_flow_node() {
+        let doc = r#"
+shell: bash
+commands:
+  test:
+    cmd: echo Test
+    depends: []
+  test2:
+    cmd: echo Test2"#
+            .trim();
+
+        let position = Position::new(4, 14);
+        let commands = get_commands(doc);
+        let command = get_current_command(doc, &position).expect("Command not found");
+        let result = on_completion_depends(&command, &commands).expect("Completion failed");
+
+        assert_eq!(result.len(), 1);
+        assert_eq!(result[0].label, "test2");
+        assert!(result[0].location.is_none());
+    }
+}

src/main.rs

@@ -3,12 +3,14 @@ use std::error::Error;
 use lsp_server::{Connection, Message};
 use lsp_types::ServerCapabilities;
 
-use crate::handler::{handle_definition, handle_didChange, handle_didOpen, LspResult};
+use crate::handler::{handle_completion, handle_definition, handle_didChange, handle_didOpen, LspResult};
 use crate::state::State;
+use crate::responses::{completion_response, definition_response};
 
 pub mod handler;
 pub mod state;
 pub mod treesitter;
+pub mod responses;
 
 fn main() -> Result<(), Box<dyn Error + Sync + Send>> {
     eprintln!("Lets LSP server starting");
@@ -22,6 +24,22 @@ fn main() -> Result<(), Box<dyn Error + Sync + Send>> {
         )),
         hover_provider: Some(lsp_types::HoverProviderCapability::Simple(true)),
         definition_provider: Some(lsp_types::OneOf::Left(true)),
+        completion_provider: Some(lsp_types::CompletionOptions {
+            resolve_provider: Some(false),
+            trigger_characters: Some(vec![
+                ".".to_string(),
+                ":".to_string(),
+                " ".to_string(),
+                "$".to_string(),
+                "- ".to_string(),
+                "[".to_string(),
+            ]),
+            work_done_progress_options: lsp_types::WorkDoneProgressOptions {
+                work_done_progress: None,
+            },
+            all_commit_characters: None,
+            completion_item: None,
+        }),
         ..ServerCapabilities::default()
     };
 
@@ -43,6 +61,7 @@ fn main() -> Result<(), Box<dyn Error + Sync + Send>> {
                 eprintln!("--> Request: {:?}", req);
                 match req.method.as_str() {
                     "textDocument/definition" => handle_definition(req, &mut state),
+                    "textDocument/completion" => handle_completion(req, &mut state),
                     _ => None,
                 }
             }
@@ -64,13 +83,10 @@ fn main() -> Result<(), Box<dyn Error + Sync + Send>> {
             match result {
                 LspResult::OK => (),
                 LspResult::Definition(result) => {
-                    let result = lsp_server::Response {
-                        id: result.id,
-                        result: Some(serde_json::to_value(result.value)?),
-                        error: None,
-                    };
-                    let response = Message::Response(result);
-                    connection.sender.send(response)?
+                    connection.sender.send(definition_response(result)?)?
+                },
+                LspResult::Completion(result) => {
+                    connection.sender.send(completion_response(result))?
                 }
             }
         }

src/responses.rs

@@ -0,0 +1,43 @@
+use lsp_server::Message;
+
+use crate::handler;
+
+pub fn definition_response(result: handler::DefinitionResult) -> anyhow::Result<Message> {
+    Ok(Message::Response(lsp_server::Response {
+        id: result.id,
+        result: serde_json::to_value(result.value).ok(),
+        error: None,
+    }))
+}
+
+pub fn completion_response(result: handler::CompletionResult) -> Message {
+    Message::Response(lsp_server::Response {
+        id: result.id,
+        result: serde_json::to_value(lsp_types::CompletionList {
+            items: result
+                .list
+                .iter()
+                .map(|c| {
+                    let mut item = lsp_types::CompletionItem {
+                        label: c.label.clone(),
+                        kind: Some(lsp_types::CompletionItemKind::KEYWORD),
+                        ..Default::default()
+                    };
+
+                    if let Some(documentation) = c.details.clone() {
+                        item.documentation =
+                            Some(lsp_types::Documentation::MarkupContent(lsp_types::MarkupContent {
+                                kind: lsp_types::MarkupKind::Markdown,
+                                value: documentation.clone(),
+                            }));
+                    }
+
+                    item
+                })
+                .collect(),
+            is_incomplete: false,
+        })
+        .ok(),
+        error: None,
+    })
+}