cargo-lsp 0.0.7

LSP for Cargo.toml files
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

// These are all the prefixes that keys can have (non leaf)
// It's necessary because some of these don't have any known keys under, but
// still count for table completion (ex dependencies).
const TABLES: &[&str] = &[
    "package",
    "features",
    "dependencies",
    "dev-dependencies",
    "build-dependencies",
    "lints",
    "lints.clippy",
];

// These are the final keys including their full path (leaves)
const PROPS: &[&str] = &[
    "package.name",
    "package.version",
    "package.edition",
    "package.authors",
    "package.license",
    "package.description",
    "package.homepage",
    "package.repository",
    "package.documentation",
    "package.readme",
    "package.keywords",
    "package.categories",
    "lints.clippy.pedantic",
    "lints.clippy.pedantic.level",
    "lints.clippy.pedantic.priority",
];

pub fn tables(exclude: &[String]) -> Vec<String> {
    TABLES
        .iter()
        .filter(|s| !exclude.iter().any(|e| e == **s))
        .map(|s| format!("[{s}]"))
        .collect()
}

pub fn props(prefix: &str) -> Vec<String> {
    if prefix.is_empty() {
        return PROPS.iter().map(std::string::ToString::to_string).collect();
    }
    PROPS
        .iter()
        .filter_map(|s| s.strip_prefix(prefix))
        .filter_map(|s| s.strip_prefix('.'))
        .map(std::string::ToString::to_string)
        .collect()
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn test_all() {
        let p = props("");
        assert_eq!(p, PROPS);
    }

    #[test]
    fn test_unknown() {
        let p = props("ba");
        assert!(p.is_empty());
    }

    #[test]
    fn test_package() {
        let p = props("package");
        assert_eq!(
            p,
            &[
                "name",
                "version",
                "edition",
                "authors",
                "license",
                "description",
                "homepage",
                "repository",
                "documentation",
                "readme",
                "keywords",
                "categories",
            ]
        );
    }
    
    #[test]
    fn test_table_dots() {
        let p = props("lints.clippy");
        assert_eq!(p, &["pedantic", "pedantic.level", "pedantic.priority"]);
    }

    #[test]
    fn test_partial_dots() {
        let p = props("lints.clippy.pedantic");
        assert_eq!(p, &["level", "priority"]);
    }

    #[test]
    fn test_tables() {
        let t = tables(&[]);
        assert_eq!(
            t,
            TABLES.iter().map(|s| format!("[{s}]")).collect::<Vec<_>>()
        );
    }

    #[test]
    fn test_table_exclude() {
        let t = tables(&["package".to_string(), "dependencies".to_string()]);
        assert_eq!(
            t,
            &[
                "[features]",
                "[dev-dependencies]",
                "[build-dependencies]",
                "[lints]",
                "[lints.clippy]",
            ]
        );
    }
}