1use std::path::Path;
2use std::sync::atomic::AtomicBool;
3use std::sync::Arc;
4
5use anyhow::{anyhow, bail, Result};
6use assistant_slash_command::{
7 ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
8};
9use gpui::{AppContext, Model, Task, WeakView};
10use indexed_docs::{
11 IndexedDocsRegistry, IndexedDocsStore, LocalProvider, PackageName, ProviderId, RustdocIndexer,
12};
13use language::LspAdapterDelegate;
14use project::{Project, ProjectPath};
15use ui::prelude::*;
16use util::{maybe, ResultExt};
17use workspace::Workspace;
18
19pub(crate) struct DocsSlashCommand;
20
21impl DocsSlashCommand {
22 pub const NAME: &'static str = "docs";
23
24 fn path_to_cargo_toml(project: Model<Project>, cx: &mut AppContext) -> Option<Arc<Path>> {
25 let worktree = project.read(cx).worktrees().next()?;
26 let worktree = worktree.read(cx);
27 let entry = worktree.entry_for_path("Cargo.toml")?;
28 let path = ProjectPath {
29 worktree_id: worktree.id(),
30 path: entry.path.clone(),
31 };
32 Some(Arc::from(
33 project.read(cx).absolute_path(&path, cx)?.as_path(),
34 ))
35 }
36
37 /// Ensures that the rustdoc provider is registered.
38 ///
39 /// Ideally we would do this sooner, but we need to wait until we're able to
40 /// access the workspace so we can read the project.
41 fn ensure_rustdoc_provider_is_registered(
42 &self,
43 workspace: Option<WeakView<Workspace>>,
44 cx: &mut AppContext,
45 ) {
46 let indexed_docs_registry = IndexedDocsRegistry::global(cx);
47 if indexed_docs_registry
48 .get_provider_store(ProviderId::rustdoc())
49 .is_none()
50 {
51 let index_provider_deps = maybe!({
52 let workspace = workspace.ok_or_else(|| anyhow!("no workspace"))?;
53 let workspace = workspace
54 .upgrade()
55 .ok_or_else(|| anyhow!("workspace was dropped"))?;
56 let project = workspace.read(cx).project().clone();
57 let fs = project.read(cx).fs().clone();
58 let cargo_workspace_root = Self::path_to_cargo_toml(project, cx)
59 .and_then(|path| path.parent().map(|path| path.to_path_buf()))
60 .ok_or_else(|| anyhow!("no Cargo workspace root found"))?;
61
62 anyhow::Ok((fs, cargo_workspace_root))
63 });
64
65 if let Some((fs, cargo_workspace_root)) = index_provider_deps.log_err() {
66 indexed_docs_registry.register_provider(Box::new(RustdocIndexer::new(Box::new(
67 LocalProvider::new(fs, cargo_workspace_root),
68 ))));
69 }
70 }
71 }
72}
73
74impl SlashCommand for DocsSlashCommand {
75 fn name(&self) -> String {
76 Self::NAME.into()
77 }
78
79 fn description(&self) -> String {
80 "insert docs".into()
81 }
82
83 fn menu_text(&self) -> String {
84 "Insert Documentation".into()
85 }
86
87 fn requires_argument(&self) -> bool {
88 true
89 }
90
91 fn complete_argument(
92 self: Arc<Self>,
93 query: String,
94 _cancel: Arc<AtomicBool>,
95 workspace: Option<WeakView<Workspace>>,
96 cx: &mut AppContext,
97 ) -> Task<Result<Vec<ArgumentCompletion>>> {
98 self.ensure_rustdoc_provider_is_registered(workspace, cx);
99
100 let indexed_docs_registry = IndexedDocsRegistry::global(cx);
101 let args = DocsSlashCommandArgs::parse(&query);
102 let store = args
103 .provider()
104 .ok_or_else(|| anyhow!("no docs provider specified"))
105 .and_then(|provider| IndexedDocsStore::try_global(provider, cx));
106 cx.background_executor().spawn(async move {
107 fn build_completions(
108 provider: ProviderId,
109 items: Vec<String>,
110 ) -> Vec<ArgumentCompletion> {
111 items
112 .into_iter()
113 .map(|item| ArgumentCompletion {
114 label: item.clone(),
115 new_text: format!("{provider} {item}"),
116 run_command: true,
117 })
118 .collect()
119 }
120
121 match args {
122 DocsSlashCommandArgs::NoProvider => {
123 let providers = indexed_docs_registry.list_providers();
124 Ok(providers
125 .into_iter()
126 .map(|provider| ArgumentCompletion {
127 label: provider.to_string(),
128 new_text: provider.to_string(),
129 run_command: false,
130 })
131 .collect())
132 }
133 DocsSlashCommandArgs::SearchPackageDocs {
134 provider,
135 package,
136 index,
137 } => {
138 let store = store?;
139
140 if index {
141 // We don't need to hold onto this task, as the `IndexedDocsStore` will hold it
142 // until it completes.
143 let _ = store.clone().index(package.as_str().into());
144 }
145
146 let items = store.search(package).await;
147 Ok(build_completions(provider, items))
148 }
149 DocsSlashCommandArgs::SearchItemDocs {
150 provider,
151 item_path,
152 ..
153 } => {
154 let store = store?;
155 let items = store.search(item_path).await;
156 Ok(build_completions(provider, items))
157 }
158 }
159 })
160 }
161
162 fn run(
163 self: Arc<Self>,
164 argument: Option<&str>,
165 _workspace: WeakView<Workspace>,
166 _delegate: Arc<dyn LspAdapterDelegate>,
167 cx: &mut WindowContext,
168 ) -> Task<Result<SlashCommandOutput>> {
169 let Some(argument) = argument else {
170 return Task::ready(Err(anyhow!("missing argument")));
171 };
172
173 let args = DocsSlashCommandArgs::parse(argument);
174 let text = cx.background_executor().spawn({
175 let store = args
176 .provider()
177 .ok_or_else(|| anyhow!("no docs provider specified"))
178 .and_then(|provider| IndexedDocsStore::try_global(provider, cx));
179 async move {
180 match args {
181 DocsSlashCommandArgs::NoProvider => bail!("no docs provider specified"),
182 DocsSlashCommandArgs::SearchPackageDocs {
183 provider, package, ..
184 } => {
185 let store = store?;
186 let item_docs = store.load(package.clone()).await?;
187
188 anyhow::Ok((provider, package, item_docs.to_string()))
189 }
190 DocsSlashCommandArgs::SearchItemDocs {
191 provider,
192 item_path,
193 ..
194 } => {
195 let store = store?;
196 let item_docs = store.load(item_path.clone()).await?;
197
198 anyhow::Ok((provider, item_path, item_docs.to_string()))
199 }
200 }
201 }
202 });
203
204 cx.foreground_executor().spawn(async move {
205 let (provider, path, text) = text.await?;
206 let range = 0..text.len();
207 Ok(SlashCommandOutput {
208 text,
209 sections: vec![SlashCommandOutputSection {
210 range,
211 icon: IconName::FileRust,
212 label: format!("docs ({provider}): {path}",).into(),
213 }],
214 run_commands_in_text: false,
215 })
216 })
217 }
218}
219
220fn is_item_path_delimiter(char: char) -> bool {
221 !char.is_alphanumeric() && char != '-' && char != '_'
222}
223
224#[derive(Debug, PartialEq)]
225pub(crate) enum DocsSlashCommandArgs {
226 NoProvider,
227 SearchPackageDocs {
228 provider: ProviderId,
229 package: String,
230 index: bool,
231 },
232 SearchItemDocs {
233 provider: ProviderId,
234 package: String,
235 item_path: String,
236 },
237}
238
239impl DocsSlashCommandArgs {
240 pub fn parse(argument: &str) -> Self {
241 let Some((provider, argument)) = argument.split_once(' ') else {
242 return Self::NoProvider;
243 };
244
245 let provider = ProviderId(provider.into());
246
247 if let Some((package, rest)) = argument.split_once(is_item_path_delimiter) {
248 if rest.trim().is_empty() {
249 Self::SearchPackageDocs {
250 provider,
251 package: package.to_owned(),
252 index: true,
253 }
254 } else {
255 Self::SearchItemDocs {
256 provider,
257 package: package.to_owned(),
258 item_path: argument.to_owned(),
259 }
260 }
261 } else {
262 Self::SearchPackageDocs {
263 provider,
264 package: argument.to_owned(),
265 index: false,
266 }
267 }
268 }
269
270 pub fn provider(&self) -> Option<ProviderId> {
271 match self {
272 Self::NoProvider => None,
273 Self::SearchPackageDocs { provider, .. } | Self::SearchItemDocs { provider, .. } => {
274 Some(provider.clone())
275 }
276 }
277 }
278
279 pub fn package(&self) -> Option<PackageName> {
280 match self {
281 Self::NoProvider => None,
282 Self::SearchPackageDocs { package, .. } | Self::SearchItemDocs { package, .. } => {
283 Some(package.as_str().into())
284 }
285 }
286 }
287}
288
289#[cfg(test)]
290mod tests {
291 use super::*;
292
293 #[test]
294 fn test_parse_docs_slash_command_args() {
295 assert_eq!(
296 DocsSlashCommandArgs::parse(""),
297 DocsSlashCommandArgs::NoProvider
298 );
299 assert_eq!(
300 DocsSlashCommandArgs::parse("rustdoc"),
301 DocsSlashCommandArgs::NoProvider
302 );
303
304 assert_eq!(
305 DocsSlashCommandArgs::parse("rustdoc "),
306 DocsSlashCommandArgs::SearchPackageDocs {
307 provider: ProviderId("rustdoc".into()),
308 package: "".into(),
309 index: false
310 }
311 );
312 assert_eq!(
313 DocsSlashCommandArgs::parse("gleam "),
314 DocsSlashCommandArgs::SearchPackageDocs {
315 provider: ProviderId("gleam".into()),
316 package: "".into(),
317 index: false
318 }
319 );
320
321 assert_eq!(
322 DocsSlashCommandArgs::parse("rustdoc gpui"),
323 DocsSlashCommandArgs::SearchPackageDocs {
324 provider: ProviderId("rustdoc".into()),
325 package: "gpui".into(),
326 index: false,
327 }
328 );
329 assert_eq!(
330 DocsSlashCommandArgs::parse("gleam gleam_stdlib"),
331 DocsSlashCommandArgs::SearchPackageDocs {
332 provider: ProviderId("gleam".into()),
333 package: "gleam_stdlib".into(),
334 index: false
335 }
336 );
337
338 // Adding an item path delimiter indicates we can start indexing.
339 assert_eq!(
340 DocsSlashCommandArgs::parse("rustdoc gpui:"),
341 DocsSlashCommandArgs::SearchPackageDocs {
342 provider: ProviderId("rustdoc".into()),
343 package: "gpui".into(),
344 index: true,
345 }
346 );
347 assert_eq!(
348 DocsSlashCommandArgs::parse("gleam gleam_stdlib/"),
349 DocsSlashCommandArgs::SearchPackageDocs {
350 provider: ProviderId("gleam".into()),
351 package: "gleam_stdlib".into(),
352 index: true
353 }
354 );
355
356 assert_eq!(
357 DocsSlashCommandArgs::parse("rustdoc gpui::foo::bar::Baz"),
358 DocsSlashCommandArgs::SearchItemDocs {
359 provider: ProviderId("rustdoc".into()),
360 package: "gpui".into(),
361 item_path: "gpui::foo::bar::Baz".into()
362 }
363 );
364 assert_eq!(
365 DocsSlashCommandArgs::parse("gleam gleam_stdlib/gleam/int"),
366 DocsSlashCommandArgs::SearchItemDocs {
367 provider: ProviderId("gleam".into()),
368 package: "gleam_stdlib".into(),
369 item_path: "gleam_stdlib/gleam/int".into()
370 }
371 );
372 }
373}