vrl 0.32.0

Vector Remap Language
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

use crate::compiler::prelude::*;
use std::collections::BTreeMap;
use url::form_urlencoded;

pub fn parse_query_string(bytes: &Bytes, ignore_keys_without_values: bool) -> Resolved {
    let mut query_string = bytes.as_ref();
    if !query_string.is_empty() && query_string[0] == b'?' {
        query_string = &query_string[1..];
    }
    let mut result = BTreeMap::new();
    let parsed = form_urlencoded::parse(query_string);
    for (k, value) in parsed {
        let value = value.as_ref();
        if ignore_keys_without_values && value.is_empty() {
            continue;
        }
        result
            .entry(k.into_owned().into())
            .and_modify(|v| {
                match v {
                    Value::Array(v) => {
                        v.push(value.into());
                    }
                    v => {
                        *v = Value::Array(vec![v.clone(), value.into()]);
                    }
                };
            })
            .or_insert_with(|| value.into());
    }
    Ok(result.into())
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::btreemap;

    #[test]
    fn test_parses_complete() {
        let result = parse_query_string(&"foo=%2B1&bar=2&xyz=&abc".into(), false).unwrap();
        assert_eq!(
            result,
            Value::from(btreemap! {
                "foo" => "+1",
                "bar" => "2",
                "xyz" => "",
                "abc" => "",
            })
        );
    }

    #[test]
    fn test_parses_multiple_values() {
        let result = parse_query_string(&"foo=bar&foo=xyz".into(), false).unwrap();
        assert_eq!(
            result,
            Value::from(btreemap! {
                "foo" => vec!["bar", "xyz"],
            })
        );
    }

    #[test]
    fn test_parses_ruby_on_rails_multiple_values() {
        let result = parse_query_string(&"?foo%5b%5d=bar&foo%5b%5d=xyz".into(), false).unwrap();
        assert_eq!(
            result,
            Value::from(btreemap! {
                "foo[]" =>  vec!["bar", "xyz"],
            })
        );
    }

    #[test]
    fn test_parses_empty_key() {
        let result = parse_query_string(&"=&=".into(), false).unwrap();
        assert_eq!(
            result,
            Value::from(btreemap! {
                "" => vec!["", ""],
            })
        );
    }

    #[test]
    fn test_parses_single_key() {
        let result = parse_query_string(&"foo".into(), false).unwrap();
        assert_eq!(
            result,
            Value::from(btreemap! {
                "foo" => "",
            })
        );
    }

    #[test]
    fn ignores_key_without_values() {
        let result = parse_query_string(&"foo".into(), true).unwrap();
        assert_eq!(result, Value::from(btreemap! {}));
    }

    #[test]
    fn test_parses_empty_string() {
        let result = parse_query_string(&"".into(), false).unwrap();
        assert_eq!(result, Value::from(btreemap! {}));
    }

    #[test]
    fn test_parses_if_starts_with_question_mark() {
        let result = parse_query_string(&"?foo=bar".into(), false).unwrap();
        assert_eq!(
            result,
            Value::from(btreemap! {
                "foo" => "bar",
            })
        );
    }
}