1use anyhow::{anyhow, Result};
2use async_trait::async_trait;
3use futures::StreamExt;
4use language::{LanguageServerName, LspAdapter, LspAdapterDelegate};
5use lsp::LanguageServerBinary;
6use node_runtime::NodeRuntime;
7use serde_json::json;
8use smol::fs;
9use std::{
10 any::Any,
11 ffi::OsString,
12 path::{Path, PathBuf},
13 sync::Arc,
14};
15use util::{maybe, ResultExt};
16
17const SERVER_PATH: &str =
18 "node_modules/vscode-langservers-extracted/bin/vscode-css-language-server";
19
20fn server_binary_arguments(server_path: &Path) -> Vec<OsString> {
21 vec![server_path.into(), "--stdio".into()]
22}
23
24pub struct CssLspAdapter {
25 node: Arc<dyn NodeRuntime>,
26}
27
28impl CssLspAdapter {
29 pub fn new(node: Arc<dyn NodeRuntime>) -> Self {
30 CssLspAdapter { node }
31 }
32}
33
34#[async_trait(?Send)]
35impl LspAdapter for CssLspAdapter {
36 fn name(&self) -> LanguageServerName {
37 LanguageServerName("vscode-css-language-server".into())
38 }
39
40 async fn fetch_latest_server_version(
41 &self,
42 _: &dyn LspAdapterDelegate,
43 ) -> Result<Box<dyn 'static + Any + Send>> {
44 Ok(Box::new(
45 self.node
46 .npm_package_latest_version("vscode-langservers-extracted")
47 .await?,
48 ) as Box<_>)
49 }
50
51 async fn fetch_server_binary(
52 &self,
53 latest_version: Box<dyn 'static + Send + Any>,
54 container_dir: PathBuf,
55 _: &dyn LspAdapterDelegate,
56 ) -> Result<LanguageServerBinary> {
57 let latest_version = latest_version.downcast::<String>().unwrap();
58 let server_path = container_dir.join(SERVER_PATH);
59 let package_name = "vscode-langservers-extracted";
60
61 let should_install_language_server = self
62 .node
63 .should_install_npm_package(package_name, &server_path, &container_dir, &latest_version)
64 .await;
65
66 if should_install_language_server {
67 self.node
68 .npm_install_packages(&container_dir, &[(package_name, latest_version.as_str())])
69 .await?;
70 }
71
72 Ok(LanguageServerBinary {
73 path: self.node.binary_path().await?,
74 env: None,
75 arguments: server_binary_arguments(&server_path),
76 })
77 }
78
79 async fn cached_server_binary(
80 &self,
81 container_dir: PathBuf,
82 _: &dyn LspAdapterDelegate,
83 ) -> Option<LanguageServerBinary> {
84 get_cached_server_binary(container_dir, &*self.node).await
85 }
86
87 async fn installation_test_binary(
88 &self,
89 container_dir: PathBuf,
90 ) -> Option<LanguageServerBinary> {
91 get_cached_server_binary(container_dir, &*self.node).await
92 }
93
94 async fn initialization_options(
95 self: Arc<Self>,
96 _: &Arc<dyn LspAdapterDelegate>,
97 ) -> Result<Option<serde_json::Value>> {
98 Ok(Some(json!({
99 "provideFormatter": true
100 })))
101 }
102}
103
104async fn get_cached_server_binary(
105 container_dir: PathBuf,
106 node: &dyn NodeRuntime,
107) -> Option<LanguageServerBinary> {
108 maybe!(async {
109 let mut last_version_dir = None;
110 let mut entries = fs::read_dir(&container_dir).await?;
111 while let Some(entry) = entries.next().await {
112 let entry = entry?;
113 if entry.file_type().await?.is_dir() {
114 last_version_dir = Some(entry.path());
115 }
116 }
117 let last_version_dir = last_version_dir.ok_or_else(|| anyhow!("no cached binary"))?;
118 let server_path = last_version_dir.join(SERVER_PATH);
119 if server_path.exists() {
120 Ok(LanguageServerBinary {
121 path: node.binary_path().await?,
122 env: None,
123 arguments: server_binary_arguments(&server_path),
124 })
125 } else {
126 Err(anyhow!(
127 "missing executable in directory {:?}",
128 last_version_dir
129 ))
130 }
131 })
132 .await
133 .log_err()
134}
135
136#[cfg(test)]
137mod tests {
138 use gpui::{Context, TestAppContext};
139 use text::BufferId;
140 use unindent::Unindent;
141
142 #[gpui::test]
143 async fn test_outline(cx: &mut TestAppContext) {
144 let language = crate::language("css", tree_sitter_css::language());
145
146 let text = r#"
147 /* Import statement */
148 @import './fonts.css';
149
150 /* multiline list of selectors with nesting */
151 .test-class,
152 div {
153 .nested-class {
154 color: red;
155 }
156 }
157
158 /* descendant selectors */
159 .test .descendant {}
160
161 /* pseudo */
162 .test:not(:hover) {}
163
164 /* media queries */
165 @media screen and (min-width: 3000px) {
166 .desktop-class {}
167 }
168 "#
169 .unindent();
170
171 let buffer = cx.new_model(|cx| {
172 language::Buffer::new(0, BufferId::new(cx.entity_id().as_u64()).unwrap(), text)
173 .with_language(language, cx)
174 });
175 let outline = buffer.update(cx, |buffer, _| buffer.snapshot().outline(None).unwrap());
176 assert_eq!(
177 outline
178 .items
179 .iter()
180 .map(|item| (item.text.as_str(), item.depth))
181 .collect::<Vec<_>>(),
182 &[
183 ("@import './fonts.css'", 0),
184 (".test-class, div", 0),
185 (".nested-class", 1),
186 (".test .descendant", 0),
187 (".test:not(:hover)", 0),
188 ("@media screen and (min-width: 3000px)", 0),
189 (".desktop-class", 1),
190 ]
191 );
192 }
193}