ad_client 0.5.0

A Rust client API for the ad text editor
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
99
100
101
102
103
104
105

//! Handling of event filtering
use crate::Client;
use ad_event::{FsysEvent, Kind, Source};
use std::io;

/// Outcome of handling an event within an [EventFilter]
#[derive(Debug)]
pub enum Outcome {
    /// The event should be passed back to ad
    Passthrough,
    /// The event should not be passed back to ad
    Handled,
    /// The event should be passed back to ad and then the filter should exit
    PassthroughAndExit,
    /// The event should not be passed back to ad and the filter should exit
    Exit,
}

/// An event filter takes control over a buffer's events file and handles processing the events
/// that come through. Any events without a corresponding handler are written back to ad for
/// internal processing.
#[allow(unused_variables)]
pub trait EventFilter {
    /// Handle text being inserted into the buffer body
    fn handle_insert(
        &mut self,
        src: Source,
        from: usize,
        to: usize,
        txt: &str,
        client: &mut Client,
    ) -> io::Result<Outcome> {
        Ok(Outcome::Handled)
    }

    /// Handle text being deleted from the buffer body
    fn handle_delete(
        &mut self,
        src: Source,
        from: usize,
        to: usize,
        client: &mut Client,
    ) -> io::Result<Outcome> {
        Ok(Outcome::Handled)
    }

    /// Handle a load event in the body
    fn handle_load(
        &mut self,
        src: Source,
        from: usize,
        to: usize,
        txt: &str,
        client: &mut Client,
    ) -> io::Result<Outcome> {
        Ok(Outcome::Passthrough)
    }

    /// Handle an execute event in the body
    fn handle_execute(
        &mut self,
        src: Source,
        from: usize,
        to: usize,
        txt: &str,
        client: &mut Client,
    ) -> io::Result<Outcome> {
        Ok(Outcome::Passthrough)
    }
}

pub(crate) fn run_filter<F>(buffer: &str, mut filter: F, client: &mut Client) -> io::Result<()>
where
    F: EventFilter,
{
    for line in client.event_lines(buffer)? {
        let evt = FsysEvent::try_from_str(&line).map_err(io::Error::other)?;

        let outcome = match evt.kind {
            Kind::LoadBody => {
                filter.handle_load(evt.source, evt.ch_from, evt.ch_to, &evt.txt, client)?
            }
            Kind::ExecuteBody => {
                filter.handle_execute(evt.source, evt.ch_from, evt.ch_to, &evt.txt, client)?
            }
            Kind::InsertBody => {
                filter.handle_insert(evt.source, evt.ch_from, evt.ch_to, &evt.txt, client)?
            }
            Kind::DeleteBody => filter.handle_delete(evt.source, evt.ch_from, evt.ch_to, client)?,
            _ => Outcome::Passthrough,
        };

        match outcome {
            Outcome::Handled => (),
            Outcome::Passthrough => client.write_event(buffer, &evt.as_event_file_line())?,
            Outcome::PassthroughAndExit => {
                client.write_event(buffer, &evt.as_event_file_line())?;
                return Ok(());
            }
            Outcome::Exit => return Ok(()),
        }
    }

    Ok(())
}