rscel 1.0.8

Cel interpreter in rust
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use crate::{CelError, CelValue};

pub mod contains;
pub mod ends_with;
pub mod index_of;
pub mod match_captures;
pub mod match_captures_all;
pub mod match_replace;
pub mod match_replace_once;
pub mod matches;
pub mod remove;
pub mod repeat;
pub mod replace;
pub mod replace_i;
pub mod split;
pub mod split_whitespace;
pub mod starts_with;
pub mod trim_end_matches;
pub mod trim_matches;
pub mod trim_start_matches;

macro_rules! string_func {
    ($cel_func_name: ident, $func_name:ident, $str_func:ident) => {
        pub fn $func_name(this: CelValue, args: Vec<CelValue>) -> CelValue {
            if args.len() > 0 {
                return CelValue::from_err(CelError::argument(
                    "$cel_func_name does not take any argments",
                ));
            }

            if let CelValue::String(s) = this {
                CelValue::String(s.$str_func().chars().collect())
            } else {
                return CelValue::from_err(CelError::value(
                    "$cel_func_name only available on string",
                ));
            }
        }
    };
}

string_func!(toLower, to_lower_impl, to_lowercase);
string_func!(toUpper, to_upper_impl, to_uppercase);
string_func!(trim, trim_impl, trim);
string_func!(trimStart, trim_start_impl, trim_start);
string_func!(trimEnd, trim_end_impl, trim_end);

pub fn pad_start_impl(this: CelValue, args: Vec<CelValue>) -> CelValue {
    let s = match this {
        CelValue::String(ref s) => s.clone(),
        _ => {
            return CelValue::from_err(CelError::value("padStart is only available on strings"))
        }
    };

    let width = match args.first() {
        Some(CelValue::Int(n)) => *n as usize,
        Some(CelValue::UInt(n)) => *n as usize,
        _ => {
            return CelValue::from_err(CelError::argument(
                "padStart() requires a numeric width argument",
            ))
        }
    };

    let pad_char = match args.get(1) {
        Some(CelValue::String(p)) => {
            let mut chars = p.chars();
            match chars.next() {
                Some(c) if chars.next().is_none() => c,
                _ => {
                    return CelValue::from_err(CelError::argument(
                        "padStart() pad character must be a single character",
                    ))
                }
            }
        }
        None => ' ',
        _ => {
            return CelValue::from_err(CelError::argument(
                "padStart() pad character must be a string",
            ))
        }
    };

    let char_len = s.chars().count();
    if char_len >= width {
        return this;
    }
    let pad_count = width - char_len;
    let padded = std::iter::repeat(pad_char)
        .take(pad_count)
        .chain(s.chars())
        .collect::<String>();
    padded.into()
}

pub fn pad_end_impl(this: CelValue, args: Vec<CelValue>) -> CelValue {
    let s = match this {
        CelValue::String(ref s) => s.clone(),
        _ => {
            return CelValue::from_err(CelError::value("padEnd is only available on strings"))
        }
    };

    let width = match args.first() {
        Some(CelValue::Int(n)) => *n as usize,
        Some(CelValue::UInt(n)) => *n as usize,
        _ => {
            return CelValue::from_err(CelError::argument(
                "padEnd() requires a numeric width argument",
            ))
        }
    };

    let pad_char = match args.get(1) {
        Some(CelValue::String(p)) => {
            let mut chars = p.chars();
            match chars.next() {
                Some(c) if chars.next().is_none() => c,
                _ => {
                    return CelValue::from_err(CelError::argument(
                        "padEnd() pad character must be a single character",
                    ))
                }
            }
        }
        None => ' ',
        _ => {
            return CelValue::from_err(CelError::argument(
                "padEnd() pad character must be a string",
            ))
        }
    };

    let char_len = s.chars().count();
    if char_len >= width {
        return this;
    }
    let pad_count = width - char_len;
    let padded = s
        .chars()
        .chain(std::iter::repeat(pad_char).take(pad_count))
        .collect::<String>();
    padded.into()
}