use std::collections::HashMap;
use super::Graph;
use super::facet_projection::facet_projection_for_node;
#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
pub enum FacetValue {
Scalar(FacetScalar),
Collection(Vec<FacetScalar>),
}
#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
pub enum FacetScalar {
Text(String),
Number(f64),
Bool(bool),
}
pub mod facet_keys {
pub const ADDRESS_KIND: &str = "address_kind";
pub const DOMAIN: &str = "domain";
pub const TITLE: &str = "title";
pub const ADDRESS: &str = "address";
pub const MIME_HINT: &str = "mime_hint";
pub const VIEWER_BINDING: &str = "viewer_binding";
pub const CONTENT_LENGTH: &str = "content_length";
pub const EDGE_KINDS: &str = "edge_kinds";
pub const TRAVERSAL_COUNT: &str = "traversal_count";
pub const IN_DEGREE: &str = "in_degree";
pub const OUT_DEGREE: &str = "out_degree";
pub const FRAME_MEMBERSHIPS: &str = "frame_memberships";
pub const FRAME_AFFINITY_REGION: &str = "frame_affinity_region";
pub const UDC_CLASSES: &str = "udc_classes";
pub const SPATIAL_CLUSTER: &str = "spatial_cluster";
pub const CREATED_AT: &str = "created_at";
pub const LAST_TRAVERSAL: &str = "last_traversal";
pub const LIFECYCLE: &str = "lifecycle";
pub fn is_canonical(key: &str) -> bool {
matches!(
key,
ADDRESS_KIND
| DOMAIN
| TITLE
| ADDRESS
| MIME_HINT
| VIEWER_BINDING
| CONTENT_LENGTH
| EDGE_KINDS
| TRAVERSAL_COUNT
| IN_DEGREE
| OUT_DEGREE
| FRAME_MEMBERSHIPS
| FRAME_AFFINITY_REGION
| UDC_CLASSES
| SPATIAL_CLUSTER
| CREATED_AT
| LAST_TRAVERSAL
| LIFECYCLE
)
}
pub fn is_valid_extension(key: &str) -> bool {
let parts: Vec<&str> = key.splitn(2, ':').collect();
parts.len() == 2 && !parts[0].is_empty() && !parts[1].is_empty()
}
pub fn is_valid(key: &str) -> bool {
is_canonical(key) || is_valid_extension(key)
}
}
#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
pub enum FacetExpr {
Predicate(FacetPredicate),
And(Vec<FacetExpr>),
Or(Vec<FacetExpr>),
Not(Box<FacetExpr>),
}
#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct FacetPredicate {
pub facet_key: String,
pub operator: FacetOperator,
pub operand: FacetOperand,
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub enum FacetOperator {
Eq,
NotEq,
In,
ContainsAny,
ContainsAll,
Range,
Exists,
NotExists,
}
#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
pub enum FacetOperand {
Scalar(FacetScalar),
Set(Vec<FacetScalar>),
Range { lo: FacetScalar, hi: FacetScalar },
None,
}
pub type FacetProjection = HashMap<String, FacetValue>;
#[derive(Debug, Clone)]
pub struct FilterResult {
pub matched_nodes: Vec<super::NodeKey>,
pub filtered_out_nodes: Vec<super::NodeKey>,
pub facet_counts: HashMap<String, usize>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum FilterEvalError {
TypeMismatch {
facet_key: String,
operator: FacetOperator,
actual_value_type: &'static str,
},
InvalidExtensionKey { key: String },
KeyAbsent { key: String },
}
#[derive(Debug, Clone)]
pub struct FilterEvaluationSummary {
pub result: FilterResult,
pub warnings: Vec<FilterEvalError>,
}
impl FacetExpr {
pub fn evaluate(&self, projection: &FacetProjection) -> Result<bool, FilterEvalError> {
match self {
FacetExpr::Predicate(pred) => pred.evaluate(projection),
FacetExpr::And(exprs) => {
for e in exprs {
if !e.evaluate(projection)? {
return Ok(false);
}
}
Ok(true)
},
FacetExpr::Or(exprs) => {
for e in exprs {
if e.evaluate(projection)? {
return Ok(true);
}
}
Ok(false)
},
FacetExpr::Not(inner) => Ok(!inner.evaluate(projection)?),
}
}
}
impl FacetPredicate {
pub fn evaluate(&self, projection: &FacetProjection) -> Result<bool, FilterEvalError> {
if !facet_keys::is_valid(&self.facet_key) {
return Err(FilterEvalError::InvalidExtensionKey {
key: self.facet_key.clone(),
});
}
match self.operator {
FacetOperator::Exists => return Ok(projection.contains_key(&self.facet_key)),
FacetOperator::NotExists => return Ok(!projection.contains_key(&self.facet_key)),
_ => {},
}
let Some(value) = projection.get(&self.facet_key) else {
return Ok(false);
};
match (&self.operator, value, &self.operand) {
(FacetOperator::Eq, FacetValue::Scalar(scalar), FacetOperand::Scalar(operand)) => {
Ok(scalar == operand)
},
(FacetOperator::NotEq, FacetValue::Scalar(scalar), FacetOperand::Scalar(operand)) => {
Ok(scalar != operand)
},
(FacetOperator::In, FacetValue::Scalar(scalar), FacetOperand::Set(set)) => {
Ok(set.contains(scalar))
},
(FacetOperator::ContainsAny, FacetValue::Collection(coll), FacetOperand::Set(set)) => {
Ok(set.iter().any(|operand| {
coll.iter()
.any(|value| collection_value_matches(&self.facet_key, value, operand))
}))
},
(FacetOperator::ContainsAll, FacetValue::Collection(coll), FacetOperand::Set(set)) => {
Ok(set.iter().all(|operand| {
coll.iter()
.any(|value| collection_value_matches(&self.facet_key, value, operand))
}))
},
(
FacetOperator::Range,
FacetValue::Scalar(FacetScalar::Number(n)),
FacetOperand::Range {
lo: FacetScalar::Number(lo),
hi: FacetScalar::Number(hi),
},
) => Ok(n >= lo && n <= hi),
(op, _, _) => Err(FilterEvalError::TypeMismatch {
facet_key: self.facet_key.clone(),
operator: op.clone(),
actual_value_type: value_type_name(value),
}),
}
}
}
impl FacetExpr {
pub fn display_label(&self) -> String {
match self {
FacetExpr::Predicate(predicate) => predicate.display_label(),
FacetExpr::And(exprs) => exprs
.iter()
.map(FacetExpr::display_label)
.collect::<Vec<_>>()
.join(" AND "),
FacetExpr::Or(exprs) => exprs
.iter()
.map(FacetExpr::display_label)
.collect::<Vec<_>>()
.join(" OR "),
FacetExpr::Not(inner) => format!("NOT ({})", inner.display_label()),
}
}
}
impl FacetPredicate {
pub fn display_label(&self) -> String {
match (&self.operator, &self.operand) {
(FacetOperator::Exists, _) => self.facet_key.clone(),
(FacetOperator::NotExists, _) => format!("!{}", self.facet_key),
(FacetOperator::Eq, FacetOperand::Scalar(value)) => {
format!("{}={}", self.facet_key, facet_scalar_label(value))
},
(FacetOperator::NotEq, FacetOperand::Scalar(value)) => {
format!("{}!={}", self.facet_key, facet_scalar_label(value))
},
(FacetOperator::In, FacetOperand::Set(values)) => {
format!("{} in {}", self.facet_key, facet_set_label(values))
},
(FacetOperator::ContainsAny, FacetOperand::Set(values)) => {
format!("{} has any {}", self.facet_key, facet_set_label(values))
},
(FacetOperator::ContainsAll, FacetOperand::Set(values)) => {
format!("{} has all {}", self.facet_key, facet_set_label(values))
},
(FacetOperator::Range, FacetOperand::Range { lo, hi }) => format!(
"{} in [{}..{}]",
self.facet_key,
facet_scalar_label(lo),
facet_scalar_label(hi)
),
_ => self.facet_key.clone(),
}
}
}
fn value_type_name(value: &FacetValue) -> &'static str {
match value {
FacetValue::Scalar(FacetScalar::Text(_)) => "text",
FacetValue::Scalar(FacetScalar::Number(_)) => "number",
FacetValue::Scalar(FacetScalar::Bool(_)) => "bool",
FacetValue::Collection(_) => "collection",
}
}
fn facet_scalar_label(value: &FacetScalar) -> String {
match value {
FacetScalar::Text(text) => text.clone(),
FacetScalar::Number(number) => number.to_string(),
FacetScalar::Bool(flag) => flag.to_string(),
}
}
fn facet_set_label(values: &[FacetScalar]) -> String {
values
.iter()
.map(facet_scalar_label)
.collect::<Vec<_>>()
.join("|")
}
fn is_collection_facet_key(key: &str) -> bool {
matches!(
key,
facet_keys::EDGE_KINDS | facet_keys::FRAME_MEMBERSHIPS | facet_keys::UDC_CLASSES
)
}
fn collection_value_matches(facet_key: &str, value: &FacetScalar, operand: &FacetScalar) -> bool {
match (facet_key, value, operand) {
(facet_keys::UDC_CLASSES, FacetScalar::Text(actual), FacetScalar::Text(expected)) => {
udc_operand_matches(actual, expected)
},
_ => value == operand,
}
}
fn udc_operand_matches(actual: &str, expected: &str) -> bool {
let actual = actual.trim().to_ascii_lowercase();
let expected = expected.trim().to_ascii_lowercase();
actual == expected || actual.starts_with(&expected)
}
pub fn evaluate_filter_result(graph: &Graph, expr: &FacetExpr) -> FilterEvaluationSummary {
let mut matched_nodes = Vec::new();
let mut filtered_out_nodes = Vec::new();
let mut facet_counts = HashMap::new();
let mut warnings = Vec::new();
for (key, _) in graph.nodes() {
let Some(projection) = facet_projection_for_node(graph, key) else {
filtered_out_nodes.push(key);
continue;
};
match expr.evaluate(&projection) {
Ok(true) => {
matched_nodes.push(key);
for facet_key in projection.keys() {
*facet_counts.entry(facet_key.clone()).or_insert(0) += 1;
}
},
Ok(false) => filtered_out_nodes.push(key),
Err(error) => {
warnings.push(error);
filtered_out_nodes.push(key);
},
}
}
FilterEvaluationSummary {
result: FilterResult {
matched_nodes,
filtered_out_nodes,
facet_counts,
},
warnings,
}
}
pub fn parse_omnibar_facet_token(token: &str) -> Option<FacetExpr> {
let body = token.strip_prefix("facet:")?;
if body.is_empty() {
return None;
}
if let Some(rest) = body.strip_prefix('!') {
if let Some((key, value)) = rest.split_once('=') {
let key = key.trim().to_string();
let value = value.trim().to_string();
if !facet_keys::is_valid(&key) || key.is_empty() || value.is_empty() {
return None;
}
let collection_facet = is_collection_facet_key(&key);
let predicate = FacetPredicate {
facet_key: key,
operator: if collection_facet {
FacetOperator::ContainsAny
} else {
FacetOperator::NotEq
},
operand: if collection_facet {
FacetOperand::Set(vec![FacetScalar::Text(value)])
} else {
FacetOperand::Scalar(FacetScalar::Text(value))
},
};
return if collection_facet {
Some(FacetExpr::Not(Box::new(FacetExpr::Predicate(predicate))))
} else {
Some(FacetExpr::Predicate(predicate))
};
}
return None;
}
if let Some((key, value)) = body.split_once('=') {
let key = key.trim().to_string();
let value = value.trim().to_string();
if !facet_keys::is_valid(&key) || key.is_empty() || value.is_empty() {
return None;
}
let collection_facet = is_collection_facet_key(&key);
return Some(FacetExpr::Predicate(FacetPredicate {
facet_key: key,
operator: if collection_facet {
FacetOperator::ContainsAny
} else {
FacetOperator::Eq
},
operand: if collection_facet {
FacetOperand::Set(vec![FacetScalar::Text(value)])
} else {
FacetOperand::Scalar(FacetScalar::Text(value))
},
}));
}
let key = body.trim().to_string();
if !facet_keys::is_valid(&key) || key.is_empty() {
return None;
}
Some(FacetExpr::Predicate(FacetPredicate {
facet_key: key,
operator: FacetOperator::Exists,
operand: FacetOperand::None,
}))
}