lazy-template 0.2.0

String template library that send queries to function responder and interpolate the responses
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

use super::ComponentParserInput;
use crate::Parse;
use derive_more::{Display, Error};
use pipe_trait::Pipe;
use split_char_from_str::SplitCharFromStr;

pub type ParserInput<'a> = ComponentParserInput<'a>;

#[derive(Debug, Clone, Copy)]
pub struct SimpleQueryParser;
pub type Parser = SimpleQueryParser;

pub type SimpleQuery<'a> = &'a str;
pub type ParseOutput<'a> = SimpleQuery<'a>;

#[derive(Debug, Display, Error, Clone, Copy)]
pub enum ParseError {
    #[display("Unexpected token {_0:?}")]
    UnexpectedChar(#[error(not(source))] char),
    #[display("Unexpected end of input")]
    UnexpectedEndOfInput,
}

impl<'a> Parse<'a, ParserInput<'a>> for Parser {
    type Output = ParseOutput<'a>;
    type Error = Option<ParseError>;

    fn parse(&self, input: ParserInput<'a>) -> Result<(Self::Output, &'a str), Self::Error> {
        let (head, tail) = input.text.split_first_char().ok_or(None)?;

        if head == input.config.close_bracket {
            return head.pipe(ParseError::UnexpectedChar).pipe(Some).pipe(Err);
        }

        if head != input.config.open_bracket {
            return Err(None);
        }

        let (close_index, _) = tail
            .char_indices()
            .find(|(_, char)| *char == input.config.close_bracket)
            .ok_or(ParseError::UnexpectedEndOfInput)
            .map_err(Some)?;
        let query = &tail[..close_index];
        let rest = &tail[(close_index + 1)..];
        Ok((query, rest))
    }
}