1mod hexdocs;
2
3use std::fs;
4use zed::lsp::CompletionKind;
5use zed::{
6 CodeLabel, CodeLabelSpan, HttpRequest, KeyValueStore, LanguageServerId, SlashCommand,
7 SlashCommandArgumentCompletion, SlashCommandOutput, SlashCommandOutputSection,
8};
9use zed_extension_api::{self as zed, Result};
10
11use crate::hexdocs::convert_hexdocs_to_markdown;
12
13struct GleamExtension {
14 cached_binary_path: Option<String>,
15}
16
17impl GleamExtension {
18 fn language_server_binary_path(
19 &mut self,
20 language_server_id: &LanguageServerId,
21 worktree: &zed::Worktree,
22 ) -> Result<String> {
23 if let Some(path) = worktree.which("gleam") {
24 return Ok(path);
25 }
26
27 if let Some(path) = &self.cached_binary_path {
28 if fs::metadata(path).map_or(false, |stat| stat.is_file()) {
29 return Ok(path.clone());
30 }
31 }
32
33 zed::set_language_server_installation_status(
34 &language_server_id,
35 &zed::LanguageServerInstallationStatus::CheckingForUpdate,
36 );
37 let release = zed::latest_github_release(
38 "gleam-lang/gleam",
39 zed::GithubReleaseOptions {
40 require_assets: true,
41 pre_release: false,
42 },
43 )?;
44
45 let (platform, arch) = zed::current_platform();
46 let asset_name = format!(
47 "gleam-{version}-{arch}-{os}.tar.gz",
48 version = release.version,
49 arch = match arch {
50 zed::Architecture::Aarch64 => "aarch64",
51 zed::Architecture::X86 => "x86",
52 zed::Architecture::X8664 => "x86_64",
53 },
54 os = match platform {
55 zed::Os::Mac => "apple-darwin",
56 zed::Os::Linux => "unknown-linux-musl",
57 zed::Os::Windows => "pc-windows-msvc",
58 },
59 );
60
61 let asset = release
62 .assets
63 .iter()
64 .find(|asset| asset.name == asset_name)
65 .ok_or_else(|| format!("no asset found matching {:?}", asset_name))?;
66
67 let version_dir = format!("gleam-{}", release.version);
68 let binary_path = format!("{version_dir}/gleam");
69
70 if !fs::metadata(&binary_path).map_or(false, |stat| stat.is_file()) {
71 zed::set_language_server_installation_status(
72 &language_server_id,
73 &zed::LanguageServerInstallationStatus::Downloading,
74 );
75
76 zed::download_file(
77 &asset.download_url,
78 &version_dir,
79 zed::DownloadedFileType::GzipTar,
80 )
81 .map_err(|e| format!("failed to download file: {e}"))?;
82
83 let entries =
84 fs::read_dir(".").map_err(|e| format!("failed to list working directory {e}"))?;
85 for entry in entries {
86 let entry = entry.map_err(|e| format!("failed to load directory entry {e}"))?;
87 if entry.file_name().to_str() != Some(&version_dir) {
88 fs::remove_dir_all(&entry.path()).ok();
89 }
90 }
91 }
92
93 self.cached_binary_path = Some(binary_path.clone());
94 Ok(binary_path)
95 }
96}
97
98impl zed::Extension for GleamExtension {
99 fn new() -> Self {
100 Self {
101 cached_binary_path: None,
102 }
103 }
104
105 fn language_server_command(
106 &mut self,
107 language_server_id: &LanguageServerId,
108 worktree: &zed::Worktree,
109 ) -> Result<zed::Command> {
110 Ok(zed::Command {
111 command: self.language_server_binary_path(language_server_id, worktree)?,
112 args: vec!["lsp".to_string()],
113 env: Default::default(),
114 })
115 }
116
117 fn label_for_completion(
118 &self,
119 _language_server_id: &LanguageServerId,
120 completion: zed::lsp::Completion,
121 ) -> Option<zed::CodeLabel> {
122 let name = &completion.label;
123 let ty = strip_newlines_from_detail(&completion.detail?);
124 let let_binding = "let a";
125 let colon = ": ";
126 let assignment = " = ";
127 let call = match completion.kind? {
128 CompletionKind::Function | CompletionKind::Constructor => "()",
129 _ => "",
130 };
131 let code = format!("{let_binding}{colon}{ty}{assignment}{name}{call}");
132
133 Some(CodeLabel {
134 spans: vec![
135 CodeLabelSpan::code_range({
136 let start = let_binding.len() + colon.len() + ty.len() + assignment.len();
137 start..start + name.len()
138 }),
139 CodeLabelSpan::code_range({
140 let start = let_binding.len();
141 start..start + colon.len()
142 }),
143 CodeLabelSpan::code_range({
144 let start = let_binding.len() + colon.len();
145 start..start + ty.len()
146 }),
147 ],
148 filter_range: (0..name.len()).into(),
149 code,
150 })
151 }
152
153 fn complete_slash_command_argument(
154 &self,
155 command: SlashCommand,
156 _query: String,
157 ) -> Result<Vec<SlashCommandArgumentCompletion>, String> {
158 match command.name.as_str() {
159 "gleam-project" => Ok(vec![
160 SlashCommandArgumentCompletion {
161 label: "apple".to_string(),
162 new_text: "Apple".to_string(),
163 run_command: false,
164 },
165 SlashCommandArgumentCompletion {
166 label: "banana".to_string(),
167 new_text: "Banana".to_string(),
168 run_command: false,
169 },
170 SlashCommandArgumentCompletion {
171 label: "cherry".to_string(),
172 new_text: "Cherry".to_string(),
173 run_command: true,
174 },
175 ]),
176 _ => Ok(Vec::new()),
177 }
178 }
179
180 fn run_slash_command(
181 &self,
182 command: SlashCommand,
183 argument: Option<String>,
184 worktree: &zed::Worktree,
185 ) -> Result<SlashCommandOutput, String> {
186 match command.name.as_str() {
187 "gleam-docs" => {
188 let argument = argument.ok_or_else(|| "missing argument".to_string())?;
189
190 let mut components = argument.split('/');
191 let package_name = components
192 .next()
193 .ok_or_else(|| "missing package name".to_string())?;
194 let module_path = components.map(ToString::to_string).collect::<Vec<_>>();
195
196 let response = zed::fetch(&HttpRequest {
197 url: format!(
198 "https://hexdocs.pm/{package_name}{maybe_path}",
199 maybe_path = if !module_path.is_empty() {
200 format!("/{}.html", module_path.join("/"))
201 } else {
202 String::new()
203 }
204 ),
205 })?;
206
207 let (markdown, _modules) = convert_hexdocs_to_markdown(response.body.as_bytes())?;
208
209 let mut text = String::new();
210 text.push_str(&markdown);
211
212 Ok(SlashCommandOutput {
213 sections: vec![SlashCommandOutputSection {
214 range: (0..text.len()).into(),
215 label: format!("gleam-docs: {package_name} {}", module_path.join("/")),
216 }],
217 text,
218 })
219 }
220 "gleam-project" => {
221 let mut text = String::new();
222 text.push_str("You are in a Gleam project.\n");
223
224 if let Some(gleam_toml) = worktree.read_text_file("gleam.toml").ok() {
225 text.push_str("The `gleam.toml` is as follows:\n");
226 text.push_str(&gleam_toml);
227 }
228
229 Ok(SlashCommandOutput {
230 sections: vec![SlashCommandOutputSection {
231 range: (0..text.len()).into(),
232 label: "gleam-project".to_string(),
233 }],
234 text,
235 })
236 }
237 command => Err(format!("unknown slash command: \"{command}\"")),
238 }
239 }
240
241 fn index_docs(
242 &self,
243 provider: String,
244 package: String,
245 database: &KeyValueStore,
246 ) -> Result<(), String> {
247 match provider.as_str() {
248 "gleam-hexdocs" => hexdocs::index(package, database),
249 _ => Ok(()),
250 }
251 }
252}
253
254zed::register_extension!(GleamExtension);
255
256/// Removes newlines from the completion detail.
257///
258/// The Gleam LSP can return types containing newlines, which causes formatting
259/// issues within the Zed completions menu.
260fn strip_newlines_from_detail(detail: &str) -> String {
261 let without_newlines = detail
262 .replace("->\n ", "-> ")
263 .replace("\n ", "")
264 .replace(",\n", "");
265
266 let comma_delimited_parts = without_newlines.split(',');
267 comma_delimited_parts
268 .map(|part| part.trim())
269 .collect::<Vec<_>>()
270 .join(", ")
271}
272
273#[cfg(test)]
274mod tests {
275 use crate::strip_newlines_from_detail;
276
277 #[test]
278 fn test_strip_newlines_from_detail() {
279 let detail = "fn(\n Selector(a),\n b,\n fn(Dynamic, Dynamic, Dynamic, Dynamic, Dynamic, Dynamic, Dynamic) -> a,\n) -> Selector(a)";
280 let expected = "fn(Selector(a), b, fn(Dynamic, Dynamic, Dynamic, Dynamic, Dynamic, Dynamic, Dynamic) -> a) -> Selector(a)";
281 assert_eq!(strip_newlines_from_detail(detail), expected);
282
283 let detail = "fn(Selector(a), b, fn(Dynamic, Dynamic, Dynamic, Dynamic, Dynamic, Dynamic) -> a) ->\n Selector(a)";
284 let expected = "fn(Selector(a), b, fn(Dynamic, Dynamic, Dynamic, Dynamic, Dynamic, Dynamic) -> a) -> Selector(a)";
285 assert_eq!(strip_newlines_from_detail(detail), expected);
286
287 let detail = "fn(\n Method,\n List(#(String, String)),\n a,\n Scheme,\n String,\n Option(Int),\n String,\n Option(String),\n) -> Request(a)";
288 let expected = "fn(Method, List(#(String, String)), a, Scheme, String, Option(Int), String, Option(String)) -> Request(a)";
289 assert_eq!(strip_newlines_from_detail(&detail), expected);
290 }
291}