zen-engine 1.0.0-beta.11

Business rules engine
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

use std::sync::Arc;

use zen_expression::intellisense::dependency::ReadDependency;

use super::context::PropertyRead;

pub(crate) struct ReadFlattener;

impl ReadFlattener {
    pub(crate) fn extend_from_deps(
        deps: &[ReadDependency],
        expression_id: &Option<Arc<str>>,
        out: &mut Vec<PropertyRead>,
    ) {
        let aliases: ahash::HashMap<std::rc::Rc<str>, Vec<std::rc::Rc<str>>> =
            ahash::HashMap::default();
        Self::walk_deps(deps, expression_id, &aliases, out, 0);
    }

    fn walk_deps(
        deps: &[ReadDependency],
        expression_id: &Option<Arc<str>>,
        aliases: &ahash::HashMap<std::rc::Rc<str>, Vec<std::rc::Rc<str>>>,
        out: &mut Vec<PropertyRead>,
        depth: usize,
    ) {
        if depth >= crate::policy::MAX_RECURSION_DEPTH {
            return;
        }
        use crate::policy::queries::scope::PathSegments;
        for dep in deps {
            match dep {
                ReadDependency::Direct {
                    path,
                    span,
                    via_index,
                } => {
                    let was_aliased = !path.is_empty() && aliases.contains_key(&path[0]);
                    let resolved = Self::resolve_path(path, aliases);
                    if !resolved.is_empty() {
                        out.push(PropertyRead {
                            path: Arc::from(resolved.as_slice().to_dotted()),
                            expression_id: expression_id.clone(),
                            span: Some(*span),
                            via_alias: was_aliased || *via_index,
                            unresolved: false,
                        });
                    }
                }
                ReadDependency::Unresolved { path, span } => {
                    let resolved = Self::resolve_path(path, aliases);
                    if !resolved.is_empty() {
                        out.push(PropertyRead {
                            path: Arc::from(resolved.as_slice().to_dotted()),
                            expression_id: expression_id.clone(),
                            span: Some(*span),
                            via_alias: true,
                            unresolved: true,
                        });
                    }
                }
                ReadDependency::Iteration {
                    collection,
                    span,
                    alias,
                    reads,
                } => {
                    let collection_was_aliased =
                        !collection.is_empty() && aliases.contains_key(&collection[0]);
                    let resolved_collection = Self::resolve_path(collection, aliases);
                    if !resolved_collection.is_empty() {
                        out.push(PropertyRead {
                            path: Arc::from(resolved_collection.as_slice().to_dotted()),
                            expression_id: expression_id.clone(),
                            span: Some(*span),
                            via_alias: collection_was_aliased,
                            unresolved: false,
                        });
                    }
                    if let Some(a) = alias {
                        let mut inner_aliases = aliases.clone();
                        inner_aliases.insert(a.clone(), resolved_collection);
                        Self::walk_deps(reads, expression_id, &inner_aliases, out, depth + 1);
                    } else {
                        Self::walk_deps(reads, expression_id, aliases, out, depth + 1);
                    }
                }
            }
        }
    }

    fn resolve_path(
        path: &[std::rc::Rc<str>],
        aliases: &ahash::HashMap<std::rc::Rc<str>, Vec<std::rc::Rc<str>>>,
    ) -> Vec<std::rc::Rc<str>> {
        if path.is_empty() {
            return Vec::new();
        }
        if let Some(expansion) = aliases.get(&path[0]) {
            let mut out = expansion.clone();
            out.extend_from_slice(&path[1..]);
            out
        } else {
            path.to_vec()
        }
    }
}