xqpath 1.4.3

A high-performance jq-inspired path extractor and updater for structured data in Rust with advanced debugging, configuration management and interactive debugging capabilities
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
147
148
149
150
151
152
153
154
155

use super::BuiltinFunction;
use crate::parser::EvaluationError;
use serde_json::Value;

/// length 函数 - 获取数组/对象/字符串长度
pub struct LengthFunction;

impl BuiltinFunction for LengthFunction {
    fn name(&self) -> &str {
        "length"
    }

    fn execute(
        &self,
        args: &[Value],
        input: &Value,
    ) -> Result<Vec<Value>, EvaluationError> {
        if !args.is_empty() {
            return Err(EvaluationError::InvalidArguments(
                "length function takes no arguments".to_string(),
            ));
        }

        let length = match input {
            Value::Array(arr) => arr.len(),
            Value::Object(obj) => obj.len(),
            Value::String(s) => s.chars().count(),
            Value::Null => 0,
            _ => return Err(EvaluationError::InvalidArguments(
                "length can only be applied to arrays, objects, strings, or null".to_string()
            )),
        };

        Ok(vec![Value::Number(length.into())])
    }

    fn description(&self) -> &str {
        "Returns the length of arrays, objects, strings, or 0 for null"
    }
}

/// type 函数 - 获取值类型
pub struct TypeFunction;

impl BuiltinFunction for TypeFunction {
    fn name(&self) -> &str {
        "type"
    }

    fn execute(
        &self,
        args: &[Value],
        input: &Value,
    ) -> Result<Vec<Value>, EvaluationError> {
        if !args.is_empty() {
            return Err(EvaluationError::InvalidArguments(
                "type function takes no arguments".to_string(),
            ));
        }

        let type_name = match input {
            Value::Null => "null",
            Value::Bool(_) => "boolean",
            Value::Number(_) => "number",
            Value::String(_) => "string",
            Value::Array(_) => "array",
            Value::Object(_) => "object",
        };

        Ok(vec![Value::String(type_name.to_string())])
    }

    fn description(&self) -> &str {
        "Returns the type of the input value"
    }
}

/// keys 函数 - 获取对象键名或数组索引
pub struct KeysFunction;

impl BuiltinFunction for KeysFunction {
    fn name(&self) -> &str {
        "keys"
    }

    fn execute(
        &self,
        args: &[Value],
        input: &Value,
    ) -> Result<Vec<Value>, EvaluationError> {
        if !args.is_empty() {
            return Err(EvaluationError::InvalidArguments(
                "keys function takes no arguments".to_string(),
            ));
        }

        match input {
            Value::Object(obj) => {
                let mut keys: Vec<String> = obj.keys().cloned().collect();
                keys.sort();
                let key_values: Vec<Value> =
                    keys.into_iter().map(Value::String).collect();
                Ok(vec![Value::Array(key_values)])
            }
            Value::Array(arr) => {
                let indices: Vec<Value> =
                    (0..arr.len()).map(|i| Value::Number(i.into())).collect();
                Ok(vec![Value::Array(indices)])
            }
            _ => Err(EvaluationError::InvalidArguments(
                "keys can only be applied to objects or arrays".to_string(),
            )),
        }
    }

    fn description(&self) -> &str {
        "Returns sorted keys of an object or indices of an array"
    }
}

/// values 函数 - 获取对象所有值
pub struct ValuesFunction;

impl BuiltinFunction for ValuesFunction {
    fn name(&self) -> &str {
        "values"
    }

    fn execute(
        &self,
        args: &[Value],
        input: &Value,
    ) -> Result<Vec<Value>, EvaluationError> {
        if !args.is_empty() {
            return Err(EvaluationError::InvalidArguments(
                "values function takes no arguments".to_string(),
            ));
        }

        match input {
            Value::Object(obj) => {
                let values: Vec<Value> = obj.values().cloned().collect();
                Ok(vec![Value::Array(values)])
            }
            Value::Array(arr) => Ok(vec![Value::Array(arr.clone())]),
            _ => Err(EvaluationError::InvalidArguments(
                "values can only be applied to objects or arrays".to_string(),
            )),
        }
    }

    fn description(&self) -> &str {
        "Returns all values of an object or array"
    }
}