jarq 0.3.1

An interactive jq-like JSON query tool with a TUI
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

//! Miscellaneous operations: type, not, empty

use serde_json::Value;

pub fn eval_type(value: &Value) -> Value {
    let type_str = match value {
        Value::Null => "null",
        Value::Bool(_) => "boolean",
        Value::Number(_) => "number",
        Value::String(_) => "string",
        Value::Array(_) => "array",
        Value::Object(_) => "object",
    };
    Value::String(type_str.to_string())
}

pub fn eval_not(value: &Value) -> Value {
    // In jq, falsy values are: null and false
    let is_falsy = matches!(value, Value::Null | Value::Bool(false));
    Value::Bool(is_falsy)
}

#[cfg(test)]
mod tests {
    use crate::filter::builtins::{eval, Builtin};
    use serde_json::{json, Value};

    // type tests
    #[test]
    fn test_type_null() {
        assert_eq!(eval(&Builtin::Type, &json!(null)).unwrap(), vec![json!("null")]);
    }

    #[test]
    fn test_type_boolean() {
        assert_eq!(eval(&Builtin::Type, &json!(true)).unwrap(), vec![json!("boolean")]);
        assert_eq!(eval(&Builtin::Type, &json!(false)).unwrap(), vec![json!("boolean")]);
    }

    #[test]
    fn test_type_number() {
        assert_eq!(eval(&Builtin::Type, &json!(42)).unwrap(), vec![json!("number")]);
        assert_eq!(eval(&Builtin::Type, &json!(3.14)).unwrap(), vec![json!("number")]);
    }

    #[test]
    fn test_type_string() {
        assert_eq!(eval(&Builtin::Type, &json!("hello")).unwrap(), vec![json!("string")]);
    }

    #[test]
    fn test_type_array() {
        assert_eq!(eval(&Builtin::Type, &json!([1, 2, 3])).unwrap(), vec![json!("array")]);
    }

    #[test]
    fn test_type_object() {
        assert_eq!(eval(&Builtin::Type, &json!({"a": 1})).unwrap(), vec![json!("object")]);
    }

    // empty tests
    #[test]
    fn test_empty() {
        let empty: Vec<Value> = vec![];
        assert_eq!(eval(&Builtin::Empty, &json!({"anything": "here"})).unwrap(), empty);
        assert_eq!(eval(&Builtin::Empty, &json!(null)).unwrap(), empty);
    }

    // not tests
    #[test]
    fn test_not_null() {
        assert_eq!(eval(&Builtin::Not, &json!(null)).unwrap(), vec![json!(true)]);
    }

    #[test]
    fn test_not_false() {
        assert_eq!(eval(&Builtin::Not, &json!(false)).unwrap(), vec![json!(true)]);
    }

    #[test]
    fn test_not_true() {
        assert_eq!(eval(&Builtin::Not, &json!(true)).unwrap(), vec![json!(false)]);
    }

    #[test]
    fn test_not_truthy_values() {
        assert_eq!(eval(&Builtin::Not, &json!(0)).unwrap(), vec![json!(false)]);
        assert_eq!(eval(&Builtin::Not, &json!("")).unwrap(), vec![json!(false)]);
        assert_eq!(eval(&Builtin::Not, &json!([])).unwrap(), vec![json!(false)]);
        assert_eq!(eval(&Builtin::Not, &json!({})).unwrap(), vec![json!(false)]);
    }
}