juglans 0.2.14

Compiler and runtime for Juglans Workflow Language
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

use tower_lsp::lsp_types::*;

use crate::core::parser::GraphParser;
use crate::core::validator::{ValidationSeverity, WorkflowValidator};

/// Compute LSP diagnostics from source content
pub fn compute_diagnostics(content: &str) -> Vec<Diagnostic> {
    let mut diagnostics = Vec::new();

    // 1. Parse
    let graph = match GraphParser::parse(content) {
        Ok(g) => g,
        Err(e) => {
            let (line, col) = extract_pest_position(&e.to_string());
            diagnostics.push(Diagnostic {
                range: Range::new(Position::new(line, col), Position::new(line, col + 1)),
                severity: Some(DiagnosticSeverity::ERROR),
                code: Some(NumberOrString::String("parse".into())),
                source: Some("juglans".into()),
                message: e.to_string(),
                ..Default::default()
            });
            return diagnostics;
        }
    };

    // 2. Validate
    let result = WorkflowValidator::validate(&graph);

    for issue in result.errors.iter().chain(result.warnings.iter()) {
        let severity = match issue.severity {
            ValidationSeverity::Error => DiagnosticSeverity::ERROR,
            ValidationSeverity::Warning => DiagnosticSeverity::WARNING,
        };

        let range = if let Some(ref node_id) = issue.node_id {
            find_node_range(content, node_id)
        } else {
            Range::new(Position::new(0, 0), Position::new(0, 0))
        };

        diagnostics.push(Diagnostic {
            range,
            severity: Some(severity),
            code: Some(NumberOrString::String(issue.code.clone())),
            source: Some("juglans".into()),
            message: issue.message.clone(),
            ..Default::default()
        });
    }

    diagnostics
}

/// Find `[node_id]` definition in source, return its Range
fn find_node_range(content: &str, node_id: &str) -> Range {
    let def_pattern = format!("[{}]", node_id);
    for (line_num, line) in content.lines().enumerate() {
        if let Some(col) = line.find(&def_pattern) {
            return Range::new(
                Position::new(line_num as u32, col as u32),
                Position::new(line_num as u32, (col + def_pattern.len()) as u32),
            );
        }
    }
    Range::new(Position::new(0, 0), Position::new(0, 0))
}

/// Extract line/col from pest error string like " --> 5:12"
fn extract_pest_position(msg: &str) -> (u32, u32) {
    if let Some(pos) = msg.find(" --> ") {
        let after = &msg[pos + 5..];
        let parts: Vec<&str> = after.splitn(3, ':').collect();
        if parts.len() >= 2 {
            let line = parts[0].trim().parse::<u32>().unwrap_or(1);
            let col = parts[1]
                .split(|c: char| !c.is_ascii_digit())
                .next()
                .and_then(|s| s.parse::<u32>().ok())
                .unwrap_or(1);
            return (line.saturating_sub(1), col.saturating_sub(1));
        }
    }
    (0, 0)
}