bwq 0.3.1

A linter and parser for Brandwatch query files (.bwq)
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use super::rules::*;
use super::{ValidationContext, ValidationRule};
use crate::ast::*;
use crate::error::{LintError, LintReport, LintWarning};

/// per-expression validation engine
pub struct ValidationEngine {
    rules: Vec<Box<dyn ValidationRule>>,
}

impl ValidationEngine {
    pub fn new() -> Self {
        Self {
            rules: vec![
                // field validation rules
                Box::new(RatingFieldRule),
                Box::new(CoordinateFieldRule),
                Box::new(LanguageFieldRule),
                Box::new(AuthorGenderFieldRule),
                Box::new(BooleanFieldRule),
                Box::new(EngagementTypeFieldRule),
                Box::new(VerifiedTypeFieldRule),
                Box::new(MinuteOfDayFieldRule),
                Box::new(RangeFieldRule),
                // operator validation rules
                Box::new(MixedAndOrRule),
                Box::new(MixedNearRule),
                Box::new(PureNegativeRule),
                Box::new(BinaryOperatorRule),
                Box::new(TildeUsageRule),
                // performance validation rules
                Box::new(WildcardPerformanceRule),
                Box::new(ShortTermRule),
                Box::new(RangePerformanceRule),
            ],
        }
    }

    pub fn validate(&self, query: &Query) -> LintReport {
        let mut all_errors = Vec::new();
        let mut all_warnings = Vec::new();

        let ctx = ValidationContext::default();
        self.walk_expression(&query.expression, &ctx, &mut all_errors, &mut all_warnings);

        LintReport {
            errors: all_errors,
            warnings: all_warnings,
        }
    }

    fn walk_expression(
        &self,
        expr: &Expression,
        ctx: &ValidationContext,
        errors: &mut Vec<LintError>,
        warnings: &mut Vec<LintWarning>,
    ) {
        // apply all relevant rules to this expression
        for rule in &self.rules {
            if rule.can_validate(expr) {
                let result = rule.validate(expr, ctx);
                errors.extend(result.errors);
                warnings.extend(result.warnings);
            }
        }

        // recursively validate child expressions with updated context
        match expr {
            Expression::BooleanOp {
                operator,
                left,
                right,
                ..
            } => {
                let mut child_ctx = ctx.clone();
                child_ctx.parent_operator = Some(operator.clone());

                self.walk_expression(left, &child_ctx, errors, warnings);
                if let Some(right_expr) = right {
                    self.walk_expression(right_expr, &child_ctx, errors, warnings);
                }
            }
            Expression::Group { expression, .. } => {
                let mut group_ctx = ctx.clone();
                group_ctx.inside_group = true;
                self.walk_expression(expression, &group_ctx, errors, warnings);
            }
            Expression::Proximity { terms, .. } => {
                for term in terms {
                    self.walk_expression(term, ctx, errors, warnings);
                }
            }
            Expression::Field { field, value, .. } => {
                let mut field_ctx = ctx.clone();
                field_ctx.field_context = Some(field.clone());
                self.walk_expression(value, &field_ctx, errors, warnings);
            }
            Expression::Range { .. } | Expression::Term { .. } => {
                // terminal nodes - no recursion needed
            }
        }
    }
}

impl Default for ValidationEngine {
    fn default() -> Self {
        Self::new()
    }
}