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::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 _: &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 delegate: &Arc<dyn LspAdapterDelegate>,
146 _: Option<Toolchain>,
147 cx: &mut AsyncApp,
148 ) -> Result<serde_json::Value> {
149 let mut default_config = json!({
150 "css": {
151 "lint": {}
152 },
153 "less": {
154 "lint": {}
155 },
156 "scss": {
157 "lint": {}
158 }
159 });
160
161 let project_options = cx.update(|cx| {
162 language_server_settings(delegate.as_ref(), &self.name(), cx)
163 .and_then(|s| s.settings.clone())
164 })?;
165
166 if let Some(override_options) = project_options {
167 merge_json_value_into(override_options, &mut default_config);
168 }
169
170 Ok(default_config)
171 }
172}
173
174async fn get_cached_server_binary(
175 container_dir: PathBuf,
176 node: &NodeRuntime,
177) -> Option<LanguageServerBinary> {
178 maybe!(async {
179 let mut last_version_dir = None;
180 let mut entries = fs::read_dir(&container_dir).await?;
181 while let Some(entry) = entries.next().await {
182 let entry = entry?;
183 if entry.file_type().await?.is_dir() {
184 last_version_dir = Some(entry.path());
185 }
186 }
187 let last_version_dir = last_version_dir.context("no cached binary")?;
188 let server_path = last_version_dir.join(SERVER_PATH);
189 anyhow::ensure!(
190 server_path.exists(),
191 "missing executable in directory {last_version_dir:?}"
192 );
193 Ok(LanguageServerBinary {
194 path: node.binary_path().await?,
195 env: None,
196 arguments: server_binary_arguments(&server_path),
197 })
198 })
199 .await
200 .log_err()
201}
202
203#[cfg(test)]
204mod tests {
205 use gpui::{AppContext as _, TestAppContext};
206 use unindent::Unindent;
207
208 #[gpui::test]
209 async fn test_outline(cx: &mut TestAppContext) {
210 let language = crate::language("css", tree_sitter_css::LANGUAGE.into());
211
212 let text = r#"
213 /* Import statement */
214 @import './fonts.css';
215
216 /* multiline list of selectors with nesting */
217 .test-class,
218 div {
219 .nested-class {
220 color: red;
221 }
222 }
223
224 /* descendant selectors */
225 .test .descendant {}
226
227 /* pseudo */
228 .test:not(:hover) {}
229
230 /* media queries */
231 @media screen and (min-width: 3000px) {
232 .desktop-class {}
233 }
234 "#
235 .unindent();
236
237 let buffer = cx.new(|cx| language::Buffer::local(text, cx).with_language(language, cx));
238 let outline = buffer.read_with(cx, |buffer, _| buffer.snapshot().outline(None));
239 assert_eq!(
240 outline
241 .items
242 .iter()
243 .map(|item| (item.text.as_str(), item.depth))
244 .collect::<Vec<_>>(),
245 &[
246 ("@import './fonts.css'", 0),
247 (".test-class, div", 0),
248 (".nested-class", 1),
249 (".test .descendant", 0),
250 (".test:not(:hover)", 0),
251 ("@media screen and (min-width: 3000px)", 0),
252 (".desktop-class", 1),
253 ]
254 );
255 }
256}