Remove ruby debug adapter (#33541)

Now that the extension version has been bumped we can remove our in-tree
one to avoid having duplicate debug adapters.

Release Notes:

- The ruby debug adapter has been moved to the [ruby
extension](https://github.com/zed-extensions/ruby), if you have any
saved debug scenarios you'll need to change `"adapter": "Ruby"` to
`"adapter": "rdbg"`.

crates/dap_adapters/src/dap_adapters.rs

@@ -4,7 +4,6 @@ mod go;
 mod javascript;
 mod php;
 mod python;
-mod ruby;
 
 use std::sync::Arc;
 
@@ -25,7 +24,6 @@ use gpui::{App, BorrowAppContext};
 use javascript::JsDebugAdapter;
 use php::PhpDebugAdapter;
 use python::PythonDebugAdapter;
-use ruby::RubyDebugAdapter;
 use serde_json::json;
 use task::{DebugScenario, ZedDebugConfig};
 
@@ -35,7 +33,6 @@ pub fn init(cx: &mut App) {
         registry.add_adapter(Arc::from(PythonDebugAdapter::default()));
         registry.add_adapter(Arc::from(PhpDebugAdapter::default()));
         registry.add_adapter(Arc::from(JsDebugAdapter::default()));
-        registry.add_adapter(Arc::from(RubyDebugAdapter));
         registry.add_adapter(Arc::from(GoDebugAdapter::default()));
         registry.add_adapter(Arc::from(GdbDebugAdapter));
 

crates/dap_adapters/src/ruby.rs

@@ -1,208 +0,0 @@
-use anyhow::{Result, bail};
-use async_trait::async_trait;
-use collections::FxHashMap;
-use dap::{
-    DebugRequest, StartDebuggingRequestArguments, StartDebuggingRequestArgumentsRequest,
-    adapters::{
-        DapDelegate, DebugAdapter, DebugAdapterBinary, DebugAdapterName, DebugTaskDefinition,
-    },
-};
-use gpui::{AsyncApp, SharedString};
-use language::LanguageName;
-use serde::{Deserialize, Serialize};
-use serde_json::json;
-use std::path::PathBuf;
-use std::{ffi::OsStr, sync::Arc};
-use task::{DebugScenario, ZedDebugConfig};
-use util::command::new_smol_command;
-
-#[derive(Default)]
-pub(crate) struct RubyDebugAdapter;
-
-impl RubyDebugAdapter {
-    const ADAPTER_NAME: &'static str = "Ruby";
-}
-
-#[derive(Serialize, Deserialize)]
-struct RubyDebugConfig {
-    script_or_command: Option<String>,
-    script: Option<String>,
-    command: Option<String>,
-    #[serde(default)]
-    args: Vec<String>,
-    #[serde(default)]
-    env: FxHashMap<String, String>,
-    cwd: Option<PathBuf>,
-}
-
-#[async_trait(?Send)]
-impl DebugAdapter for RubyDebugAdapter {
-    fn name(&self) -> DebugAdapterName {
-        DebugAdapterName(Self::ADAPTER_NAME.into())
-    }
-
-    fn adapter_language_name(&self) -> Option<LanguageName> {
-        Some(SharedString::new_static("Ruby").into())
-    }
-
-    async fn request_kind(
-        &self,
-        _: &serde_json::Value,
-    ) -> Result<StartDebuggingRequestArgumentsRequest> {
-        Ok(StartDebuggingRequestArgumentsRequest::Launch)
-    }
-
-    fn dap_schema(&self) -> serde_json::Value {
-        json!({
-            "type": "object",
-            "properties": {
-                "command": {
-                    "type": "string",
-                    "description": "Command name (ruby, rake, bin/rails, bundle exec ruby, etc)",
-                },
-                "script": {
-                    "type": "string",
-                    "description": "Absolute path to a Ruby file."
-                },
-                "cwd": {
-                    "type": "string",
-                    "description": "Directory to execute the program in",
-                    "default": "${ZED_WORKTREE_ROOT}"
-                },
-                "args": {
-                    "type": "array",
-                    "description": "Command line arguments passed to the program",
-                    "items": {
-                        "type": "string"
-                    },
-                    "default": []
-                },
-                "env": {
-                    "type": "object",
-                    "description": "Additional environment variables to pass to the debugging (and debugged) process",
-                    "default": {}
-                },
-            }
-        })
-    }
-
-    async fn config_from_zed_format(&self, zed_scenario: ZedDebugConfig) -> Result<DebugScenario> {
-        match zed_scenario.request {
-            DebugRequest::Launch(launch) => {
-                let config = RubyDebugConfig {
-                    script_or_command: Some(launch.program),
-                    script: None,
-                    command: None,
-                    args: launch.args,
-                    env: launch.env,
-                    cwd: launch.cwd.clone(),
-                };
-
-                let config = serde_json::to_value(config)?;
-
-                Ok(DebugScenario {
-                    adapter: zed_scenario.adapter,
-                    label: zed_scenario.label,
-                    config,
-                    tcp_connection: None,
-                    build: None,
-                })
-            }
-            DebugRequest::Attach(_) => {
-                anyhow::bail!("Attach requests are unsupported");
-            }
-        }
-    }
-
-    async fn get_binary(
-        &self,
-        delegate: &Arc<dyn DapDelegate>,
-        definition: &DebugTaskDefinition,
-        _user_installed_path: Option<PathBuf>,
-        _user_args: Option<Vec<String>>,
-        _cx: &mut AsyncApp,
-    ) -> Result<DebugAdapterBinary> {
-        let adapter_path = paths::debug_adapters_dir().join(self.name().as_ref());
-        let mut rdbg_path = adapter_path.join("rdbg");
-        if !delegate.fs().is_file(&rdbg_path).await {
-            match delegate.which("rdbg".as_ref()).await {
-                Some(path) => rdbg_path = path,
-                None => {
-                    delegate.output_to_console(
-                        "rdbg not found on path, trying `gem install debug`".to_string(),
-                    );
-                    let output = new_smol_command("gem")
-                        .arg("install")
-                        .arg("--no-document")
-                        .arg("--bindir")
-                        .arg(adapter_path)
-                        .arg("debug")
-                        .output()
-                        .await?;
-                    anyhow::ensure!(
-                        output.status.success(),
-                        "Failed to install rdbg:\n{}",
-                        String::from_utf8_lossy(&output.stderr).to_string()
-                    );
-                }
-            }
-        }
-
-        let tcp_connection = definition.tcp_connection.clone().unwrap_or_default();
-        let (host, port, timeout) = crate::configure_tcp_connection(tcp_connection).await?;
-        let ruby_config = serde_json::from_value::<RubyDebugConfig>(definition.config.clone())?;
-
-        let mut arguments = vec![
-            "--open".to_string(),
-            format!("--port={}", port),
-            format!("--host={}", host),
-        ];
-
-        if let Some(script) = &ruby_config.script {
-            arguments.push(script.clone());
-        } else if let Some(command) = &ruby_config.command {
-            arguments.push("--command".to_string());
-            arguments.push(command.clone());
-        } else if let Some(command_or_script) = &ruby_config.script_or_command {
-            if delegate
-                .which(OsStr::new(&command_or_script))
-                .await
-                .is_some()
-            {
-                arguments.push("--command".to_string());
-            }
-            arguments.push(command_or_script.clone());
-        } else {
-            bail!("Ruby debug config must have 'script' or 'command' args");
-        }
-
-        arguments.extend(ruby_config.args);
-
-        let mut configuration = definition.config.clone();
-        if let Some(configuration) = configuration.as_object_mut() {
-            configuration
-                .entry("cwd")
-                .or_insert_with(|| delegate.worktree_root_path().to_string_lossy().into());
-        }
-
-        Ok(DebugAdapterBinary {
-            command: Some(rdbg_path.to_string_lossy().to_string()),
-            arguments,
-            connection: Some(dap::adapters::TcpArguments {
-                host,
-                port,
-                timeout,
-            }),
-            cwd: Some(
-                ruby_config
-                    .cwd
-                    .unwrap_or(delegate.worktree_root_path().to_owned()),
-            ),
-            envs: ruby_config.env.into_iter().collect(),
-            request_args: StartDebuggingRequestArguments {
-                request: self.request_kind(&definition.config).await?,
-                configuration,
-            },
-        })
-    }
-}

crates/debugger_ui/src/tests/new_process_modal.rs

@@ -267,7 +267,6 @@ async fn test_dap_adapter_config_conversion_and_validation(cx: &mut TestAppConte
         "Debugpy",
         "PHP",
         "JavaScript",
-        "Ruby",
         "Delve",
         "GDB",
         "fake-adapter",

crates/task/src/vscode_debug_format.rs

@@ -93,7 +93,7 @@ fn task_type_to_adapter_name(task_type: &str) -> String {
         "php" => "PHP",
         "cppdbg" | "lldb" => "CodeLLDB",
         "debugpy" => "Debugpy",
-        "rdbg" => "Ruby",
+        "rdbg" => "rdbg",
         _ => task_type,
     }
     .to_owned()