use super::value::{lookup, lookup_row, scalar_text};
use crate::error::{Failure, Result};
use crate::output::envelope::Row;
use serde_json::Value;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Filter {
path: String,
operator: Operator,
operand: String,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Operator {
Equals,
Differs,
Contains,
}
impl Filter {
pub fn parse(expression: &str) -> Result<Self> {
const NO_OPERATOR: &str = "filter.no_operator";
const EMPTY_KEY: &str = "filter.empty_key";
let (path, operator, operand) = if let Some((left, right)) = expression.split_once("!=") {
(left, Operator::Differs, right)
} else if let Some((left, right)) = expression.split_once('~') {
(left, Operator::Contains, right)
} else if let Some((left, right)) = expression.split_once("==") {
(left, Operator::Equals, right)
} else if let Some((left, right)) = expression.split_once('=') {
(left, Operator::Equals, right)
} else {
return Err(Failure::usage(
NO_OPERATOR,
format!("filter `{expression}` has no operator"),
)
.with_detail("detail", expression)
.with_hint("use key=value, key!=value or key~substring"));
};
if path.is_empty() {
return Err(Failure::usage(
EMPTY_KEY,
format!("filter `{expression}` has an empty key"),
)
.with_detail("detail", expression));
}
Ok(Self {
path: path.to_owned(),
operator,
operand: operand.to_owned(),
})
}
pub(super) fn accepts(&self, element: &Value) -> bool {
self.decide(lookup(element, &self.path))
}
pub(super) fn accepts_row(&self, row: &Row) -> bool {
self.decide(lookup_row(row, &self.path))
}
fn decide(&self, found: Option<&Value>) -> bool {
let Some(found) = found else {
return false;
};
let text = scalar_text(found);
match self.operator {
Operator::Equals => text == self.operand,
Operator::Differs => text != self.operand,
Operator::Contains => text.contains(&self.operand),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
#[test]
fn a_malformed_filter_fails_instead_of_matching_nothing() {
let failure = Filter::parse("no-operator-here").expect_err("must refuse");
assert_eq!(failure.category(), crate::error::Category::Usage);
}
#[test]
fn a_missing_field_never_matches_not_even_under_differs() {
let filter = Filter::parse("absent!=anything").expect("parses");
assert!(!filter.accepts(&json!({"name": "alpha"})));
}
}