php-lsp 0.29.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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

//! Protocol-wired tests for validation rule-name completion inside
//! `->validate([...])`/`Validator::make([...])`/a `rules()` method's
//! `return [...]` (`src/laravel/validation_rules.rs`).

use super::*;

use expect_test::expect;

fn write_minimal_laravel_project(root: &std::path::Path) {
    std::fs::write(root.join("artisan"), "#!/usr/bin/env php\n").unwrap();
}

#[tokio::test]
async fn completion_suggests_rule_names_in_pipe_form_first_rule() {
    let tmp = tempfile::tempdir().unwrap();
    write_minimal_laravel_project(tmp.path());
    let php = "<?php\nclass Controller {\n    public function store($request) {\n        $request->validate(['email' => 'requ\n    }\n}\n";
    std::fs::write(tmp.path().join("app.php"), php).unwrap();

    let mut s = TestServer::with_root(tmp.path()).await;
    s.wait_for_index_ready().await;
    s.open("app.php", php).await;

    // Line 3 (0-based), character 44 = right after "requ".
    let resp = s.completion("app.php", 3, 44).await;
    let out = render_completion(&resp);
    assert!(
        out.contains("Keyword     required"),
        "expected 'required' rule completion, got:\n{out}"
    );
}

#[tokio::test]
async fn completion_suggests_rule_names_after_pipe() {
    let tmp = tempfile::tempdir().unwrap();
    write_minimal_laravel_project(tmp.path());
    let php = "<?php\nclass Controller {\n    public function store($request) {\n        $request->validate(['email' => 'required|em\n    }\n}\n";
    std::fs::write(tmp.path().join("app.php"), php).unwrap();

    let mut s = TestServer::with_root(tmp.path()).await;
    s.wait_for_index_ready().await;
    s.open("app.php", php).await;

    // Line 3 (0-based), character 51 = right after "em" (following "required|").
    let resp = s.completion("app.php", 3, 51).await;
    let out = render_completion(&resp);
    expect!["Keyword     email"].assert_eq(&out);
}

#[tokio::test]
async fn completion_suggests_rule_names_in_array_form() {
    let tmp = tempfile::tempdir().unwrap();
    write_minimal_laravel_project(tmp.path());
    let php = "<?php\nclass Controller {\n    public function store($request) {\n        $request->validate(['email' => ['required', 'em\n    }\n}\n";
    std::fs::write(tmp.path().join("app.php"), php).unwrap();

    let mut s = TestServer::with_root(tmp.path()).await;
    s.wait_for_index_ready().await;
    s.open("app.php", php).await;

    // Line 3 (0-based), character 55 = right after "em" in the array form.
    let resp = s.completion("app.php", 3, 55).await;
    let out = render_completion(&resp);
    expect!["Keyword     email"].assert_eq(&out);
}

#[tokio::test]
async fn completion_suggests_rule_names_in_validator_make_second_argument() {
    let tmp = tempfile::tempdir().unwrap();
    write_minimal_laravel_project(tmp.path());
    let php = "<?php\nValidator::make($data, ['email' => 'requ\n";
    std::fs::write(tmp.path().join("app.php"), php).unwrap();

    let mut s = TestServer::with_root(tmp.path()).await;
    s.wait_for_index_ready().await;
    s.open("app.php", php).await;

    // Line 1 (0-based), character 40 = right after "requ".
    let resp = s.completion("app.php", 1, 40).await;
    let out = render_completion(&resp);
    assert!(
        out.contains("Keyword     required"),
        "expected 'required' rule completion from Validator::make(), got:\n{out}"
    );
}

#[tokio::test]
async fn completion_suggests_rule_names_in_rules_method_return() {
    let tmp = tempfile::tempdir().unwrap();
    write_minimal_laravel_project(tmp.path());
    let php = "<?php\nclass StoreUserRequest {\n    public function rules() {\n        return ['email' => 'requ\n    }\n}\n";
    std::fs::write(tmp.path().join("app.php"), php).unwrap();

    let mut s = TestServer::with_root(tmp.path()).await;
    s.wait_for_index_ready().await;
    s.open("app.php", php).await;

    // Line 3 (0-based), character 32 = right after "requ".
    let resp = s.completion("app.php", 3, 32).await;
    let out = render_completion(&resp);
    assert!(
        out.contains("Keyword     required"),
        "expected 'required' rule completion from a rules() method return, got:\n{out}"
    );
}

#[tokio::test]
async fn completion_does_not_offer_rule_names_while_typing_the_field_key() {
    let tmp = tempfile::tempdir().unwrap();
    write_minimal_laravel_project(tmp.path());
    // No `=>` yet — still typing the field name, not a rule value.
    let php = "<?php\nclass Controller {\n    public function store($request) {\n        $request->validate(['requ\n    }\n}\n";
    std::fs::write(tmp.path().join("app.php"), php).unwrap();

    let mut s = TestServer::with_root(tmp.path()).await;
    s.wait_for_index_ready().await;
    s.open("app.php", php).await;

    // Line 3 (0-based), character 33 = right after "requ".
    let resp = s.completion("app.php", 3, 33).await;
    let out = render_completion(&resp);
    assert!(
        !out.contains("Keyword     required"),
        "must not offer rule completions while typing the field key, got:\n{out}"
    );
}

#[tokio::test]
async fn completion_ignores_unrelated_array_literal() {
    let tmp = tempfile::tempdir().unwrap();
    write_minimal_laravel_project(tmp.path());
    let php = "<?php\nclass Controller {\n    public function store() {\n        $x = ['email' => 'requ\n    }\n}\n";
    std::fs::write(tmp.path().join("app.php"), php).unwrap();

    let mut s = TestServer::with_root(tmp.path()).await;
    s.wait_for_index_ready().await;
    s.open("app.php", php).await;

    // Line 3 (0-based), character 30 = right after "requ".
    let resp = s.completion("app.php", 3, 30).await;
    let out = render_completion(&resp);
    assert!(
        !out.contains("Keyword     required"),
        "a plain array unrelated to validate()/rules() must not get rule completions, got:\n{out}"
    );
}

#[tokio::test]
async fn not_offered_in_non_laravel_workspace() {
    let tmp = tempfile::tempdir().unwrap();
    // Deliberately no `artisan` — not a Laravel workspace.
    let php = "<?php\nclass Controller {\n    public function store($request) {\n        $request->validate(['email' => 'requ\n    }\n}\n";
    std::fs::write(tmp.path().join("app.php"), php).unwrap();

    let mut s = TestServer::with_root(tmp.path()).await;
    s.wait_for_index_ready().await;
    s.open("app.php", php).await;

    let resp = s.completion("app.php", 3, 44).await;
    let out = render_completion(&resp);
    assert!(
        !out.contains("Keyword     required"),
        "non-Laravel workspaces must never offer validation rule completions, got:\n{out}"
    );
}