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 version: Box<dyn 'static + Send + Any>,
54 container_dir: PathBuf,
55 _: &dyn LspAdapterDelegate,
56 ) -> Result<LanguageServerBinary> {
57 let version = version.downcast::<String>().unwrap();
58 let server_path = container_dir.join(SERVER_PATH);
59
60 if fs::metadata(&server_path).await.is_err() {
61 self.node
62 .npm_install_packages(
63 &container_dir,
64 &[("vscode-langservers-extracted", version.as_str())],
65 )
66 .await?;
67 }
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 cached_server_binary(
77 &self,
78 container_dir: PathBuf,
79 _: &dyn LspAdapterDelegate,
80 ) -> Option<LanguageServerBinary> {
81 get_cached_server_binary(container_dir, &*self.node).await
82 }
83
84 async fn installation_test_binary(
85 &self,
86 container_dir: PathBuf,
87 ) -> Option<LanguageServerBinary> {
88 get_cached_server_binary(container_dir, &*self.node).await
89 }
90
91 fn initialization_options(&self) -> Option<serde_json::Value> {
92 Some(json!({
93 "provideFormatter": true
94 }))
95 }
96}
97
98async fn get_cached_server_binary(
99 container_dir: PathBuf,
100 node: &dyn NodeRuntime,
101) -> Option<LanguageServerBinary> {
102 async_maybe!({
103 let mut last_version_dir = None;
104 let mut entries = fs::read_dir(&container_dir).await?;
105 while let Some(entry) = entries.next().await {
106 let entry = entry?;
107 if entry.file_type().await?.is_dir() {
108 last_version_dir = Some(entry.path());
109 }
110 }
111 let last_version_dir = last_version_dir.ok_or_else(|| anyhow!("no cached binary"))?;
112 let server_path = last_version_dir.join(SERVER_PATH);
113 if server_path.exists() {
114 Ok(LanguageServerBinary {
115 path: node.binary_path().await?,
116 env: None,
117 arguments: server_binary_arguments(&server_path),
118 })
119 } else {
120 Err(anyhow!(
121 "missing executable in directory {:?}",
122 last_version_dir
123 ))
124 }
125 })
126 .await
127 .log_err()
128}
129
130#[cfg(test)]
131mod tests {
132 use gpui::{Context, TestAppContext};
133 use text::BufferId;
134 use unindent::Unindent;
135
136 #[gpui::test]
137 async fn test_outline(cx: &mut TestAppContext) {
138 let language = crate::language("css", tree_sitter_css::language());
139
140 let text = r#"
141 /* Import statement */
142 @import './fonts.css';
143
144 /* multiline list of selectors with nesting */
145 .test-class,
146 div {
147 .nested-class {
148 color: red;
149 }
150 }
151
152 /* descendant selectors */
153 .test .descendant {}
154
155 /* pseudo */
156 .test:not(:hover) {}
157
158 /* media queries */
159 @media screen and (min-width: 3000px) {
160 .desktop-class {}
161 }
162 "#
163 .unindent();
164
165 let buffer = cx.new_model(|cx| {
166 language::Buffer::new(0, BufferId::new(cx.entity_id().as_u64()).unwrap(), text)
167 .with_language(language, cx)
168 });
169 let outline = buffer.update(cx, |buffer, _| buffer.snapshot().outline(None).unwrap());
170 assert_eq!(
171 outline
172 .items
173 .iter()
174 .map(|item| (item.text.as_str(), item.depth))
175 .collect::<Vec<_>>(),
176 &[
177 ("@import './fonts.css'", 0),
178 (".test-class, div", 0),
179 (".nested-class", 1),
180 (".test .descendant", 0),
181 (".test:not(:hover)", 0),
182 ("@media screen and (min-width: 3000px)", 0),
183 (".desktop-class", 1),
184 ]
185 );
186 }
187}