1use std::fs;
2use zed::LanguageServerId;
3use zed_extension_api::{self as zed, settings::LspSettings, Result};
4
5struct RuffBinary {
6 path: String,
7 args: Option<Vec<String>>,
8}
9
10struct RuffExtension {
11 cached_binary_path: Option<String>,
12}
13
14impl RuffExtension {
15 fn language_server_binary(
16 &mut self,
17 language_server_id: &LanguageServerId,
18 worktree: &zed::Worktree,
19 ) -> Result<RuffBinary> {
20 let binary_settings = LspSettings::for_worktree("ruff", worktree)
21 .ok()
22 .and_then(|lsp_settings| lsp_settings.binary);
23 let binary_args = binary_settings
24 .as_ref()
25 .and_then(|binary_settings| binary_settings.arguments.clone());
26
27 if let Some(path) = binary_settings.and_then(|binary_settings| binary_settings.path) {
28 return Ok(RuffBinary {
29 path,
30 args: binary_args,
31 });
32 }
33
34 if let Some(path) = worktree.which("ruff") {
35 return Ok(RuffBinary {
36 path,
37 args: binary_args,
38 });
39 }
40
41 if let Some(path) = &self.cached_binary_path {
42 if fs::metadata(path).map_or(false, |stat| stat.is_file()) {
43 return Ok(RuffBinary {
44 path: path.clone(),
45 args: binary_args,
46 });
47 }
48 }
49
50 zed::set_language_server_installation_status(
51 language_server_id,
52 &zed::LanguageServerInstallationStatus::CheckingForUpdate,
53 );
54 let release = zed::latest_github_release(
55 "astral-sh/ruff",
56 zed::GithubReleaseOptions {
57 require_assets: true,
58 pre_release: false,
59 },
60 )?;
61
62 let (platform, arch) = zed::current_platform();
63
64 let asset_stem = format!(
65 "ruff-{arch}-{os}",
66 arch = match arch {
67 zed::Architecture::Aarch64 => "aarch64",
68 zed::Architecture::X86 => "x86",
69 zed::Architecture::X8664 => "x86_64",
70 },
71 os = match platform {
72 zed::Os::Mac => "apple-darwin",
73 zed::Os::Linux => "unknown-linux-gnu",
74 zed::Os::Windows => "pc-windows-msvc",
75 }
76 );
77 let asset_name = format!(
78 "{asset_stem}.{suffix}",
79 suffix = match platform {
80 zed::Os::Windows => "zip",
81 _ => "tar.gz",
82 }
83 );
84
85 let asset = release
86 .assets
87 .iter()
88 .find(|asset| asset.name == asset_name)
89 .ok_or_else(|| format!("no asset found matching {:?}", asset_name))?;
90
91 let version_dir = format!("ruff-{}", release.version);
92 let binary_path = format!("{version_dir}/{asset_stem}/ruff");
93
94 if !fs::metadata(&binary_path).map_or(false, |stat| stat.is_file()) {
95 zed::set_language_server_installation_status(
96 language_server_id,
97 &zed::LanguageServerInstallationStatus::Downloading,
98 );
99 let file_kind = match platform {
100 zed::Os::Windows => zed::DownloadedFileType::Zip,
101 _ => zed::DownloadedFileType::GzipTar,
102 };
103 zed::download_file(&asset.download_url, &version_dir, file_kind)
104 .map_err(|e| format!("failed to download file: {e}"))?;
105
106 let entries =
107 fs::read_dir(".").map_err(|e| format!("failed to list working directory {e}"))?;
108 for entry in entries {
109 let entry = entry.map_err(|e| format!("failed to load directory entry {e}"))?;
110 if entry.file_name().to_str() != Some(&version_dir) {
111 fs::remove_dir_all(entry.path()).ok();
112 }
113 }
114 }
115
116 self.cached_binary_path = Some(binary_path.clone());
117 Ok(RuffBinary {
118 path: binary_path,
119 args: binary_args,
120 })
121 }
122}
123
124impl zed::Extension for RuffExtension {
125 fn new() -> Self {
126 Self {
127 cached_binary_path: None,
128 }
129 }
130
131 fn language_server_command(
132 &mut self,
133 language_server_id: &LanguageServerId,
134 worktree: &zed::Worktree,
135 ) -> Result<zed::Command> {
136 let ruff_binary = self.language_server_binary(language_server_id, worktree)?;
137 Ok(zed::Command {
138 command: ruff_binary.path,
139 args: ruff_binary.args.unwrap_or_else(|| vec!["server".into()]),
140 env: vec![],
141 })
142 }
143
144 fn language_server_initialization_options(
145 &mut self,
146 server_id: &LanguageServerId,
147 worktree: &zed_extension_api::Worktree,
148 ) -> Result<Option<zed_extension_api::serde_json::Value>> {
149 let settings = LspSettings::for_worktree(server_id.as_ref(), worktree)
150 .ok()
151 .and_then(|lsp_settings| lsp_settings.initialization_options.clone())
152 .unwrap_or_default();
153 Ok(Some(settings))
154 }
155
156 fn language_server_workspace_configuration(
157 &mut self,
158 server_id: &LanguageServerId,
159 worktree: &zed_extension_api::Worktree,
160 ) -> Result<Option<zed_extension_api::serde_json::Value>> {
161 let settings = LspSettings::for_worktree(server_id.as_ref(), worktree)
162 .ok()
163 .and_then(|lsp_settings| lsp_settings.settings.clone())
164 .unwrap_or_default();
165 Ok(Some(settings))
166 }
167}
168
169zed::register_extension!(RuffExtension);