json_predicate/predicate/second_order/
mod.rs

1use crate::Predicate;
2use serde::{Deserialize, Serialize};
3use serde_json::Value;
4
5use self::{and::And, not::Not, or::Or};
6
7use super::{context::PredicateContext, error::PredicateError, PredicateImpl};
8
9pub mod and;
10pub mod not;
11pub mod or;
12
13#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
14#[serde(untagged)]
15pub enum SecondOrder {
16    And(And),
17    Or(Or),
18    Not(Not),
19}
20
21impl PredicateImpl for SecondOrder {
22    fn evaluate(&self, data: &Value, ctx: PredicateContext) -> Result<bool, PredicateError> {
23        match self {
24            Self::And(ty) => ty.evaluate(data, ctx),
25            Self::Or(ty) => ty.evaluate(data, ctx),
26            Self::Not(ty) => ty.evaluate(data, ctx),
27        }
28    }
29}
30
31impl From<SecondOrder> for Predicate {
32    fn from(value: SecondOrder) -> Self {
33        Predicate::SecondOrder(value)
34    }
35}
36
37#[cfg(test)]
38mod tests {
39    use serde::Deserialize;
40
41    use crate::predicate::first_order::FirstOrder;
42
43    #[test]
44    fn deser_test() {
45        let contains_expect = serde_json::json!({
46             "op": "contains",
47             "path": "/a/b",
48             "value": " is a "
49        });
50
51        let deser = FirstOrder::deserialize(contains_expect).unwrap();
52
53        insta::assert_debug_snapshot!(deser, @r###"
54        Contains(
55            Contains {
56                path: Some(
57                    JSONPath(
58                        JsonPointer {
59                            ref_toks: [
60                                "a",
61                                "b",
62                            ],
63                            _phantom: PhantomData<alloc::string::String>,
64                        },
65                    ),
66                ),
67                ignore_case: false,
68                value: String(
69                    " is a ",
70                ),
71            },
72        )
73        "###);
74    }
75}