lspf 0.5.2

A Rust framework for building extensible LSP language servers
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

//! Document Color server for CSS-style `#rgb` and `#rrggbb`.

mod example_support;

use std::sync::Arc;

use lspf::types::{
    Color, ColorInformation, ColorPresentation, ColorPresentationParams, ColorProviderOptions,
    DocumentColorParams, Position, Range,
};
use lspf::{CancellationToken, Context, LspError, Server};

struct State;

fn hex_value(chars: &str) -> Option<u32> {
    let expanded = if chars.len() == 3 {
        chars.chars().flat_map(|c| [c, c]).collect::<String>()
    } else {
        chars.to_string()
    };
    u32::from_str_radix(&expanded, 16).ok()
}

async fn document_colors(
    _: Arc<State>,
    ctx: Context,
    params: DocumentColorParams,
    _: CancellationToken,
) -> Result<Vec<ColorInformation>, LspError> {
    let text = example_support::text(&ctx, &params.text_document.uri)?;
    let mut colors = Vec::new();
    for (line_number, line) in text.lines().enumerate() {
        for (start, _) in line.match_indices('#') {
            let available = &line[start + 1..];
            let length = if available
                .get(..6)
                .is_some_and(|s| s.bytes().all(|b| b.is_ascii_hexdigit()))
                && available
                    .as_bytes()
                    .get(6)
                    .is_none_or(|b| !b.is_ascii_alphanumeric())
            {
                6
            } else if available
                .get(..3)
                .is_some_and(|s| s.bytes().all(|b| b.is_ascii_hexdigit()))
                && available
                    .as_bytes()
                    .get(3)
                    .is_none_or(|b| !b.is_ascii_alphanumeric())
            {
                3
            } else {
                continue;
            };
            let Some(value) = hex_value(&available[..length]) else {
                continue;
            };
            colors.push(ColorInformation {
                range: Range::new(
                    Position::new(line_number as u32, start as u32),
                    Position::new(line_number as u32, (start + length + 1) as u32),
                ),
                color: Color {
                    red: ((value >> 16) & 0xff) as f32 / 255.0,
                    green: ((value >> 8) & 0xff) as f32 / 255.0,
                    blue: (value & 0xff) as f32 / 255.0,
                    alpha: 1.0,
                },
            });
        }
    }
    Ok(colors)
}

async fn color_presentation(
    _: Arc<State>,
    _: Context,
    params: ColorPresentationParams,
    _: CancellationToken,
) -> Result<Vec<ColorPresentation>, LspError> {
    let red = (params.color.red * 255.0) as u32;
    let green = (params.color.green * 255.0) as u32;
    let blue = (params.color.blue * 255.0) as u32;
    Ok(vec![ColorPresentation {
        label: format!("#{:06x}", (red << 16) | (green << 8) | blue),
        text_edit: None,
        additional_text_edits: None,
    }])
}

#[tokio::main]
async fn main() -> lspf::Result<()> {
    let server = Server::builder(State)
        .feature(
            lspf::features::document_color(ColorProviderOptions {}),
            document_colors,
        )
        .feature(lspf::features::color_presentation(), color_presentation)
        .build()
        .expect("color registrations are valid");
    example_support::serve(server).await
}