extensions: Add Ruff extension

Cargo.toml

@@ -137,6 +137,7 @@ members = [
     "extensions/php",
     "extensions/prisma",
     "extensions/purescript",
+    "extensions/ruff",
     "extensions/ruby",
     "extensions/snippets",
     "extensions/svelte",

extensions/ruff/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "zed_ruff"
+version = "0.0.1"
+edition = "2021"
+publish = false
+license = "Apache-2.0"
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/ruff.rs"
+crate-type = ["cdylib"]
+
+[dependencies]
+zed_extension_api = "0.0.6"

extensions/ruff/LICENSE-APACHE

@@ -0,0 +1 @@
+../../LICENSE-APACHE

extensions/ruff/extension.toml

@@ -0,0 +1,11 @@
+id = "ruff"
+name = "Ruff"
+description = "Support for Ruff, the Python linter and formatter"
+version = "0.0.1"
+schema_version = 1
+authors = []
+repository = "https://github.com/zed-industries/zed"
+
+[language_servers.ruff]
+name = "Ruff"
+languages = ["Python"]

extensions/ruff/src/ruff.rs

@@ -0,0 +1,122 @@
+use std::fs;
+use zed::LanguageServerId;
+use zed_extension_api::{self as zed, settings::LspSettings, Result};
+
+struct RuffExtension {
+    cached_binary_path: Option<String>,
+}
+
+impl RuffExtension {
+    fn language_server_binary_path(
+        &mut self,
+        language_server_id: &LanguageServerId,
+        worktree: &zed::Worktree,
+    ) -> Result<String> {
+        if let Some(path) = worktree.which("ruff") {
+            return Ok(path);
+        }
+
+        zed::set_language_server_installation_status(
+            &language_server_id,
+            &zed::LanguageServerInstallationStatus::CheckingForUpdate,
+        );
+        let release = zed::latest_github_release(
+            "astral-sh/ruff",
+            zed::GithubReleaseOptions {
+                require_assets: true,
+                pre_release: false,
+            },
+        )?;
+
+        let (platform, arch) = zed::current_platform();
+
+        let asset_stem = format!(
+            "ruff-{arch}-{os}",
+            arch = match arch {
+                zed::Architecture::Aarch64 => "aarch64",
+                zed::Architecture::X86 => "x86",
+                zed::Architecture::X8664 => "x86_64",
+            },
+            os = match platform {
+                zed::Os::Mac => "apple-darwin",
+                zed::Os::Linux => "unknown-linux-gnu",
+                zed::Os::Windows => "pc-windows-msvc",
+            }
+        );
+        let asset_name = format!(
+            "{asset_stem}.{suffix}",
+            suffix = match platform {
+                zed::Os::Windows => "zip",
+                _ => "tar.gz",
+            }
+        );
+
+        let asset = release
+            .assets
+            .iter()
+            .find(|asset| asset.name == asset_name)
+            .ok_or_else(|| format!("no asset found matching {:?}", asset_name))?;
+
+        let version_dir = format!("ruff-{}", release.version);
+        let binary_path = format!("{version_dir}/{asset_stem}/ruff");
+
+        if !fs::metadata(&binary_path).map_or(false, |stat| stat.is_file()) {
+            zed::set_language_server_installation_status(
+                &language_server_id,
+                &zed::LanguageServerInstallationStatus::Downloading,
+            );
+            let file_kind = match platform {
+                zed::Os::Windows => zed::DownloadedFileType::Zip,
+                _ => zed::DownloadedFileType::GzipTar,
+            };
+            zed::download_file(&asset.download_url, &version_dir, file_kind)
+                .map_err(|e| format!("failed to download file: {e}"))?;
+
+            let entries =
+                fs::read_dir(".").map_err(|e| format!("failed to list working directory {e}"))?;
+            for entry in entries {
+                let entry = entry.map_err(|e| format!("failed to load directory entry {e}"))?;
+                if entry.file_name().to_str() != Some(&version_dir) {
+                    fs::remove_dir_all(&entry.path()).ok();
+                }
+            }
+        }
+
+        self.cached_binary_path = Some(binary_path.clone());
+        Ok(binary_path)
+    }
+}
+
+impl zed::Extension for RuffExtension {
+    fn new() -> Self {
+        Self {
+            cached_binary_path: None,
+        }
+    }
+
+    fn language_server_command(
+        &mut self,
+        language_server_id: &LanguageServerId,
+        worktree: &zed::Worktree,
+    ) -> Result<zed::Command> {
+        Ok(zed::Command {
+            command: self.language_server_binary_path(language_server_id, worktree)?,
+            args: vec!["server".into(), "--preview".into()],
+            env: vec![],
+        })
+    }
+
+    fn language_server_workspace_configuration(
+        &mut self,
+        server_id: &LanguageServerId,
+        worktree: &zed_extension_api::Worktree,
+    ) -> Result<Option<zed_extension_api::serde_json::Value>> {
+        let settings = LspSettings::for_worktree(server_id.as_ref(), worktree)
+            .ok()
+            .and_then(|lsp_settings| lsp_settings.settings.clone())
+            .unwrap_or_default();
+        Ok(Some(settings))
+    }
+}
+
+zed::register_extension!(RuffExtension);