jsona-lsp 0.4.0

Language server for JSONA
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

use jsona::syntax::{
    SyntaxElement,
    SyntaxKind::{ANNOTATION_VALUE, ARRAY, BLOCK_COMMENT, LINE_COMMENT, OBJECT},
    SyntaxNode,
};
use jsona_util::environment::Environment;
use lsp_async_stub::{
    rpc::Error,
    util::{LspExt, Mapper},
    Context, Params,
};
use lsp_types::{FoldingRange, FoldingRangeKind, FoldingRangeParams, Range};

use crate::world::World;

#[tracing::instrument(skip_all)]
pub(crate) async fn folding_ranges<E: Environment>(
    context: Context<World<E>>,
    params: Params<FoldingRangeParams>,
) -> Result<Option<Vec<FoldingRange>>, Error> {
    let p = params.required()?;

    let workspaces = context.workspaces.read().await;
    let document_uri = &p.text_document.uri;
    let (_, doc) = workspaces.try_get_document(document_uri)?;

    let syntax = doc.parse.clone().into_syntax();

    Ok(Some(
        syntax
            .descendants_with_tokens()
            .filter_map(|d| match d.kind() {
                OBJECT | ARRAY | ANNOTATION_VALUE | BLOCK_COMMENT => {
                    doc.mapper.range(d.text_range()).map(|range| FoldingRange {
                        start_line: range.start.line as u32,
                        end_line: range.end.line as u32,
                        kind: match d.kind() {
                            BLOCK_COMMENT => Some(FoldingRangeKind::Comment),
                            _ => None,
                        },
                        ..FoldingRange::default()
                    })
                }
                _ => None,
            })
            .chain(collect_consecutive_comments(&doc.mapper, &syntax))
            .collect(),
    ))
}

fn collect_consecutive_comments(
    mapper: &Mapper,
    syntax: &SyntaxNode,
) -> impl Iterator<Item = FoldingRange> {
    let mut ranges = Vec::new();

    let mut last_comment_range: Option<Range> = None;

    for token in syntax
        .descendants_with_tokens()
        .filter(|n| n.kind() == LINE_COMMENT)
        .filter_map(SyntaxElement::into_token)
    {
        let range = mapper
            .range(token.text_range())
            .unwrap_or_default()
            .into_lsp();

        match last_comment_range {
            Some(mut existing_range) => {
                if range.end.line - existing_range.end.line > 1 {
                    if existing_range.end.line != existing_range.start.line {
                        ranges.push(FoldingRange {
                            start_line: existing_range.start.line,
                            end_line: existing_range.end.line,
                            kind: Some(FoldingRangeKind::Comment),
                            ..FoldingRange::default()
                        });
                    }

                    last_comment_range = Some(range);
                } else {
                    existing_range.end = range.end;
                    last_comment_range = Some(existing_range);
                }
            }
            None => last_comment_range = Some(range),
        }
    }

    if let Some(existing_range) = last_comment_range {
        if existing_range.end.line != existing_range.start.line {
            ranges.push(FoldingRange {
                start_line: existing_range.start.line,
                end_line: existing_range.end.line,
                ..FoldingRange::default()
            });
        }
    }

    ranges.into_iter()
}