Detailed changes
@@ -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);
}
@@ -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()
}
@@ -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;
@@ -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<Project>, cx: &mut AppContext) -> Option<Arc<Path>> {
+ 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<WeakView<Workspace>>,
+ 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<Self>,
+ query: String,
+ _cancel: Arc<AtomicBool>,
+ workspace: Option<WeakView<Workspace>>,
+ cx: &mut AppContext,
+ ) -> Task<Result<Vec<String>>> {
+ 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<String>) -> Vec<String> {
+ 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<Self>,
+ argument: Option<&str>,
+ _workspace: WeakView<Workspace>,
+ _delegate: Arc<dyn LspAdapterDelegate>,
+ cx: &mut WindowContext,
+ ) -> Task<Result<SlashCommandOutput>> {
+ 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<ProviderId> {
+ match self {
+ Self::NoProvider => None,
+ Self::SearchPackageDocs { provider, .. } | Self::SearchItemDocs { provider, .. } => {
+ Some(provider.clone())
+ }
+ }
+ }
+
+ pub fn package(&self) -> Option<PackageName> {
+ 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()
+ }
+ );
+ }
+}
@@ -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<dyn Fs>,
- http_client: Arc<HttpClientWithUrl>,
- crate_name: PackageName,
- module_path: Vec<String>,
- 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<Project>, cx: &mut AppContext) -> Option<Arc<Path>> {
- 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<WeakView<Workspace>>,
- 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<Self>,
- query: String,
- _cancel: Arc<AtomicBool>,
- workspace: Option<WeakView<Workspace>>,
- cx: &mut AppContext,
- ) -> Task<Result<Vec<String>>> {
- 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<Self>,
- argument: Option<&str>,
- workspace: WeakView<Workspace>,
- _delegate: Arc<dyn LspAdapterDelegate>,
- cx: &mut WindowContext,
- ) -> Task<Result<SlashCommandOutput>> {
- 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::<Vec<_>>();
-
- 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,
- })
- })
- }
-}
@@ -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,
@@ -34,6 +34,14 @@ impl IndexedDocsRegistry {
}
}
+ pub fn list_providers(&self) -> Vec<ProviderId> {
+ self.stores_by_provider
+ .read()
+ .keys()
+ .cloned()
+ .collect::<Vec<_>>()
+ }
+
pub fn register_provider(
&self,
provider: Box<dyn IndexedDocsProvider + Send + Sync + 'static>,
@@ -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<String>,
- ) -> Result<MarkdownDocs> {
- 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<MarkdownDocs> {
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();
};