jnv 0.6.1

JSON navigator and interactive filter leveraging jq
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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use std::sync::Arc;

use async_trait::async_trait;
use promkit_widgets::core::{
    crossterm::event::Event,
    pane::{Pane, EMPTY_PANE},
    render::SharedRenderer,
};
use tokio::{sync::Mutex, task::JoinHandle};

pub mod init;
pub use init::ViewProvider;

use crate::prompt::Index;
pub mod monitor;
pub mod spinner;

#[derive(PartialEq)]
enum State {
    Idle,
    Loading,
    Processing,
}

#[async_trait]
pub trait Visualizer: Send + Sync + 'static {
    async fn content_to_copy(&self) -> String;
    async fn create_init_pane(&mut self, area: (u16, u16)) -> Pane;
    async fn create_pane_from_event(&mut self, area: (u16, u16), event: &Event) -> Pane;
    async fn create_panes_from_query(
        &mut self,
        area: (u16, u16),
        query: String,
    ) -> (Option<Pane>, Option<Pane>);
}

pub struct Context {
    state: State,
    area: (u16, u16),
    current_task: Option<JoinHandle<()>>,
}

impl Context {
    pub fn new(area: (u16, u16)) -> Self {
        Self {
            state: State::Idle,
            area,
            current_task: None,
        }
    }
}

pub struct Processor {
    shared: Arc<Mutex<Context>>,
}

impl Processor {
    pub fn new(shared: Arc<Mutex<Context>>) -> Self {
        Self { shared }
    }

    fn spawn_process_task(
        &self,
        query: String,
        shared_visualizer: Arc<Mutex<impl Visualizer>>,
        shared_renderer: SharedRenderer<Index>,
    ) -> JoinHandle<()> {
        let shared = self.shared.clone();
        tokio::spawn(async move {
            {
                let mut shared_state = shared.lock().await;
                shared_state.state = State::Processing;
            }

            let (maybe_guide, maybe_resp) = {
                let shared_state = shared.lock().await;
                let area = shared_state.area;
                drop(shared_state);

                let mut visualizer = shared_visualizer.lock().await;
                visualizer.create_panes_from_query(area, query).await
            };

            // Set state to Idle to prevent overwriting by spinner frames in terminal.
            {
                let mut shared_state = shared.lock().await;
                shared_state.state = State::Idle;
            }
            {
                // TODO: error handling
                let _ = shared_renderer
                    .update([
                        (Index::Guide, maybe_guide.unwrap_or(EMPTY_PANE.to_owned())),
                        (
                            Index::Processor,
                            maybe_resp.unwrap_or(EMPTY_PANE.to_owned()),
                        ),
                    ])
                    .render()
                    .await;
            }
        })
    }

    pub async fn render_on_resize(
        &self,
        shared_visualizer: Arc<Mutex<impl Visualizer>>,
        area: (u16, u16),
        query: String,
        shared_renderer: SharedRenderer<Index>,
    ) {
        {
            let mut shared_state = self.shared.lock().await;
            shared_state.area = area;
            if let Some(task) = shared_state.current_task.take() {
                task.abort();
            }
        }

        let process_task = self.spawn_process_task(query, shared_visualizer, shared_renderer);

        {
            let mut shared_state = self.shared.lock().await;
            shared_state.current_task = Some(process_task);
        }
    }

    pub async fn render_result(
        &self,
        shared_visualizer: Arc<Mutex<impl Visualizer>>,
        query: String,
        shared_renderer: SharedRenderer<Index>,
    ) {
        {
            let mut shared_state = self.shared.lock().await;
            if let Some(task) = shared_state.current_task.take() {
                task.abort();
            }
        }

        let process_task = self.spawn_process_task(query, shared_visualizer, shared_renderer);

        {
            let mut shared_state = self.shared.lock().await;
            shared_state.current_task = Some(process_task);
        }
    }
}