1use anyhow::{anyhow, Result};
2use async_trait::async_trait;
3use futures::StreamExt;
4use gpui::AsyncAppContext;
5use language::{
6 language_settings::AllLanguageSettings, LanguageServerName, LspAdapter, LspAdapterDelegate,
7};
8use lsp::LanguageServerBinary;
9use node_runtime::NodeRuntime;
10use serde_json::Value;
11use settings::{Settings, SettingsLocation};
12use smol::fs;
13use std::{
14 any::Any,
15 ffi::OsString,
16 path::{Path, PathBuf},
17 sync::Arc,
18};
19use util::{maybe, ResultExt};
20
21const SERVER_PATH: &str = "node_modules/yaml-language-server/bin/yaml-language-server";
22
23fn server_binary_arguments(server_path: &Path) -> Vec<OsString> {
24 vec![server_path.into(), "--stdio".into()]
25}
26
27pub struct YamlLspAdapter {
28 node: Arc<dyn NodeRuntime>,
29}
30
31impl YamlLspAdapter {
32 pub fn new(node: Arc<dyn NodeRuntime>) -> Self {
33 YamlLspAdapter { node }
34 }
35}
36
37#[async_trait(?Send)]
38impl LspAdapter for YamlLspAdapter {
39 fn name(&self) -> LanguageServerName {
40 LanguageServerName("yaml-language-server".into())
41 }
42
43 async fn fetch_latest_server_version(
44 &self,
45 _: &dyn LspAdapterDelegate,
46 ) -> Result<Box<dyn 'static + Any + Send>> {
47 Ok(Box::new(
48 self.node
49 .npm_package_latest_version("yaml-language-server")
50 .await?,
51 ) as Box<_>)
52 }
53
54 async fn fetch_server_binary(
55 &self,
56 latest_version: Box<dyn 'static + Send + Any>,
57 container_dir: PathBuf,
58 _: &dyn LspAdapterDelegate,
59 ) -> Result<LanguageServerBinary> {
60 let latest_version = latest_version.downcast::<String>().unwrap();
61 let server_path = container_dir.join(SERVER_PATH);
62 let package_name = "yaml-language-server";
63
64 let should_install_language_server = self
65 .node
66 .should_install_npm_package(package_name, &server_path, &container_dir, &latest_version)
67 .await;
68
69 if should_install_language_server {
70 self.node
71 .npm_install_packages(&container_dir, &[(package_name, latest_version.as_str())])
72 .await?;
73 }
74
75 Ok(LanguageServerBinary {
76 path: self.node.binary_path().await?,
77 env: None,
78 arguments: server_binary_arguments(&server_path),
79 })
80 }
81
82 async fn cached_server_binary(
83 &self,
84 container_dir: PathBuf,
85 _: &dyn LspAdapterDelegate,
86 ) -> Option<LanguageServerBinary> {
87 get_cached_server_binary(container_dir, &*self.node).await
88 }
89
90 async fn installation_test_binary(
91 &self,
92 container_dir: PathBuf,
93 ) -> Option<LanguageServerBinary> {
94 get_cached_server_binary(container_dir, &*self.node).await
95 }
96
97 async fn workspace_configuration(
98 self: Arc<Self>,
99 delegate: &Arc<dyn LspAdapterDelegate>,
100 cx: &mut AsyncAppContext,
101 ) -> Result<Value> {
102 let location = SettingsLocation {
103 worktree_id: delegate.worktree_id() as usize,
104 path: delegate.worktree_root_path(),
105 };
106
107 let tab_size = cx.update(|cx| {
108 AllLanguageSettings::get(Some(location), cx)
109 .language(Some("YAML"))
110 .tab_size
111 })?;
112
113 Ok(serde_json::json!({
114 "yaml": {
115 "keyOrdering": false
116 },
117 "[yaml]": {
118 "editor.tabSize": tab_size
119 }
120 }))
121 }
122}
123
124async fn get_cached_server_binary(
125 container_dir: PathBuf,
126 node: &dyn NodeRuntime,
127) -> Option<LanguageServerBinary> {
128 maybe!(async {
129 let mut last_version_dir = None;
130 let mut entries = fs::read_dir(&container_dir).await?;
131 while let Some(entry) = entries.next().await {
132 let entry = entry?;
133 if entry.file_type().await?.is_dir() {
134 last_version_dir = Some(entry.path());
135 }
136 }
137 let last_version_dir = last_version_dir.ok_or_else(|| anyhow!("no cached binary"))?;
138 let server_path = last_version_dir.join(SERVER_PATH);
139 if server_path.exists() {
140 Ok(LanguageServerBinary {
141 path: node.binary_path().await?,
142 env: None,
143 arguments: server_binary_arguments(&server_path),
144 })
145 } else {
146 Err(anyhow!(
147 "missing executable in directory {:?}",
148 last_version_dir
149 ))
150 }
151 })
152 .await
153 .log_err()
154}