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