1use std::fs;
2use zed::LanguageServerId;
3use zed_extension_api::{self as zed, Result, settings::LspSettings};
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 = match platform {
93 zed::Os::Windows => format!("{version_dir}/ruff.exe"),
94 _ => format!("{version_dir}/{asset_stem}/ruff"),
95 };
96
97 if !fs::metadata(&binary_path).map_or(false, |stat| stat.is_file()) {
98 zed::set_language_server_installation_status(
99 language_server_id,
100 &zed::LanguageServerInstallationStatus::Downloading,
101 );
102 let file_kind = match platform {
103 zed::Os::Windows => zed::DownloadedFileType::Zip,
104 _ => zed::DownloadedFileType::GzipTar,
105 };
106 zed::download_file(&asset.download_url, &version_dir, file_kind)
107 .map_err(|e| format!("failed to download file: {e}"))?;
108
109 let entries: Vec<_> = fs::read_dir(".")
110 .map_err(|e| format!("failed to list working directory {e}"))?
111 .collect();
112 for entry in entries {
113 let entry = entry.map_err(|e| format!("failed to load directory entry {e}"))?;
114 if entry.file_name().to_str() != Some(&version_dir) {
115 fs::remove_dir_all(entry.path()).ok();
116 }
117 }
118 }
119
120 self.cached_binary_path = Some(binary_path.clone());
121 Ok(RuffBinary {
122 path: binary_path,
123 args: binary_args,
124 })
125 }
126}
127
128impl zed::Extension for RuffExtension {
129 fn new() -> Self {
130 Self {
131 cached_binary_path: None,
132 }
133 }
134
135 fn language_server_command(
136 &mut self,
137 language_server_id: &LanguageServerId,
138 worktree: &zed::Worktree,
139 ) -> Result<zed::Command> {
140 let ruff_binary = self.language_server_binary(language_server_id, worktree)?;
141 Ok(zed::Command {
142 command: ruff_binary.path,
143 args: ruff_binary.args.unwrap_or_else(|| vec!["server".into()]),
144 env: vec![],
145 })
146 }
147
148 fn language_server_initialization_options(
149 &mut self,
150 server_id: &LanguageServerId,
151 worktree: &zed_extension_api::Worktree,
152 ) -> Result<Option<zed_extension_api::serde_json::Value>> {
153 let settings = LspSettings::for_worktree(server_id.as_ref(), worktree)
154 .ok()
155 .and_then(|lsp_settings| lsp_settings.initialization_options.clone())
156 .unwrap_or_default();
157 Ok(Some(settings))
158 }
159
160 fn language_server_workspace_configuration(
161 &mut self,
162 server_id: &LanguageServerId,
163 worktree: &zed_extension_api::Worktree,
164 ) -> Result<Option<zed_extension_api::serde_json::Value>> {
165 let settings = LspSettings::for_worktree(server_id.as_ref(), worktree)
166 .ok()
167 .and_then(|lsp_settings| lsp_settings.settings.clone())
168 .unwrap_or_default();
169 Ok(Some(settings))
170 }
171}
172
173zed::register_extension!(RuffExtension);