qlue-ls 3.4.1

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

use std::rc::Rc;

use super::{
    super::environment::{CompletionEnvironment, CompletionLocation},
    super::error::CompletionError,
    super::utils::{CompletionTemplate, dispatch_completion_query},
};
use crate::server::{Server, lsp::CompletionList, message_handler::completion::utils::reduce_path};
use futures::lock::Mutex;
use ll_sparql_parser::syntax_kind::SyntaxKind;

pub async fn completions(
    server_rc: Rc<Mutex<Server>>,
    environment: &CompletionEnvironment,
) -> Result<CompletionList, CompletionError> {
    let mut template_context = environment.template_context().await;
    template_context.insert("local_context", &local_context(environment));

    dispatch_completion_query(
        server_rc,
        environment,
        template_context,
        CompletionTemplate::PredicateCompletionContextInsensitive,
        true,
    )
    .await
}

fn local_context(environment: &CompletionEnvironment) -> Option<String> {
    if let CompletionLocation::BlankNodeProperty(ref prop_list) = environment.location {
        if environment
            .continuations
            .contains(&SyntaxKind::PropertyListPath)
            || environment
                .continuations
                .contains(&SyntaxKind::PropertyListPathNotEmpty)
            || prop_list.property_list().is_none()
        {
            Some("[] ?qls_entity []".to_string())
        } else {
            let properties = prop_list.property_list().unwrap().properties();
            if environment.continuations.contains(&SyntaxKind::VerbPath) {
                Some("[] ?qls_entity []".to_string())
            } else if properties.len() == 1 {
                reduce_path(
                    "[]",
                    &properties[0].verb,
                    "[]",
                    environment
                        .anchor_token
                        .as_ref()
                        .unwrap()
                        .text_range()
                        .end(),
                )
            } else {
                let (last_prop, prev_prop) = properties.split_last()?;
                Some(format!(
                    "[] {} . {}",
                    prev_prop
                        .iter()
                        .map(|prop| prop.text())
                        .collect::<Vec<_>>()
                        .join(" ; "),
                    reduce_path(
                        "[]",
                        &last_prop.verb,
                        "[]",
                        environment
                            .anchor_token
                            .as_ref()
                            .unwrap()
                            .text_range()
                            .end()
                    )?
                ))
            }
        }
    } else {
        None
    }
}