grpctestify 1.8.6

gRPC testing utility written in Rust
Documentation 
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

//! Document symbols for GCTF documents.
//!
//! Builds a tree of symbols for assertions and extracted variables
//! that appears in the LSP document symbol response.

use crate::parser;
use crate::parser::ast::SectionType;
use tower_lsp::lsp_types::{DocumentSymbol, Position, Range, SymbolKind};

/// Build document symbols (assertions and extracted variables) for a GCTF document.
pub fn build_section_children_for_doc(doc: &parser::GctfDocument) -> Vec<DocumentSymbol> {
    let mut all_children: Vec<DocumentSymbol> = Vec::new();

    for s in &doc.sections {
        let mut children: Vec<DocumentSymbol> = Vec::new();

        if s.section_type == SectionType::Asserts {
            for (idx, line) in s.raw_content.lines().enumerate() {
                let trimmed = line.trim();
                if trimmed.is_empty() || trimmed.starts_with('#') || trimmed.starts_with("//") {
                    continue;
                }

                let line_num = (s.start_line + idx + 1) as u32;
                #[expect(deprecated)]
                let mut assertion_symbol = DocumentSymbol {
                    name: trimmed.to_string(),
                    detail: Some("assertion".to_string()),
                    kind: SymbolKind::STRING,
                    tags: None,
                    deprecated: None,
                    range: Range::new(
                        Position::new(line_num, 0),
                        Position::new(line_num, trimmed.len() as u32),
                    ),
                    selection_range: Range::new(
                        Position::new(line_num, 0),
                        Position::new(line_num, trimmed.len() as u32),
                    ),
                    children: None,
                };

                let mut var_children = Vec::new();
                let mut offset = 0usize;
                while let Some(open) = trimmed[offset..].find("{{") {
                    let abs_open = offset + open;
                    let Some(close_rel) = trimmed[abs_open..].find("}}") else {
                        break;
                    };
                    let abs_close = abs_open + close_rel + 2;
                    let inner = trimmed[abs_open + 2..abs_close - 2].trim();
                    if !inner.is_empty() {
                        #[expect(deprecated)]
                        var_children.push(DocumentSymbol {
                            name: inner.to_string(),
                            detail: Some("variable reference".to_string()),
                            kind: SymbolKind::VARIABLE,
                            tags: None,
                            deprecated: None,
                            range: Range::new(
                                Position::new(line_num, abs_open as u32),
                                Position::new(line_num, abs_close as u32),
                            ),
                            selection_range: Range::new(
                                Position::new(line_num, (abs_open + 2) as u32),
                                Position::new(line_num, (abs_close - 2) as u32),
                            ),
                            children: None,
                        });
                    }
                    offset = abs_close;
                }

                if !var_children.is_empty() {
                    assertion_symbol.children = Some(var_children);
                }

                children.push(assertion_symbol);
            }
        }

        if s.section_type == SectionType::Extract {
            for (idx, line) in s.raw_content.lines().enumerate() {
                let trimmed = line.trim();
                if trimmed.is_empty() || trimmed.starts_with('#') || trimmed.starts_with("//") {
                    continue;
                }

                let Some((name, expr)) = trimmed.split_once('=') else {
                    continue;
                };
                let var_name = name.trim();
                let line_num = (s.start_line + idx + 1) as u32;
                let expr_trimmed = expr.trim();

                #[expect(deprecated)]
                children.push(DocumentSymbol {
                    name: var_name.to_string(),
                    detail: Some(format!("extract: {}", expr_trimmed)),
                    kind: SymbolKind::VARIABLE,
                    tags: None,
                    deprecated: None,
                    range: Range::new(
                        Position::new(line_num, 0),
                        Position::new(line_num, trimmed.len() as u32),
                    ),
                    selection_range: Range::new(
                        Position::new(line_num, 0),
                        Position::new(line_num, var_name.len() as u32),
                    ),
                    children: None,
                });
            }
        }

        if !children.is_empty() {
            all_children.extend(children);
        }
    }

    all_children
}