ferogram 0.6.5

A native, elegant, and asynchronous MTProto framework in Rust for Telegram clients, bots, and applications.
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

/*
 * Copyright (c) 2026 Ankit Chaubey <ankitchaubey.dev@gmail.com>
 * https://github.com/ankit-chaubey
 *
 * Project: ferogram
 * Website: https://ferogram.dev
 *
 * Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
 * https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
 * <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your option.
 * This file may not be copied, modified, or distributed except according
 * to those terms.
 */

//! Built-in filters over [`CallbackQuery`] and [`InlineQuery`].
//!
//! These use the same [`BoxFilter`]/`&`/`|`/`!` combinator machinery as the
//! message filters in [`super::builtins`], just parameterized over a
//! different update type. See [`crate::filters::Router::on_callback_query`]
//! and [`crate::filters::Router::on_inline_query`] for how to register them.

use regex::Regex;

use super::core::{BoxFilter, make};
use crate::update::{CallbackQuery, InlineQuery};

/// Callback data matches exactly.
///
/// # Example
/// ```rust,no_run
/// use ferogram::filters::data;
/// let close = data("close");
/// ```
pub fn data(value: impl Into<String>) -> BoxFilter<CallbackQuery> {
    let value = value.into();
    make(move |q: &CallbackQuery| q.data() == Some(value.as_str()))
}

/// Callback data starts with `prefix` (case-sensitive).
///
/// # Example
/// ```rust,no_run
/// use ferogram::filters::data_prefix;
/// let page = data_prefix("page:");
/// ```
pub fn data_prefix(prefix: impl Into<String>) -> BoxFilter<CallbackQuery> {
    let prefix = prefix.into();
    make(move |q: &CallbackQuery| q.data().is_some_and(|d| d.starts_with(prefix.as_str())))
}

/// Callback data matches a regular expression.
///
/// The pattern is compiled once, at filter-construction time. Panics if
/// `pattern` is not a valid regex -- construct filters at startup, not
/// inside a hot path, so a bad pattern fails fast and loudly.
///
/// # Example
/// ```rust,no_run
/// use ferogram::filters::data_regex;
/// let item = data_regex(r"^item_\d+$");
/// ```
pub fn data_regex(pattern: &str) -> BoxFilter<CallbackQuery> {
    let re = Regex::new(pattern).expect("data_regex: invalid regular expression");
    make(move |q: &CallbackQuery| q.data().is_some_and(|d| re.is_match(d)))
}

/// Inline query text matches a regular expression.
///
/// Panics if `pattern` is not a valid regex, for the same reason as
/// [`data_regex`].
///
/// # Example
/// ```rust,no_run
/// use ferogram::filters::inline_query_matches;
/// let cats = inline_query_matches(r"^cat:");
/// ```
pub fn inline_query_matches(pattern: &str) -> BoxFilter<InlineQuery> {
    let re = Regex::new(pattern).expect("inline_query_matches: invalid regular expression");
    make(move |q: &InlineQuery| re.is_match(q.query()))
}