1use anyhow::{Context as _, Result};
2use async_trait::async_trait;
3use futures::StreamExt;
4use gpui::AsyncApp;
5use language::{LanguageToolchainStore, LspAdapter, LspAdapterDelegate};
6use lsp::{LanguageServerBinary, LanguageServerName};
7use node_runtime::NodeRuntime;
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 _: Arc<dyn LanguageToolchainStore>,
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(Self::PACKAGE_NAME, &server_path, &container_dir, &version)
107 .await;
108
109 if should_install_language_server {
110 None
111 } else {
112 Some(LanguageServerBinary {
113 path: self.node.binary_path().await.ok()?,
114 env: None,
115 arguments: server_binary_arguments(&server_path),
116 })
117 }
118 }
119
120 async fn cached_server_binary(
121 &self,
122 container_dir: PathBuf,
123 _: &dyn LspAdapterDelegate,
124 ) -> Option<LanguageServerBinary> {
125 get_cached_server_binary(container_dir, &self.node).await
126 }
127
128 async fn initialization_options(
129 self: Arc<Self>,
130 _: &dyn Fs,
131 _: &Arc<dyn LspAdapterDelegate>,
132 ) -> Result<Option<serde_json::Value>> {
133 Ok(Some(json!({
134 "provideFormatter": true
135 })))
136 }
137
138 async fn workspace_configuration(
139 self: Arc<Self>,
140 _: &dyn Fs,
141 delegate: &Arc<dyn LspAdapterDelegate>,
142 _: Arc<dyn LanguageToolchainStore>,
143 cx: &mut AsyncApp,
144 ) -> Result<serde_json::Value> {
145 let mut default_config = json!({
146 "css": {
147 "lint": {}
148 },
149 "less": {
150 "lint": {}
151 },
152 "scss": {
153 "lint": {}
154 }
155 });
156
157 let project_options = cx.update(|cx| {
158 language_server_settings(delegate.as_ref(), &self.name(), cx)
159 .and_then(|s| s.settings.clone())
160 })?;
161
162 if let Some(override_options) = project_options {
163 merge_json_value_into(override_options, &mut default_config);
164 }
165
166 Ok(default_config)
167 }
168}
169
170async fn get_cached_server_binary(
171 container_dir: PathBuf,
172 node: &NodeRuntime,
173) -> Option<LanguageServerBinary> {
174 maybe!(async {
175 let mut last_version_dir = None;
176 let mut entries = fs::read_dir(&container_dir).await?;
177 while let Some(entry) = entries.next().await {
178 let entry = entry?;
179 if entry.file_type().await?.is_dir() {
180 last_version_dir = Some(entry.path());
181 }
182 }
183 let last_version_dir = last_version_dir.context("no cached binary")?;
184 let server_path = last_version_dir.join(SERVER_PATH);
185 anyhow::ensure!(
186 server_path.exists(),
187 "missing executable in directory {last_version_dir:?}"
188 );
189 Ok(LanguageServerBinary {
190 path: node.binary_path().await?,
191 env: None,
192 arguments: server_binary_arguments(&server_path),
193 })
194 })
195 .await
196 .log_err()
197}
198
199#[cfg(test)]
200mod tests {
201 use gpui::{AppContext as _, TestAppContext};
202 use unindent::Unindent;
203
204 #[gpui::test]
205 async fn test_outline(cx: &mut TestAppContext) {
206 let language = crate::language("css", tree_sitter_css::LANGUAGE.into());
207
208 let text = r#"
209 /* Import statement */
210 @import './fonts.css';
211
212 /* multiline list of selectors with nesting */
213 .test-class,
214 div {
215 .nested-class {
216 color: red;
217 }
218 }
219
220 /* descendant selectors */
221 .test .descendant {}
222
223 /* pseudo */
224 .test:not(:hover) {}
225
226 /* media queries */
227 @media screen and (min-width: 3000px) {
228 .desktop-class {}
229 }
230 "#
231 .unindent();
232
233 let buffer = cx.new(|cx| language::Buffer::local(text, cx).with_language(language, cx));
234 let outline = buffer.read_with(cx, |buffer, _| buffer.snapshot().outline(None).unwrap());
235 assert_eq!(
236 outline
237 .items
238 .iter()
239 .map(|item| (item.text.as_str(), item.depth))
240 .collect::<Vec<_>>(),
241 &[
242 ("@import './fonts.css'", 0),
243 (".test-class, div", 0),
244 (".nested-class", 1),
245 (".test .descendant", 0),
246 (".test:not(:hover)", 0),
247 ("@media screen and (min-width: 3000px)", 0),
248 (".desktop-class", 1),
249 ]
250 );
251 }
252}