telers 1.0.0-beta.2

An asynchronous framework for Telegram Bot API written in 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
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
149
150
151

use super::{Filter, FilterResult};
use crate::Request;

use std::{convert::Infallible, future::Future};

#[derive(Clone)]
pub enum Dummy {}

/// A filter state holding allowed states for filtering requests
#[derive(Clone)]
pub enum State<S = Dummy, const N: usize = 0> {
    /// State is equal to the specified value
    Eq([S; N]),
    /// Allow any state
    Any,
    /// Allow only no state
    None,
}

impl State {
    /// Creates a state filter that allows any state
    #[inline]
    #[must_use]
    pub const fn any() -> Self {
        Self::Any
    }

    /// Creates a state filter that allows only the absence of state
    #[inline]
    #[must_use]
    pub const fn none() -> Self {
        Self::None
    }

    #[inline]
    #[must_use]
    const fn validate(&self, is_some: bool) -> bool {
        if is_some {
            matches!(self, Self::Any)
        } else {
            matches!(self, Self::None)
        }
    }
}

impl<S> State<S, 1>
where
    for<'a> S: PartialEq<&'a str>,
{
    /// Creates a state filter with a single allowed state
    #[inline]
    #[must_use]
    pub const fn one(state: S) -> Self {
        Self::Eq([state; 1])
    }
}

impl<S, const N: usize> State<S, N>
where
    for<'a> S: PartialEq<&'a str>,
{
    /// Creates a state filter with multiple allowed states
    #[inline]
    #[must_use]
    pub fn many(states: impl Into<[S; N]>) -> Self {
        Self::Eq(states.into())
    }
}

impl<S, const N: usize> State<S, N>
where
    for<'a> S: PartialEq<&'a str>,
{
    #[must_use]
    fn validate_eq(&self, state: Option<&str>) -> bool {
        let Some(state) = state else {
            return false;
        };
        match self {
            State::Eq(allowed_states) => allowed_states
                .iter()
                .any(|allowed_state| *allowed_state == state),
            _ => unreachable!(),
        }
    }
}

impl<Client> Filter<Client> for State<Dummy, 0>
where
    Client: Send,
{
    type Error = Infallible;

    fn check(
        &mut self,
        request: &mut Request<Client>,
    ) -> impl Future<Output = FilterResult<Self::Error>> + Send {
        let res = self.validate(request.context.contains_key("fsm_state"));
        async move { Ok(res) }
    }
}

impl<Client, S, const N: usize> Filter<Client> for State<S, N>
where
    Client: Send,
    for<'a> S: PartialEq<&'a str> + Clone + Send + Sync + 'static,
{
    type Error = Infallible;

    fn check(
        &mut self,
        request: &mut Request<Client>,
    ) -> impl Future<Output = FilterResult<Self::Error>> + Send {
        let res = self.validate_eq(
            request
                .context
                .get::<Box<str>>("fsm_state")
                .map(|val| &**val),
        );
        async move { Ok(res) }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_validate() {
        let filter = State::one("state");
        assert!(filter.validate_eq(Some("state")));
        assert!(!filter.validate_eq(Some("wrong_state")));
        assert!(!filter.validate_eq(None));

        let filter = State::many(["state", "another_state"]);
        assert!(filter.validate_eq(Some("state")));
        assert!(filter.validate_eq(Some("another_state")));
        assert!(!filter.validate_eq(Some("wrong_state")));
        assert!(!filter.validate_eq(None));

        let filter = State::any();
        assert!(filter.validate(true));
        assert!(filter.validate(true));
        assert!(!filter.validate(false));

        let filter = State::none();
        assert!(!filter.validate(true));
        assert!(!filter.validate(true));
        assert!(filter.validate(false));
    }
}