qlue-ls 3.4.3

A language server for SPARQL
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

//! End-to-end tests for jump navigation
//!
//! Tests the qlueLs/jump LSP extension. The server formats the document,
//! computes the jump target on the formatted document and returns the
//! edits together with the final cursor position.

mod harness;

use harness::TestClient;
use harness::runtime::run_lsp_test;
use indoc::indoc;

#[test]
fn test_jump_next_formats_and_jumps_past_query() {
    run_lsp_test(|| async {
        let client = TestClient::new();
        client.initialize().await;

        // NOTE: cursor on the whitespace-only line the formatter removes
        let query = "SELECT * WHERE {\n  ?s ?p ?o\n  \n}";
        client.open_document("file:///test.sparql", query).await;

        let id = client.jump("file:///test.sparql", 2, 2, false).await;
        let response = client.get_response(id).expect("Should receive response");
        let result = &response["result"];

        let edits = result["edits"].as_array().expect("edits should be array");
        assert_eq!(edits.len(), 1);
        assert_eq!(
            edits[0]["newText"].as_str().unwrap(),
            "SELECT * WHERE {\n  ?s ?p ?o\n}\n\n"
        );
        // NOTE: cursor on the new line below the query
        assert_eq!(result["position"]["line"], 3);
        assert_eq!(result["position"]["character"], 0);
    });
}

#[test]
fn test_jump_prev_from_body_to_select_clause() {
    run_lsp_test(|| async {
        let client = TestClient::new();
        client.initialize().await;

        let query = indoc!(
            "SELECT * WHERE {
               ?s ?p ?o
            }"
        );
        client.open_document("file:///test.sparql", query).await;

        let id = client.jump("file:///test.sparql", 1, 2, true).await;
        let response = client.get_response(id).expect("Should receive response");
        let result = &response["result"];

        let edits = result["edits"].as_array().expect("edits should be array");
        assert_eq!(edits.len(), 1);
        assert_eq!(
            edits[0]["newText"].as_str().unwrap(),
            "SELECT *  WHERE {\n  ?s ?p ?o\n}\n"
        );
        // NOTE: cursor before the WHERE clause, a " " is inserted after it
        assert_eq!(result["position"]["line"], 0);
        assert_eq!(result["position"]["character"], 9);
    });
}

#[test]
fn test_jump_next_into_group_graph_pattern() {
    run_lsp_test(|| async {
        let client = TestClient::new();
        client.initialize().await;

        let query = indoc!(
            "SELECT * WHERE {
               ?s ?p ?o
            }"
        );
        client.open_document("file:///test.sparql", query).await;

        // NOTE: cursor at the end of the select clause
        let id = client.jump("file:///test.sparql", 0, 8, false).await;
        let response = client.get_response(id).expect("Should receive response");
        let result = &response["result"];

        let edits = result["edits"].as_array().expect("edits should be array");
        assert_eq!(edits.len(), 1);
        assert_eq!(
            edits[0]["newText"].as_str().unwrap(),
            "SELECT * WHERE {\n  ?s ?p ?o\n  \n}\n"
        );
        // NOTE: cursor on the new line inside the group graph pattern
        assert_eq!(result["position"]["line"], 2);
        assert_eq!(result["position"]["character"], 2);
    });
}

#[test]
fn test_jump_applies_format_before_computing_target() {
    run_lsp_test(|| async {
        let client = TestClient::new();
        client.initialize().await;

        // NOTE: unformatted query, cursor at the very end
        let query = "SELECT*WHERE{?a ?b ?c}";
        client.open_document("file:///test.sparql", query).await;

        let id = client.jump("file:///test.sparql", 0, 22, false).await;
        let response = client.get_response(id).expect("Should receive response");
        let result = &response["result"];

        let edits = result["edits"].as_array().expect("edits should be array");
        assert_eq!(edits.len(), 1);
        // NOTE: the jump wraps around to the end of the select clause,
        // which inserts a " " before the cursor
        assert_eq!(
            edits[0]["newText"].as_str().unwrap(),
            "SELECT *  WHERE {\n  ?a ?b ?c\n}\n"
        );
        assert_eq!(result["position"]["line"], 0);
        assert_eq!(result["position"]["character"], 9);
    });
}

#[test]
fn test_jump_on_empty_document_does_not_crash() {
    run_lsp_test(|| async {
        let client = TestClient::new();
        client.initialize().await;

        client.open_document("file:///test.sparql", "").await;

        let id = client.jump("file:///test.sparql", 0, 0, false).await;
        let response = client.get_response(id).expect("Should receive response");
        let result = &response["result"];

        assert!(result["edits"].is_array());
    });
}