php-lsp 0.4.0

A PHP Language Server Protocol implementation
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

//! Text formatting: document formatting, range formatting, and on-type formatting.

mod common;

use common::TestServer;

#[tokio::test]
async fn formatting_returns_null_or_valid_edits() {
    let mut server = TestServer::new().await;
    server
        .open("fmt.php", "<?php\nfunction ugly( $x ){return $x;}\n")
        .await;

    let resp = server.formatting("fmt.php").await;

    assert!(resp["error"].is_null(), "formatting error: {:?}", resp);
    match resp["result"].as_array() {
        None => assert!(
            resp["result"].is_null(),
            "expected null (no formatter) or TextEdit array, got: {:?}",
            resp["result"]
        ),
        Some(edits) => {
            assert!(!edits.is_empty(), "formatter returned empty edit array");
            for edit in edits {
                assert!(
                    edit["range"].is_object(),
                    "TextEdit missing 'range': {:?}",
                    edit
                );
                assert!(
                    edit["newText"].is_string(),
                    "TextEdit missing 'newText': {:?}",
                    edit
                );
            }
        }
    }
}

#[tokio::test]
async fn range_formatting_returns_null_or_valid_edits() {
    let mut server = TestServer::new().await;
    server
        .open("rfmt.php", "<?php\nfunction ugly( $x ){return $x;}\n")
        .await;

    let resp = server.range_formatting("rfmt.php", 0, 0, 2, 0).await;

    assert!(resp["error"].is_null(), "rangeFormatting error: {:?}", resp);
    match resp["result"].as_array() {
        None => assert!(
            resp["result"].is_null(),
            "expected null (no formatter) or TextEdit array, got: {:?}",
            resp["result"]
        ),
        Some(edits) => {
            assert!(!edits.is_empty(), "formatter returned empty edit array");
            for edit in edits {
                assert!(
                    edit["range"].is_object(),
                    "TextEdit missing 'range': {:?}",
                    edit
                );
                assert!(
                    edit["newText"].is_string(),
                    "TextEdit missing 'newText': {:?}",
                    edit
                );
            }
        }
    }
}

/// Unknown trigger characters must return null — the handler only supports `}` and `\n`.
#[tokio::test]
async fn on_type_formatting_unknown_trigger_returns_null() {
    let mut server = TestServer::new().await;
    server.open("otfmt.php", "<?php\nif (true) {\n").await;

    let resp = server.on_type_formatting("otfmt.php", 1, 10, "{").await;

    assert!(
        resp["error"].is_null(),
        "onTypeFormatting error: {:?}",
        resp
    );
    assert!(
        resp["result"].is_null(),
        "expected null for unhandled trigger '{{', got: {:?}",
        resp["result"]
    );
}

/// The `}` trigger is handled in-process (no external tool needed) and must
/// de-indent the closing brace to match the indentation of the opening `{`.
#[tokio::test]
async fn on_type_formatting_close_brace_deindents() {
    let mut server = TestServer::new().await;
    server
        .open("otfmt2.php", "<?php\nif (true) {\n    }\n")
        .await;

    let resp = server.on_type_formatting("otfmt2.php", 2, 4, "}").await;

    assert!(
        resp["error"].is_null(),
        "onTypeFormatting error: {:?}",
        resp
    );
    let edits = resp["result"]
        .as_array()
        .expect("} trigger must produce a TextEdit array");
    assert_eq!(edits.len(), 1, "expected exactly one de-indent edit");

    let edit = &edits[0];
    assert_eq!(
        edit["range"]["start"],
        serde_json::json!({"line": 2, "character": 0}),
        "edit start must be at line 2, character 0"
    );
    assert_eq!(
        edit["range"]["end"],
        serde_json::json!({"line": 2, "character": 4}),
        "edit end must be at line 2, character 4 (replacing 4-space indent)"
    );
    assert_eq!(
        edit["newText"].as_str().unwrap(),
        "",
        "newText must be empty (de-indent to column 0)"
    );
}