nika-engine 0.38.0

Nika workflow engine — embeddable runtime, provider, DAG, and binding logic
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

//! CodeLens Handler
//!
//! Shows inline actionable buttons above workflow elements:
//! - "▶ Run Workflow" on the `tasks:` line
//! - "✓ Validate" on the `schema:` or `workflow:` line
//! - Task count summary on `tasks:` line

#[cfg(feature = "lsp")]
use tower_lsp_server::ls_types::*;

/// Compute code lenses for the document.
#[cfg(feature = "lsp")]
pub fn compute_code_lenses(text: &str, _uri: &Uri) -> Vec<CodeLens> {
    let mut lenses = Vec::new();
    let lines: Vec<&str> = text.lines().collect();

    // Pre-compute task count (avoid O(n²) scan inside loop)
    let task_count = lines
        .iter()
        .filter(|l| l.trim().starts_with("- id:"))
        .count();

    for (i, line) in lines.iter().enumerate() {
        let trimmed = line.trim();
        let line_range = Range {
            start: Position {
                line: i as u32,
                character: 0,
            },
            end: Position {
                line: i as u32,
                character: line.chars().map(|c| c.len_utf16()).sum::<usize>() as u32,
            },
        };

        // "✓ Validate" on schema: or workflow: line
        if trimmed.starts_with("schema:") || trimmed.starts_with("workflow:") {
            lenses.push(CodeLens {
                range: line_range,
                command: Some(Command {
                    title: "✓ Validate".to_string(),
                    command: "nika.checkWorkflow".to_string(),
                    arguments: None,
                }),
                data: None,
            });
        }

        // "▶ Run" + task count on tasks: line
        if trimmed == "tasks:" {
            lenses.push(CodeLens {
                range: line_range,
                command: Some(Command {
                    title: "▶ Run Workflow".to_string(),
                    command: "nika.runWorkflow".to_string(),
                    arguments: None,
                }),
                data: None,
            });

            if task_count > 0 {
                lenses.push(CodeLens {
                    range: line_range,
                    command: Some(Command {
                        title: format!(
                            "{} task{}",
                            task_count,
                            if task_count == 1 { "" } else { "s" }
                        ),
                        command: "nika.showTasks".to_string(),
                        arguments: None,
                    }),
                    data: None,
                });
            }
        }
    }

    lenses
}

#[cfg(test)]
mod tests {
    #[cfg(feature = "lsp")]
    use super::*;

    #[cfg(feature = "lsp")]
    fn test_uri() -> Uri {
        "file:///test.nika.yaml".parse().unwrap()
    }

    #[test]
    #[cfg(feature = "lsp")]
    fn validate_on_schema() {
        let lenses = compute_code_lenses("schema: \"@0.12\"\n", &test_uri());
        assert!(lenses.iter().any(|l| l
            .command
            .as_ref()
            .is_some_and(|c| c.title.contains("Validate"))));
    }

    #[test]
    #[cfg(feature = "lsp")]
    fn run_on_tasks() {
        let text = "schema: \"@0.12\"\ntasks:\n  - id: step1\n    infer: x\n";
        let lenses = compute_code_lenses(text, &test_uri());
        assert!(lenses
            .iter()
            .any(|l| l.command.as_ref().is_some_and(|c| c.title.contains("Run"))));
    }

    #[test]
    #[cfg(feature = "lsp")]
    fn task_count() {
        let text =
            "tasks:\n  - id: a\n    exec: x\n  - id: b\n    exec: y\n  - id: c\n    exec: z\n";
        let lenses = compute_code_lenses(text, &test_uri());
        assert!(lenses.iter().any(|l| l
            .command
            .as_ref()
            .is_some_and(|c| c.title.contains("3 tasks"))));
    }

    #[test]
    #[cfg(feature = "lsp")]
    fn no_lenses_on_empty() {
        let lenses = compute_code_lenses("", &test_uri());
        assert!(lenses.is_empty());
    }
}