achitek-ls 0.2.0

achitekfile language server
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

use crate::utils;
use achitek_ls::{
    handlers::request::handle_completion,
    server::{Document, Documents, ServerState},
};
use lsp_server::{Connection, Request, RequestId};
use lsp_types::{
    CompletionParams, CompletionResponse, Position, TextDocumentIdentifier,
    TextDocumentPositionParams, Uri,
    request::{Completion, Request as LspRequest},
};
use std::fs;

#[test]
fn completion_returns_achitekfile_prompt_attributes() -> anyhow::Result<()> {
    let (server_connection, client_connection) = Connection::memory();
    let uri: Uri = utils::TEST_URI.parse()?;
    let request_id = RequestId::from(1_i32);
    let request = Request::new(
        request_id.clone(),
        Completion::METHOD.to_owned(),
        CompletionParams {
            text_document_position: TextDocumentPositionParams {
                text_document: TextDocumentIdentifier { uri: uri.clone() },
                position: Position {
                    line: 6,
                    character: 2,
                },
            },
            work_done_progress_params: Default::default(),
            partial_result_params: Default::default(),
            context: None,
        },
    );
    let state = ServerState {
        documents: Documents::from([(
            uri.as_str().to_owned(),
            Document {
                version: 1,
                text: valid_completion_source(),
            },
        )]),
        ..Default::default()
    };
    let params = serde_json::from_value(request.params.clone())?;
    let result = handle_completion(&state, params)?;

    utils::send_response(&server_connection, &request, result)?;

    let response = utils::request_response_sink(&client_connection)?;
    assert_eq!(response.id, request_id);
    assert!(response.error.is_none());

    let result: Option<CompletionResponse> =
        serde_json::from_value(response.result.expect("response should contain a result"))?;
    let Some(CompletionResponse::Array(items)) = result else {
        panic!("expected completion item array");
    };
    assert!(items.iter().any(|item| item.label == "type"));

    Ok(())
}

#[test]
fn completion_returns_prompt_names_in_tera_expressions() -> anyhow::Result<()> {
    let temp_root = utils::temp_dir("achitek-template-completion")?;
    fs::create_dir_all(&temp_root)?;
    let achitek_path = temp_root.join("Achitekfile");
    fs::write(&achitek_path, valid_completion_source())?;
    let template_path = temp_root.join("Cargo.toml.tera");
    let template_source = "{{ pro".to_owned();
    fs::write(&template_path, &template_source)?;
    let uri = achitek_ls::server::utils::path_to_uri(&template_path)?;
    let params = CompletionParams {
        text_document_position: TextDocumentPositionParams {
            text_document: TextDocumentIdentifier { uri: uri.clone() },
            position: Position {
                line: 0,
                character: 6,
            },
        },
        work_done_progress_params: Default::default(),
        partial_result_params: Default::default(),
        context: None,
    };
    let state = ServerState {
        documents: Documents::from([(
            uri.as_str().to_owned(),
            Document {
                version: 1,
                text: template_source,
            },
        )]),
        ..Default::default()
    };

    let Some(CompletionResponse::Array(items)) = handle_completion(&state, params)? else {
        panic!("expected completion item array");
    };

    assert!(items.iter().any(|item| item.label == "project_name"));

    fs::remove_dir_all(&temp_root)?;
    Ok(())
}

fn valid_completion_source() -> String {
    indoc::indoc! {r#"
        blueprint {
          version = "1.0.0"
          name = "minimal"
        }

        prompt "project_name" {

        }
    "#}
    .to_owned()
}