prax 0.1.1

a web penetration proxy hosted in neovim
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

use std::{collections::VecDeque, sync::Arc};

use crate::cli::NvimConnInfo;
use prax::hist::Hist;
use tokio::sync::{mpsc, Mutex, Notify};
use tokio_util::sync::CancellationToken;

use self::{
    handler::Handler,
    view::{View, ViewOp},
};

mod filter;
mod handler;
mod io;
mod tasks;
mod view;

pub use filter::Intercept;

pub(crate) type Neovim = nvim_rs::Neovim<io::IoConn>;
pub(crate) type Buffer = nvim_rs::Buffer<io::IoConn>;
pub(crate) type Window = nvim_rs::Window<io::IoConn>;

pub struct NVim {
    view: Arc<Mutex<View>>,
    action: mpsc::Sender<ViewOp>,
    backlog: Arc<Mutex<VecDeque<Arc<Notify>>>>,
}

impl NVim {
    pub async fn connect(
        conn_info: NvimConnInfo,
        token: CancellationToken,
        history: &'static Hist,
    ) -> eyre::Result<NVim> {
        let (send, recv) = tokio::sync::mpsc::channel(16);

        let handler = Handler::new(send);
        let single = conn_info.singleton();

        let (nvim, join) = io::IoConn::connect(&conn_info, handler).await?;
        let (view, action) = View::new(nvim, token.clone()).await?;
        let backlog = Arc::new(Mutex::new(VecDeque::<Arc<Notify>>::new()));

        tasks::runloop(join, if single { Some(token) } else { None });
        tasks::ui_binding(recv, view.clone(), action.clone(), backlog.clone(), history);
        tasks::history_report(action.clone(), history);

        Ok(NVim {
            view,
            action,
            backlog,
        })
    }

    pub fn intercept(self) -> Intercept {
        self.into()
    }
}