1use anyhow::{Context as _, Result};
2use async_trait::async_trait;
3use futures::StreamExt;
4use gpui::AsyncApp;
5use language::{LspAdapter, LspAdapterDelegate, Toolchain};
6use lsp::{LanguageServerBinary, LanguageServerName};
7use node_runtime::{NodeRuntime, VersionStrategy};
8use project::{Fs, lsp_store::language_server_settings};
9use serde_json::json;
10use smol::fs;
11use std::{
12 any::Any,
13 ffi::OsString,
14 path::{Path, PathBuf},
15 sync::Arc,
16};
17use util::{ResultExt, maybe, merge_json_value_into};
18
19const SERVER_PATH: &str =
20 "node_modules/vscode-langservers-extracted/bin/vscode-css-language-server";
21
22fn server_binary_arguments(server_path: &Path) -> Vec<OsString> {
23 vec![server_path.into(), "--stdio".into()]
24}
25
26pub struct CssLspAdapter {
27 node: NodeRuntime,
28}
29
30impl CssLspAdapter {
31 const PACKAGE_NAME: &str = "vscode-langservers-extracted";
32 pub fn new(node: NodeRuntime) -> Self {
33 CssLspAdapter { node }
34 }
35}
36
37#[async_trait(?Send)]
38impl LspAdapter for CssLspAdapter {
39 fn name(&self) -> LanguageServerName {
40 LanguageServerName("vscode-css-language-server".into())
41 }
42
43 async fn check_if_user_installed(
44 &self,
45 delegate: &dyn LspAdapterDelegate,
46 _: Option<Toolchain>,
47 _: &AsyncApp,
48 ) -> Option<LanguageServerBinary> {
49 let path = delegate
50 .which("vscode-css-language-server".as_ref())
51 .await?;
52 let env = delegate.shell_env().await;
53
54 Some(LanguageServerBinary {
55 path,
56 env: Some(env),
57 arguments: vec!["--stdio".into()],
58 })
59 }
60
61 async fn fetch_latest_server_version(
62 &self,
63 _: &dyn LspAdapterDelegate,
64 ) -> Result<Box<dyn 'static + Any + Send>> {
65 Ok(Box::new(
66 self.node
67 .npm_package_latest_version("vscode-langservers-extracted")
68 .await?,
69 ) as Box<_>)
70 }
71
72 async fn fetch_server_binary(
73 &self,
74 latest_version: Box<dyn 'static + Send + Any>,
75 container_dir: PathBuf,
76 _: &dyn LspAdapterDelegate,
77 ) -> Result<LanguageServerBinary> {
78 let latest_version = latest_version.downcast::<String>().unwrap();
79 let server_path = container_dir.join(SERVER_PATH);
80
81 self.node
82 .npm_install_packages(
83 &container_dir,
84 &[(Self::PACKAGE_NAME, latest_version.as_str())],
85 )
86 .await?;
87
88 Ok(LanguageServerBinary {
89 path: self.node.binary_path().await?,
90 env: None,
91 arguments: server_binary_arguments(&server_path),
92 })
93 }
94
95 async fn check_if_version_installed(
96 &self,
97 version: &(dyn 'static + Send + Any),
98 container_dir: &PathBuf,
99 _: &dyn LspAdapterDelegate,
100 ) -> Option<LanguageServerBinary> {
101 let version = version.downcast_ref::<String>().unwrap();
102 let server_path = container_dir.join(SERVER_PATH);
103
104 let should_install_language_server = self
105 .node
106 .should_install_npm_package(
107 Self::PACKAGE_NAME,
108 &server_path,
109 container_dir,
110 VersionStrategy::Latest(version),
111 )
112 .await;
113
114 if should_install_language_server {
115 None
116 } else {
117 Some(LanguageServerBinary {
118 path: self.node.binary_path().await.ok()?,
119 env: None,
120 arguments: server_binary_arguments(&server_path),
121 })
122 }
123 }
124
125 async fn cached_server_binary(
126 &self,
127 container_dir: PathBuf,
128 _: &dyn LspAdapterDelegate,
129 ) -> Option<LanguageServerBinary> {
130 get_cached_server_binary(container_dir, &self.node).await
131 }
132
133 async fn initialization_options(
134 self: Arc<Self>,
135 _: &dyn Fs,
136 _: &Arc<dyn LspAdapterDelegate>,
137 ) -> Result<Option<serde_json::Value>> {
138 Ok(Some(json!({
139 "provideFormatter": true
140 })))
141 }
142
143 async fn workspace_configuration(
144 self: Arc<Self>,
145 _: &dyn Fs,
146 delegate: &Arc<dyn LspAdapterDelegate>,
147 _: Option<Toolchain>,
148 cx: &mut AsyncApp,
149 ) -> Result<serde_json::Value> {
150 let mut default_config = json!({
151 "css": {
152 "lint": {}
153 },
154 "less": {
155 "lint": {}
156 },
157 "scss": {
158 "lint": {}
159 }
160 });
161
162 let project_options = cx.update(|cx| {
163 language_server_settings(delegate.as_ref(), &self.name(), cx)
164 .and_then(|s| s.settings.clone())
165 })?;
166
167 if let Some(override_options) = project_options {
168 merge_json_value_into(override_options, &mut default_config);
169 }
170
171 Ok(default_config)
172 }
173}
174
175async fn get_cached_server_binary(
176 container_dir: PathBuf,
177 node: &NodeRuntime,
178) -> Option<LanguageServerBinary> {
179 maybe!(async {
180 let mut last_version_dir = None;
181 let mut entries = fs::read_dir(&container_dir).await?;
182 while let Some(entry) = entries.next().await {
183 let entry = entry?;
184 if entry.file_type().await?.is_dir() {
185 last_version_dir = Some(entry.path());
186 }
187 }
188 let last_version_dir = last_version_dir.context("no cached binary")?;
189 let server_path = last_version_dir.join(SERVER_PATH);
190 anyhow::ensure!(
191 server_path.exists(),
192 "missing executable in directory {last_version_dir:?}"
193 );
194 Ok(LanguageServerBinary {
195 path: node.binary_path().await?,
196 env: None,
197 arguments: server_binary_arguments(&server_path),
198 })
199 })
200 .await
201 .log_err()
202}
203
204#[cfg(test)]
205mod tests {
206 use gpui::{AppContext as _, TestAppContext};
207 use unindent::Unindent;
208
209 #[gpui::test]
210 async fn test_outline(cx: &mut TestAppContext) {
211 let language = crate::language("css", tree_sitter_css::LANGUAGE.into());
212
213 let text = r#"
214 /* Import statement */
215 @import './fonts.css';
216
217 /* multiline list of selectors with nesting */
218 .test-class,
219 div {
220 .nested-class {
221 color: red;
222 }
223 }
224
225 /* descendant selectors */
226 .test .descendant {}
227
228 /* pseudo */
229 .test:not(:hover) {}
230
231 /* media queries */
232 @media screen and (min-width: 3000px) {
233 .desktop-class {}
234 }
235 "#
236 .unindent();
237
238 let buffer = cx.new(|cx| language::Buffer::local(text, cx).with_language(language, cx));
239 let outline = buffer.read_with(cx, |buffer, _| buffer.snapshot().outline(None).unwrap());
240 assert_eq!(
241 outline
242 .items
243 .iter()
244 .map(|item| (item.text.as_str(), item.depth))
245 .collect::<Vec<_>>(),
246 &[
247 ("@import './fonts.css'", 0),
248 (".test-class, div", 0),
249 (".nested-class", 1),
250 (".test .descendant", 0),
251 (".test:not(:hover)", 0),
252 ("@media screen and (min-width: 3000px)", 0),
253 (".desktop-class", 1),
254 ]
255 );
256 }
257}