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