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