From 75d2e04a1dbb6a5ebc5f8e1beabf3a3fa40d78bf Mon Sep 17 00:00:00 2001 From: Marshall Bowers Date: Wed, 3 Jul 2024 17:04:08 -0400 Subject: [PATCH] assistant: Add `/docs` slash command (#13794) This PR adds a new `/docs` slash command to the Assistant. This slash command replaces `/rustdoc`. The `/docs` slash command works with different providers. There is currently a built-in provider for rustdoc, but new providers can be defined within extensions. The Gleam extension contains an example of this. When you first type `/docs` a completion menu will be shown with the list of available providers: https://github.com/zed-industries/zed/assets/1486634/32287000-5855-44d9-a2eb-569596f5abd9 After completing the provider you want to use then you can type the package name and/or item path to search for the relevant docs: https://github.com/zed-industries/zed/assets/1486634/6fc55a63-7fcd-42ea-80ce-08c670bf03fc There are still some rough edges around completions that I would like to get cleaned up in a future PR. Both of these seem to stem from the fact that we're using an intermediate completion in the slash command: 1. Accepting a provider completion will show an error until you press Space to continue typing. - We need a way of not submitting a slash command when a completion is accepted. 2. We currently need to show the provider name in the documentation item completion list. - Without it, the provider name gets wiped out when accepting a completion, causing the slash command to become invalid. Release Notes: - N/A --- crates/assistant/src/assistant.rs | 7 +- crates/assistant/src/assistant_panel.rs | 29 +- crates/assistant/src/slash_command.rs | 2 +- .../src/slash_command/docs_command.rs | 365 ++++++++++++++++++ .../src/slash_command/rustdoc_command.rs | 265 ------------- crates/indexed_docs/src/providers/rustdoc.rs | 10 - crates/indexed_docs/src/registry.rs | 8 + crates/indexed_docs/src/store.rs | 18 +- 8 files changed, 397 insertions(+), 307 deletions(-) create mode 100644 crates/assistant/src/slash_command/docs_command.rs delete mode 100644 crates/assistant/src/slash_command/rustdoc_command.rs diff --git a/crates/assistant/src/assistant.rs b/crates/assistant/src/assistant.rs index b938c31c09..e97afd2c8d 100644 --- a/crates/assistant/src/assistant.rs +++ b/crates/assistant/src/assistant.rs @@ -27,8 +27,9 @@ use semantic_index::{CloudEmbeddingProvider, SemanticIndex}; use serde::{Deserialize, Serialize}; use settings::{Settings, SettingsStore}; use slash_command::{ - active_command, default_command, diagnostics_command, fetch_command, file_command, now_command, - project_command, prompt_command, rustdoc_command, search_command, tabs_command, term_command, + active_command, default_command, diagnostics_command, docs_command, fetch_command, + file_command, now_command, project_command, prompt_command, search_command, tabs_command, + term_command, }; use std::{ fmt::{self, Display}, @@ -323,7 +324,7 @@ fn register_slash_commands(cx: &mut AppContext) { slash_command_registry.register_command(term_command::TermSlashCommand, true); slash_command_registry.register_command(now_command::NowSlashCommand, true); slash_command_registry.register_command(diagnostics_command::DiagnosticsCommand, true); - slash_command_registry.register_command(rustdoc_command::RustdocSlashCommand, false); + slash_command_registry.register_command(docs_command::DocsSlashCommand, true); slash_command_registry.register_command(fetch_command::FetchSlashCommand, false); } diff --git a/crates/assistant/src/assistant_panel.rs b/crates/assistant/src/assistant_panel.rs index 529c14b094..77a75feafe 100644 --- a/crates/assistant/src/assistant_panel.rs +++ b/crates/assistant/src/assistant_panel.rs @@ -1,3 +1,4 @@ +use crate::slash_command::docs_command::{DocsSlashCommand, DocsSlashCommandArgs}; use crate::{ assistant_settings::{AssistantDockPosition, AssistantSettings}, humanize_token_count, @@ -39,7 +40,7 @@ use gpui::{ Subscription, Task, Transformation, UpdateGlobal, View, ViewContext, VisualContext, WeakView, WindowContext, }; -use indexed_docs::{IndexedDocsStore, PackageName, ProviderId}; +use indexed_docs::IndexedDocsStore; use language::{ language_settings::SoftWrap, AnchorRangeExt as _, AutoindentMode, Buffer, LanguageRegistry, LspAdapterDelegate, OffsetRangeExt as _, Point, ToOffset as _, @@ -2695,8 +2696,8 @@ impl ContextEditor { // TODO: In the future we should investigate how we can expose // this as a hook on the `SlashCommand` trait so that we don't // need to special-case it here. - if command.name == "rustdoc" { - return render_rustdoc_slash_command_trailer( + if command.name == DocsSlashCommand::NAME { + return render_docs_slash_command_trailer( row, command.clone(), cx, @@ -3405,25 +3406,29 @@ fn render_pending_slash_command_gutter_decoration( icon.into_any_element() } -fn render_rustdoc_slash_command_trailer( +fn render_docs_slash_command_trailer( row: MultiBufferRow, command: PendingSlashCommand, cx: &mut WindowContext, ) -> AnyElement { - let Some(rustdoc_store) = IndexedDocsStore::try_global(ProviderId::rustdoc(), cx).ok() else { + let Some(argument) = command.argument else { return Empty.into_any(); }; - let Some((crate_name, _)) = command - .argument - .as_ref() - .and_then(|arg| arg.split_once(':')) + let args = DocsSlashCommandArgs::parse(&argument); + + let Some(store) = args + .provider() + .and_then(|provider| IndexedDocsStore::try_global(provider, cx).ok()) else { return Empty.into_any(); }; - let crate_name = PackageName::from(crate_name); - if !rustdoc_store.is_indexing(&crate_name) { + let Some(package) = args.package() else { + return Empty.into_any(); + }; + + if !store.is_indexing(&package) { return Empty.into_any(); } @@ -3434,7 +3439,7 @@ fn render_rustdoc_slash_command_trailer( Animation::new(Duration::from_secs(4)).repeat(), |icon, delta| icon.transform(Transformation::rotate(percentage(delta))), )) - .tooltip(move |cx| Tooltip::text(format!("Indexing {crate_name}…"), cx)) + .tooltip(move |cx| Tooltip::text(format!("Indexing {package}…"), cx)) .into_any_element() } diff --git a/crates/assistant/src/slash_command.rs b/crates/assistant/src/slash_command.rs index 5f20b08e98..37678e0fc6 100644 --- a/crates/assistant/src/slash_command.rs +++ b/crates/assistant/src/slash_command.rs @@ -20,12 +20,12 @@ use workspace::Workspace; pub mod active_command; pub mod default_command; pub mod diagnostics_command; +pub mod docs_command; pub mod fetch_command; pub mod file_command; pub mod now_command; pub mod project_command; pub mod prompt_command; -pub mod rustdoc_command; pub mod search_command; pub mod tabs_command; pub mod term_command; diff --git a/crates/assistant/src/slash_command/docs_command.rs b/crates/assistant/src/slash_command/docs_command.rs new file mode 100644 index 0000000000..c66e68bef1 --- /dev/null +++ b/crates/assistant/src/slash_command/docs_command.rs @@ -0,0 +1,365 @@ +use std::path::Path; +use std::sync::atomic::AtomicBool; +use std::sync::Arc; + +use anyhow::{anyhow, bail, Result}; +use assistant_slash_command::{SlashCommand, SlashCommandOutput, SlashCommandOutputSection}; +use gpui::{AppContext, Model, Task, WeakView}; +use indexed_docs::{ + IndexedDocsRegistry, IndexedDocsStore, LocalProvider, PackageName, ProviderId, RustdocIndexer, +}; +use language::LspAdapterDelegate; +use project::{Project, ProjectPath}; +use ui::prelude::*; +use util::{maybe, ResultExt}; +use workspace::Workspace; + +pub(crate) struct DocsSlashCommand; + +impl DocsSlashCommand { + pub const NAME: &'static str = "docs"; + + fn path_to_cargo_toml(project: Model, cx: &mut AppContext) -> Option> { + let worktree = project.read(cx).worktrees().next()?; + let worktree = worktree.read(cx); + let entry = worktree.entry_for_path("Cargo.toml")?; + let path = ProjectPath { + worktree_id: worktree.id(), + path: entry.path.clone(), + }; + Some(Arc::from( + project.read(cx).absolute_path(&path, cx)?.as_path(), + )) + } + + /// Ensures that the rustdoc provider is registered. + /// + /// Ideally we would do this sooner, but we need to wait until we're able to + /// access the workspace so we can read the project. + fn ensure_rustdoc_provider_is_registered( + &self, + workspace: Option>, + cx: &mut AppContext, + ) { + let indexed_docs_registry = IndexedDocsRegistry::global(cx); + if indexed_docs_registry + .get_provider_store(ProviderId::rustdoc()) + .is_none() + { + let index_provider_deps = maybe!({ + let workspace = workspace.ok_or_else(|| anyhow!("no workspace"))?; + let workspace = workspace + .upgrade() + .ok_or_else(|| anyhow!("workspace was dropped"))?; + let project = workspace.read(cx).project().clone(); + let fs = project.read(cx).fs().clone(); + let cargo_workspace_root = Self::path_to_cargo_toml(project, cx) + .and_then(|path| path.parent().map(|path| path.to_path_buf())) + .ok_or_else(|| anyhow!("no Cargo workspace root found"))?; + + anyhow::Ok((fs, cargo_workspace_root)) + }); + + if let Some((fs, cargo_workspace_root)) = index_provider_deps.log_err() { + indexed_docs_registry.register_provider(Box::new(RustdocIndexer::new(Box::new( + LocalProvider::new(fs, cargo_workspace_root), + )))); + } + } + } +} + +impl SlashCommand for DocsSlashCommand { + fn name(&self) -> String { + Self::NAME.into() + } + + fn description(&self) -> String { + "insert docs".into() + } + + fn menu_text(&self) -> String { + "Insert Documentation".into() + } + + fn requires_argument(&self) -> bool { + true + } + + fn complete_argument( + self: Arc, + query: String, + _cancel: Arc, + workspace: Option>, + cx: &mut AppContext, + ) -> Task>> { + self.ensure_rustdoc_provider_is_registered(workspace, cx); + + let indexed_docs_registry = IndexedDocsRegistry::global(cx); + let args = DocsSlashCommandArgs::parse(&query); + let store = args + .provider() + .ok_or_else(|| anyhow!("no docs provider specified")) + .and_then(|provider| IndexedDocsStore::try_global(provider, cx)); + cx.background_executor().spawn(async move { + /// HACK: Prefixes the completions with the provider ID so that it doesn't get deleted + /// when a completion is accepted. + /// + /// We will likely want to extend `complete_argument` with support for replacing just + /// a particular range of the argument when a completion is accepted. + fn prefix_with_provider(provider: ProviderId, items: Vec) -> Vec { + items + .into_iter() + .map(|item| format!("{provider} {item}")) + .collect() + } + + match args { + DocsSlashCommandArgs::NoProvider => { + let providers = indexed_docs_registry.list_providers(); + Ok(providers + .into_iter() + .map(|provider| provider.to_string()) + .collect()) + } + DocsSlashCommandArgs::SearchPackageDocs { + provider, + package, + index, + } => { + let store = store?; + + if index { + // We don't need to hold onto this task, as the `IndexedDocsStore` will hold it + // until it completes. + let _ = store.clone().index(package.as_str().into()); + } + + let items = store.search(package).await; + Ok(prefix_with_provider(provider, items)) + } + DocsSlashCommandArgs::SearchItemDocs { + provider, + item_path, + .. + } => { + let store = store?; + let items = store.search(item_path).await; + Ok(prefix_with_provider(provider, items)) + } + } + }) + } + + fn run( + self: Arc, + argument: Option<&str>, + _workspace: WeakView, + _delegate: Arc, + cx: &mut WindowContext, + ) -> Task> { + let Some(argument) = argument else { + return Task::ready(Err(anyhow!("missing argument"))); + }; + + let args = DocsSlashCommandArgs::parse(argument); + let text = cx.background_executor().spawn({ + let store = args + .provider() + .ok_or_else(|| anyhow!("no docs provider specified")) + .and_then(|provider| IndexedDocsStore::try_global(provider, cx)); + async move { + match args { + DocsSlashCommandArgs::NoProvider => bail!("no docs provider specified"), + DocsSlashCommandArgs::SearchPackageDocs { + provider, package, .. + } => { + let store = store?; + let item_docs = store.load(package.clone()).await?; + + anyhow::Ok((provider, package, item_docs.to_string())) + } + DocsSlashCommandArgs::SearchItemDocs { + provider, + item_path, + .. + } => { + let store = store?; + let item_docs = store.load(item_path.clone()).await?; + + anyhow::Ok((provider, item_path, item_docs.to_string())) + } + } + } + }); + + cx.foreground_executor().spawn(async move { + let (provider, path, text) = text.await?; + let range = 0..text.len(); + Ok(SlashCommandOutput { + text, + sections: vec![SlashCommandOutputSection { + range, + icon: IconName::FileRust, + label: format!("docs ({provider}): {path}",).into(), + }], + run_commands_in_text: false, + }) + }) + } +} + +fn is_item_path_delimiter(char: char) -> bool { + !char.is_alphanumeric() && char != '-' && char != '_' +} + +#[derive(Debug, PartialEq)] +pub(crate) enum DocsSlashCommandArgs { + NoProvider, + SearchPackageDocs { + provider: ProviderId, + package: String, + index: bool, + }, + SearchItemDocs { + provider: ProviderId, + package: String, + item_path: String, + }, +} + +impl DocsSlashCommandArgs { + pub fn parse(argument: &str) -> Self { + let Some((provider, argument)) = argument.split_once(' ') else { + return Self::NoProvider; + }; + + let provider = ProviderId(provider.into()); + + if let Some((package, rest)) = argument.split_once(is_item_path_delimiter) { + if rest.trim().is_empty() { + Self::SearchPackageDocs { + provider, + package: package.to_owned(), + index: true, + } + } else { + Self::SearchItemDocs { + provider, + package: package.to_owned(), + item_path: argument.to_owned(), + } + } + } else { + Self::SearchPackageDocs { + provider, + package: argument.to_owned(), + index: false, + } + } + } + + pub fn provider(&self) -> Option { + match self { + Self::NoProvider => None, + Self::SearchPackageDocs { provider, .. } | Self::SearchItemDocs { provider, .. } => { + Some(provider.clone()) + } + } + } + + pub fn package(&self) -> Option { + match self { + Self::NoProvider => None, + Self::SearchPackageDocs { package, .. } | Self::SearchItemDocs { package, .. } => { + Some(package.as_str().into()) + } + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_parse_docs_slash_command_args() { + assert_eq!( + DocsSlashCommandArgs::parse(""), + DocsSlashCommandArgs::NoProvider + ); + assert_eq!( + DocsSlashCommandArgs::parse("rustdoc"), + DocsSlashCommandArgs::NoProvider + ); + + assert_eq!( + DocsSlashCommandArgs::parse("rustdoc "), + DocsSlashCommandArgs::SearchPackageDocs { + provider: ProviderId("rustdoc".into()), + package: "".into(), + index: false + } + ); + assert_eq!( + DocsSlashCommandArgs::parse("gleam "), + DocsSlashCommandArgs::SearchPackageDocs { + provider: ProviderId("gleam".into()), + package: "".into(), + index: false + } + ); + + assert_eq!( + DocsSlashCommandArgs::parse("rustdoc gpui"), + DocsSlashCommandArgs::SearchPackageDocs { + provider: ProviderId("rustdoc".into()), + package: "gpui".into(), + index: false, + } + ); + assert_eq!( + DocsSlashCommandArgs::parse("gleam gleam_stdlib"), + DocsSlashCommandArgs::SearchPackageDocs { + provider: ProviderId("gleam".into()), + package: "gleam_stdlib".into(), + index: false + } + ); + + // Adding an item path delimiter indicates we can start indexing. + assert_eq!( + DocsSlashCommandArgs::parse("rustdoc gpui:"), + DocsSlashCommandArgs::SearchPackageDocs { + provider: ProviderId("rustdoc".into()), + package: "gpui".into(), + index: true, + } + ); + assert_eq!( + DocsSlashCommandArgs::parse("gleam gleam_stdlib/"), + DocsSlashCommandArgs::SearchPackageDocs { + provider: ProviderId("gleam".into()), + package: "gleam_stdlib".into(), + index: true + } + ); + + assert_eq!( + DocsSlashCommandArgs::parse("rustdoc gpui::foo::bar::Baz"), + DocsSlashCommandArgs::SearchItemDocs { + provider: ProviderId("rustdoc".into()), + package: "gpui".into(), + item_path: "gpui::foo::bar::Baz".into() + } + ); + assert_eq!( + DocsSlashCommandArgs::parse("gleam gleam_stdlib/gleam/int"), + DocsSlashCommandArgs::SearchItemDocs { + provider: ProviderId("gleam".into()), + package: "gleam_stdlib".into(), + item_path: "gleam_stdlib/gleam/int".into() + } + ); + } +} diff --git a/crates/assistant/src/slash_command/rustdoc_command.rs b/crates/assistant/src/slash_command/rustdoc_command.rs deleted file mode 100644 index 5f5c7fac84..0000000000 --- a/crates/assistant/src/slash_command/rustdoc_command.rs +++ /dev/null @@ -1,265 +0,0 @@ -use std::path::Path; -use std::sync::atomic::AtomicBool; -use std::sync::Arc; - -use anyhow::{anyhow, bail, Context, Result}; -use assistant_slash_command::{SlashCommand, SlashCommandOutput, SlashCommandOutputSection}; -use fs::Fs; -use futures::AsyncReadExt; -use gpui::{AppContext, Model, Task, WeakView}; -use http::{AsyncBody, HttpClient, HttpClientWithUrl}; -use indexed_docs::{ - convert_rustdoc_to_markdown, IndexedDocsRegistry, IndexedDocsStore, LocalProvider, PackageName, - ProviderId, RustdocIndexer, RustdocSource, -}; -use language::LspAdapterDelegate; -use project::{Project, ProjectPath}; -use ui::prelude::*; -use util::{maybe, ResultExt}; -use workspace::Workspace; - -pub(crate) struct RustdocSlashCommand; - -impl RustdocSlashCommand { - async fn build_message( - fs: Arc, - http_client: Arc, - crate_name: PackageName, - module_path: Vec, - path_to_cargo_toml: Option<&Path>, - ) -> Result<(RustdocSource, String)> { - let cargo_workspace_root = path_to_cargo_toml.and_then(|path| path.parent()); - if let Some(cargo_workspace_root) = cargo_workspace_root { - let mut local_cargo_doc_path = cargo_workspace_root.join("target/doc"); - local_cargo_doc_path.push(crate_name.as_ref()); - if !module_path.is_empty() { - local_cargo_doc_path.push(module_path.join("/")); - } - local_cargo_doc_path.push("index.html"); - - if let Ok(contents) = fs.load(&local_cargo_doc_path).await { - let (markdown, _items) = convert_rustdoc_to_markdown(contents.as_bytes())?; - - return Ok((RustdocSource::Local, markdown)); - } - } - - let version = "latest"; - let path = format!( - "{crate_name}/{version}/{crate_name}/{module_path}", - module_path = module_path.join("/") - ); - - let mut response = http_client - .get( - &format!("https://docs.rs/{path}"), - AsyncBody::default(), - true, - ) - .await?; - - let mut body = Vec::new(); - response - .body_mut() - .read_to_end(&mut body) - .await - .context("error reading docs.rs response body")?; - - if response.status().is_client_error() { - let text = String::from_utf8_lossy(body.as_slice()); - bail!( - "status error {}, response: {text:?}", - response.status().as_u16() - ); - } - - let (markdown, _items) = convert_rustdoc_to_markdown(&body[..])?; - - Ok((RustdocSource::DocsDotRs, markdown)) - } - - fn path_to_cargo_toml(project: Model, cx: &mut AppContext) -> Option> { - let worktree = project.read(cx).worktrees().next()?; - let worktree = worktree.read(cx); - let entry = worktree.entry_for_path("Cargo.toml")?; - let path = ProjectPath { - worktree_id: worktree.id(), - path: entry.path.clone(), - }; - Some(Arc::from( - project.read(cx).absolute_path(&path, cx)?.as_path(), - )) - } - - /// Ensures that the rustdoc provider is registered. - /// - /// Ideally we would do this sooner, but we need to wait until we're able to - /// access the workspace so we can read the project. - fn ensure_rustdoc_provider_is_registered( - &self, - workspace: Option>, - cx: &mut AppContext, - ) { - let indexed_docs_registry = IndexedDocsRegistry::global(cx); - if indexed_docs_registry - .get_provider_store(ProviderId::rustdoc()) - .is_none() - { - let index_provider_deps = maybe!({ - let workspace = workspace.ok_or_else(|| anyhow!("no workspace"))?; - let workspace = workspace - .upgrade() - .ok_or_else(|| anyhow!("workspace was dropped"))?; - let project = workspace.read(cx).project().clone(); - let fs = project.read(cx).fs().clone(); - let cargo_workspace_root = Self::path_to_cargo_toml(project, cx) - .and_then(|path| path.parent().map(|path| path.to_path_buf())) - .ok_or_else(|| anyhow!("no Cargo workspace root found"))?; - - anyhow::Ok((fs, cargo_workspace_root)) - }); - - if let Some((fs, cargo_workspace_root)) = index_provider_deps.log_err() { - indexed_docs_registry.register_provider(Box::new(RustdocIndexer::new(Box::new( - LocalProvider::new(fs, cargo_workspace_root), - )))); - } - } - } -} - -impl SlashCommand for RustdocSlashCommand { - fn name(&self) -> String { - "rustdoc".into() - } - - fn description(&self) -> String { - "insert Rust docs".into() - } - - fn menu_text(&self) -> String { - "Insert Rust Documentation".into() - } - - fn requires_argument(&self) -> bool { - true - } - - fn complete_argument( - self: Arc, - query: String, - _cancel: Arc, - workspace: Option>, - cx: &mut AppContext, - ) -> Task>> { - self.ensure_rustdoc_provider_is_registered(workspace, cx); - - let store = IndexedDocsStore::try_global(ProviderId::rustdoc(), cx); - cx.background_executor().spawn(async move { - let store = store?; - - if let Some((crate_name, rest)) = query.split_once(':') { - if rest.is_empty() { - // We don't need to hold onto this task, as the `IndexedDocsStore` will hold it - // until it completes. - let _ = store.clone().index(crate_name.into()); - } - } - - let items = store.search(query).await; - Ok(items) - }) - } - - fn run( - self: Arc, - argument: Option<&str>, - workspace: WeakView, - _delegate: Arc, - cx: &mut WindowContext, - ) -> Task> { - let Some(argument) = argument else { - return Task::ready(Err(anyhow!("missing crate name"))); - }; - let Some(workspace) = workspace.upgrade() else { - return Task::ready(Err(anyhow!("workspace was dropped"))); - }; - - let project = workspace.read(cx).project().clone(); - let fs = project.read(cx).fs().clone(); - let http_client = workspace.read(cx).client().http_client(); - let path_to_cargo_toml = Self::path_to_cargo_toml(project, cx); - - let mut path_components = argument.split("::"); - let crate_name = match path_components - .next() - .ok_or_else(|| anyhow!("missing crate name")) - { - Ok(crate_name) => PackageName::from(crate_name), - Err(err) => return Task::ready(Err(err)), - }; - let item_path = path_components.map(ToString::to_string).collect::>(); - - let text = cx.background_executor().spawn({ - let rustdoc_store = IndexedDocsStore::try_global(ProviderId::rustdoc(), cx); - let crate_name = crate_name.clone(); - let item_path = item_path.clone(); - async move { - let rustdoc_store = rustdoc_store?; - let item_docs = rustdoc_store - .load( - crate_name.clone(), - if item_path.is_empty() { - None - } else { - Some(item_path.join("::")) - }, - ) - .await; - - if let Ok(item_docs) = item_docs { - anyhow::Ok((RustdocSource::Index, item_docs.to_string())) - } else { - Self::build_message( - fs, - http_client, - crate_name, - item_path, - path_to_cargo_toml.as_deref(), - ) - .await - } - } - }); - - let module_path = if item_path.is_empty() { - None - } else { - Some(SharedString::from(item_path.join("::"))) - }; - cx.foreground_executor().spawn(async move { - let (source, text) = text.await?; - let range = 0..text.len(); - let crate_path = module_path - .map(|module_path| format!("{}::{}", crate_name, module_path)) - .unwrap_or_else(|| crate_name.to_string()); - Ok(SlashCommandOutput { - text, - sections: vec![SlashCommandOutputSection { - range, - icon: IconName::FileRust, - label: format!( - "rustdoc ({source}): {crate_path}", - source = match source { - RustdocSource::Index => "index", - RustdocSource::Local => "local", - RustdocSource::DocsDotRs => "docs.rs", - } - ) - .into(), - }], - run_commands_in_text: false, - }) - }) - } -} diff --git a/crates/indexed_docs/src/providers/rustdoc.rs b/crates/indexed_docs/src/providers/rustdoc.rs index 7dae48da3f..9b3038a2e5 100644 --- a/crates/indexed_docs/src/providers/rustdoc.rs +++ b/crates/indexed_docs/src/providers/rustdoc.rs @@ -16,16 +16,6 @@ use http::{AsyncBody, HttpClient, HttpClientWithUrl}; use crate::{IndexedDocsDatabase, IndexedDocsProvider, PackageName, ProviderId}; -#[derive(Debug, Clone, Copy)] -pub enum RustdocSource { - /// The docs were sourced from Zed's rustdoc index. - Index, - /// The docs were sourced from local `cargo doc` output. - Local, - /// The docs were sourced from `docs.rs`. - DocsDotRs, -} - #[derive(Debug)] struct RustdocItemWithHistory { pub item: RustdocItem, diff --git a/crates/indexed_docs/src/registry.rs b/crates/indexed_docs/src/registry.rs index e251b3c616..fa3425466c 100644 --- a/crates/indexed_docs/src/registry.rs +++ b/crates/indexed_docs/src/registry.rs @@ -34,6 +34,14 @@ impl IndexedDocsRegistry { } } + pub fn list_providers(&self) -> Vec { + self.stores_by_provider + .read() + .keys() + .cloned() + .collect::>() + } + pub fn register_provider( &self, provider: Box, diff --git a/crates/indexed_docs/src/store.rs b/crates/indexed_docs/src/store.rs index 5c53c128d8..438cd19b69 100644 --- a/crates/indexed_docs/src/store.rs +++ b/crates/indexed_docs/src/store.rs @@ -94,22 +94,12 @@ impl IndexedDocsStore { self.indexing_tasks_by_package.read().contains_key(package) } - pub async fn load( - &self, - package: PackageName, - item_path: Option, - ) -> Result { - let item_path = if let Some(item_path) = item_path { - format!("{package}::{item_path}") - } else { - package.to_string() - }; - + pub async fn load(&self, key: String) -> Result { self.database_future .clone() .await .map_err(|err| anyhow!(err))? - .load(item_path) + .load(key) .await } @@ -160,10 +150,6 @@ impl IndexedDocsStore { let executor = self.executor.clone(); let database_future = self.database_future.clone(); self.executor.spawn(async move { - if query.is_empty() { - return Vec::new(); - } - let Some(database) = database_future.await.map_err(|err| anyhow!(err)).log_err() else { return Vec::new(); };