ferritin 0.8.0

Human-friendly CLI for browsing Rust documentation
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

//! Request thread - handles Navigator operations and document formatting

use super::channels::{RequestResponse, UiCommand};
use super::history::HistoryEntry;
use crate::commands::{list, search};
use crate::{request::Request, styled_string::Document};
use crossbeam_channel::{Receiver, Sender};

/// Request thread loop - processes commands from UI thread
pub(super) fn request_thread_loop<'a>(
    request: &'a Request,
    cmd_rx: Receiver<UiCommand<'a>>,
    resp_tx: Sender<RequestResponse<'a>>,
) {
    for cmd in cmd_rx {
        match cmd {
            UiCommand::Navigate(doc_ref) => {
                // Format the already-resolved item (e.g., from clicking a link)
                let doc_nodes = request.format_item(doc_ref);
                let doc = Document::from(doc_nodes);
                let entry = HistoryEntry::Item(doc_ref);

                let _ = resp_tx.send(RequestResponse::Document {
                    doc,
                    entry: Some(entry),
                });
            }

            UiCommand::NavigateToPath(path) => {
                let mut suggestions = vec![];
                if let Some(item) = request.resolve_path(path.as_ref(), &mut suggestions) {
                    let doc_nodes = request.format_item(item);
                    let doc = Document::from(doc_nodes);
                    let entry = HistoryEntry::Item(item);

                    let _ = resp_tx.send(RequestResponse::Document {
                        doc,
                        entry: Some(entry),
                    });
                } else {
                    let _ = resp_tx.send(RequestResponse::Error(format!("Not found: {}", path)));
                }
            }

            UiCommand::Search {
                query,
                crate_name,
                limit,
            } => {
                let (search_doc, _is_error) = search::execute(
                    request,
                    query.as_ref(),
                    limit,
                    crate_name.as_ref().map(|c| c.as_ref()),
                );

                // Always create history entry for searches
                let entry = HistoryEntry::Search {
                    query: query.into_owned(),
                    crate_name: crate_name.map(|c| c.into_owned()),
                };

                let _ = resp_tx.send(RequestResponse::Document {
                    doc: search_doc,
                    entry: Some(entry),
                });
            }

            UiCommand::List => {
                let (list_doc, _is_error, default_crate) = list::execute(request);
                let entry = HistoryEntry::List { default_crate };

                let _ = resp_tx.send(RequestResponse::Document {
                    doc: list_doc,
                    entry: Some(entry),
                });
            }

            UiCommand::ToggleSource {
                include_source,
                current_item,
            } => {
                request.format_context().set_include_source(include_source);
                if let Some(current_item) = current_item {
                    let _ = resp_tx.send(RequestResponse::Document {
                        doc: Document::from(request.format_item(current_item)),
                        entry: None,
                    });
                }
            }

            UiCommand::Shutdown => {
                let _ = resp_tx.send(RequestResponse::ShuttingDown);
                break;
            }
        }
    }
}