rulemorph 0.3.1

YAML-based declarative data transformation engine for CSV/JSON to JSON
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
111
112
113

use crate::error::ErrorCode;
use crate::model::{Expr, ExprChain, ExprOp};

use super::ValidationCtx;

#[derive(Clone, Copy, PartialEq, Eq)]
enum BoolExprKind {
    Bool,
    Maybe,
    NotBool,
}

pub(super) fn validate_when_expr(expr: &Expr, base_path: &str, ctx: &mut ValidationCtx<'_>) {
    if matches!(bool_expr_kind(expr), BoolExprKind::NotBool) {
        ctx.push(
            ErrorCode::InvalidWhenType,
            "when/record_when must evaluate to boolean",
            base_path,
        );
    }
}

fn bool_expr_kind(expr: &Expr) -> BoolExprKind {
    match expr {
        Expr::Literal(value) => {
            if value.is_boolean() {
                BoolExprKind::Bool
            } else {
                BoolExprKind::NotBool
            }
        }
        Expr::Ref(_) => BoolExprKind::Maybe,
        Expr::Op(expr_op) => match expr_op.op.as_str() {
            "concat" | "to_string" | "trim" | "lowercase" | "uppercase" | "replace" | "split"
            | "pad_start" | "pad_end" | "lookup" | "lookup_first" | "merge" | "deep_merge"
            | "get" | "pick" | "omit" | "keys" | "values" | "entries" | "len" | "from_entries"
            | "object_flatten" | "object_unflatten" | "map" | "filter" | "flat_map" | "flatten"
            | "take" | "drop" | "slice" | "chunk" | "zip" | "zip_with" | "unzip" | "group_by"
            | "key_by" | "partition" | "unique" | "distinct_by" | "sort_by" | "find_index"
            | "index_of" | "sum" | "avg" | "min" | "max" | "+" | "-" | "*" | "/" | "round"
            | "to_base" | "date_format" | "to_unixtime" => BoolExprKind::NotBool,
            "and" | "or" | "not" | "contains" => BoolExprKind::Bool,
            "==" | "!=" | "<" | "<=" | ">" | ">=" | "~=" => BoolExprKind::Bool,
            "coalesce" => {
                let mut saw_maybe = false;
                for arg in &expr_op.args {
                    match bool_expr_kind(arg) {
                        BoolExprKind::Bool => {}
                        BoolExprKind::Maybe => saw_maybe = true,
                        BoolExprKind::NotBool => return BoolExprKind::NotBool,
                    }
                }
                if saw_maybe {
                    BoolExprKind::Maybe
                } else {
                    BoolExprKind::Bool
                }
            }
            _ => BoolExprKind::Maybe,
        },
        Expr::Chain(expr_chain) => bool_expr_kind_chain(expr_chain),
    }
}

fn bool_expr_kind_chain(expr_chain: &ExprChain) -> BoolExprKind {
    if expr_chain.chain.is_empty() {
        return BoolExprKind::NotBool;
    }

    let mut current = bool_expr_kind(&expr_chain.chain[0]);
    for step in expr_chain.chain.iter().skip(1) {
        let expr_op = match step {
            Expr::Op(expr_op) => expr_op,
            _ => return BoolExprKind::Maybe,
        };
        current = bool_expr_kind_for_op_with_input(expr_op, current);
    }
    current
}

fn bool_expr_kind_for_op_with_input(expr_op: &ExprOp, injected: BoolExprKind) -> BoolExprKind {
    match expr_op.op.as_str() {
        "concat" | "to_string" | "trim" | "lowercase" | "uppercase" | "replace" | "split"
        | "pad_start" | "pad_end" | "lookup" | "lookup_first" | "merge" | "deep_merge" | "get"
        | "pick" | "omit" | "keys" | "values" | "entries" | "len" | "from_entries"
        | "object_flatten" | "object_unflatten" | "map" | "filter" | "flat_map" | "flatten"
        | "take" | "drop" | "slice" | "chunk" | "zip" | "zip_with" | "unzip" | "group_by"
        | "key_by" | "partition" | "unique" | "distinct_by" | "sort_by" | "find_index"
        | "index_of" | "sum" | "avg" | "min" | "max" | "+" | "-" | "*" | "/" | "round"
        | "to_base" | "date_format" | "to_unixtime" => BoolExprKind::NotBool,
        "and" | "or" | "not" | "contains" => BoolExprKind::Bool,
        "==" | "!=" | "<" | "<=" | ">" | ">=" | "~=" => BoolExprKind::Bool,
        "coalesce" => {
            let mut saw_maybe = matches!(injected, BoolExprKind::Maybe);
            if matches!(injected, BoolExprKind::NotBool) {
                return BoolExprKind::NotBool;
            }
            for arg in &expr_op.args {
                match bool_expr_kind(arg) {
                    BoolExprKind::Bool => {}
                    BoolExprKind::Maybe => saw_maybe = true,
                    BoolExprKind::NotBool => return BoolExprKind::NotBool,
                }
            }
            if saw_maybe {
                BoolExprKind::Maybe
            } else {
                BoolExprKind::Bool
            }
        }
        _ => BoolExprKind::Maybe,
    }
}