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 _: &AsyncApp,
65 ) -> Result<Box<dyn 'static + Any + Send>> {
66 Ok(Box::new(
67 self.node
68 .npm_package_latest_version("vscode-langservers-extracted")
69 .await?,
70 ) as Box<_>)
71 }
72
73 async fn fetch_server_binary(
74 &self,
75 latest_version: Box<dyn 'static + Send + Any>,
76 container_dir: PathBuf,
77 _: &dyn LspAdapterDelegate,
78 ) -> Result<LanguageServerBinary> {
79 let latest_version = latest_version.downcast::<String>().unwrap();
80 let server_path = container_dir.join(SERVER_PATH);
81
82 self.node
83 .npm_install_packages(
84 &container_dir,
85 &[(Self::PACKAGE_NAME, latest_version.as_str())],
86 )
87 .await?;
88
89 Ok(LanguageServerBinary {
90 path: self.node.binary_path().await?,
91 env: None,
92 arguments: server_binary_arguments(&server_path),
93 })
94 }
95
96 async fn check_if_version_installed(
97 &self,
98 version: &(dyn 'static + Send + Any),
99 container_dir: &PathBuf,
100 _: &dyn LspAdapterDelegate,
101 ) -> Option<LanguageServerBinary> {
102 let version = version.downcast_ref::<String>().unwrap();
103 let server_path = container_dir.join(SERVER_PATH);
104
105 let should_install_language_server = self
106 .node
107 .should_install_npm_package(
108 Self::PACKAGE_NAME,
109 &server_path,
110 container_dir,
111 VersionStrategy::Latest(version),
112 )
113 .await;
114
115 if should_install_language_server {
116 None
117 } else {
118 Some(LanguageServerBinary {
119 path: self.node.binary_path().await.ok()?,
120 env: None,
121 arguments: server_binary_arguments(&server_path),
122 })
123 }
124 }
125
126 async fn cached_server_binary(
127 &self,
128 container_dir: PathBuf,
129 _: &dyn LspAdapterDelegate,
130 ) -> Option<LanguageServerBinary> {
131 get_cached_server_binary(container_dir, &self.node).await
132 }
133
134 async fn initialization_options(
135 self: Arc<Self>,
136 _: &dyn Fs,
137 _: &Arc<dyn LspAdapterDelegate>,
138 ) -> Result<Option<serde_json::Value>> {
139 Ok(Some(json!({
140 "provideFormatter": true
141 })))
142 }
143
144 async fn workspace_configuration(
145 self: Arc<Self>,
146 _: &dyn Fs,
147 delegate: &Arc<dyn LspAdapterDelegate>,
148 _: Option<Toolchain>,
149 cx: &mut AsyncApp,
150 ) -> Result<serde_json::Value> {
151 let mut default_config = json!({
152 "css": {
153 "lint": {}
154 },
155 "less": {
156 "lint": {}
157 },
158 "scss": {
159 "lint": {}
160 }
161 });
162
163 let project_options = cx.update(|cx| {
164 language_server_settings(delegate.as_ref(), &self.name(), cx)
165 .and_then(|s| s.settings.clone())
166 })?;
167
168 if let Some(override_options) = project_options {
169 merge_json_value_into(override_options, &mut default_config);
170 }
171
172 Ok(default_config)
173 }
174}
175
176async fn get_cached_server_binary(
177 container_dir: PathBuf,
178 node: &NodeRuntime,
179) -> Option<LanguageServerBinary> {
180 maybe!(async {
181 let mut last_version_dir = None;
182 let mut entries = fs::read_dir(&container_dir).await?;
183 while let Some(entry) = entries.next().await {
184 let entry = entry?;
185 if entry.file_type().await?.is_dir() {
186 last_version_dir = Some(entry.path());
187 }
188 }
189 let last_version_dir = last_version_dir.context("no cached binary")?;
190 let server_path = last_version_dir.join(SERVER_PATH);
191 anyhow::ensure!(
192 server_path.exists(),
193 "missing executable in directory {last_version_dir:?}"
194 );
195 Ok(LanguageServerBinary {
196 path: node.binary_path().await?,
197 env: None,
198 arguments: server_binary_arguments(&server_path),
199 })
200 })
201 .await
202 .log_err()
203}
204
205#[cfg(test)]
206mod tests {
207 use gpui::{AppContext as _, TestAppContext};
208 use unindent::Unindent;
209
210 #[gpui::test]
211 async fn test_outline(cx: &mut TestAppContext) {
212 let language = crate::language("css", tree_sitter_css::LANGUAGE.into());
213
214 let text = r#"
215 /* Import statement */
216 @import './fonts.css';
217
218 /* multiline list of selectors with nesting */
219 .test-class,
220 div {
221 .nested-class {
222 color: red;
223 }
224 }
225
226 /* descendant selectors */
227 .test .descendant {}
228
229 /* pseudo */
230 .test:not(:hover) {}
231
232 /* media queries */
233 @media screen and (min-width: 3000px) {
234 .desktop-class {}
235 }
236 "#
237 .unindent();
238
239 let buffer = cx.new(|cx| language::Buffer::local(text, cx).with_language(language, cx));
240 let outline = buffer.read_with(cx, |buffer, _| buffer.snapshot().outline(None).unwrap());
241 assert_eq!(
242 outline
243 .items
244 .iter()
245 .map(|item| (item.text.as_str(), item.depth))
246 .collect::<Vec<_>>(),
247 &[
248 ("@import './fonts.css'", 0),
249 (".test-class, div", 0),
250 (".nested-class", 1),
251 (".test .descendant", 0),
252 (".test:not(:hover)", 0),
253 ("@media screen and (min-width: 3000px)", 0),
254 (".desktop-class", 1),
255 ]
256 );
257 }
258}