Skip to main content

filter_expr/
lib.rs

1//! A library for parsing the filter expression.
2
3mod error;
4mod expr;
5mod parser;
6mod token;
7mod transform;
8
9use std::fmt::Debug;
10
11pub use error::Error;
12pub use expr::Expr;
13pub use transform::{Transform, TransformContext, TransformResult};
14
15/// The filter expression.
16#[derive(Clone, PartialEq)]
17pub struct FilterExpr {
18    /// The expression of the filter. Possibly empty.
19    expr: Option<Expr>,
20}
21
22impl Debug for FilterExpr {
23    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
24        match &self.expr {
25            Some(expr) => write!(f, "{:?}", expr),
26            None => write!(f, "Empty"),
27        }
28    }
29}
30
31impl FilterExpr {
32    /// Parse the filter expression.
33    ///
34    /// ```rust
35    /// use filter_expr::FilterExpr;
36    ///
37    /// let filter_expr = FilterExpr::parse("name = 'John' AND age > 18").unwrap();
38    /// ```
39    pub fn parse(expr: &str) -> Result<Self, Error> {
40        if expr.trim().is_empty() {
41            return Ok(Self { expr: None });
42        }
43
44        let expr = parse_expr(expr)?;
45        Ok(Self { expr: Some(expr) })
46    }
47
48    /// Check if the filter expression is empty.
49    pub fn is_empty(&self) -> bool {
50        self.expr.is_none()
51    }
52
53    /// Create a new filter expression with the given expression.
54    pub fn new(expr: Option<Expr>) -> Self {
55        Self { expr }
56    }
57
58    /// Get the expression of the filter.
59    pub fn expr(&self) -> Option<&Expr> {
60        self.expr.as_ref()
61    }
62
63    /// Transform the filter expression.
64    pub async fn transform<F: Transform>(self, transformer: &mut F) -> Result<Self, Error> {
65        Ok(Self {
66            expr: match self.expr {
67                Some(expr) => Some(expr.transform(transformer).await?),
68                None => None,
69            },
70        })
71    }
72}
73
74fn parse_expr(input: &str) -> Result<Expr, Error> {
75    let tokens = token::parse_token(input)?;
76    let mut parser = parser::Parser::new(tokens);
77    parser.parse_expr()
78}