robinpath 0.2.0

RobinPath - A lightweight, fast scripting language interpreter for automation and data processing
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

use super::Value;
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(tag = "type")]
pub enum AttributePathSegment {
    #[serde(rename = "property")]
    Property { name: String },
    #[serde(rename = "index")]
    Index { index: i64 },
    #[serde(rename = "dynamicKey")]
    DynamicKey {
        variable: String,
        #[serde(rename = "varPath")]
        var_path: Option<Vec<AttributePathSegment>>,
    },
}

/// Resolve a path against a base value, returning the nested value or Null
pub fn resolve_path(base: &Value, path: &[AttributePathSegment]) -> Value {
    let mut current = base.clone();

    for segment in path {
        match segment {
            AttributePathSegment::Property { name } => {
                current = match &current {
                    Value::Object(obj) => obj.get(name).cloned().unwrap_or(Value::Null),
                    Value::Array(arr) if name == "length" => Value::Number(arr.len() as f64),
                    Value::String(s) if name == "length" => Value::Number(s.chars().count() as f64),
                    _ => return Value::Null,
                };
            }
            AttributePathSegment::Index { index } => {
                current = match &current {
                    Value::Array(arr) => {
                        let idx = *index;
                        if idx < 0 || idx as usize >= arr.len() {
                            return Value::Null;
                        }
                        arr[idx as usize].clone()
                    }
                    _ => return Value::Null,
                };
            }
            AttributePathSegment::DynamicKey { .. } => {
                // Dynamic keys need runtime resolution — handled in executor
                return Value::Null;
            }
        }
    }

    current
}

/// Set a value at a path within a base value, mutating in place
pub fn set_at_path(base: &mut Value, path: &[AttributePathSegment], value: Value) {
    if path.is_empty() {
        return;
    }

    if path.len() == 1 {
        match &path[0] {
            AttributePathSegment::Property { name } => {
                if let Value::Object(obj) = base {
                    obj.insert(name.clone(), value);
                } else {
                    // Auto-create object
                    let mut obj = indexmap::IndexMap::new();
                    obj.insert(name.clone(), value);
                    *base = Value::Object(obj);
                }
            }
            AttributePathSegment::Index { index } => {
                if let Value::Array(arr) = base {
                    let idx = *index as usize;
                    if idx < arr.len() {
                        arr[idx] = value;
                    } else {
                        // Extend array with nulls to reach the target index
                        arr.resize(idx + 1, Value::Null);
                        arr[idx] = value;
                    }
                }
            }
            AttributePathSegment::DynamicKey { .. } => {
                // Handled in executor
            }
        }
        return;
    }

    let (first, rest) = path.split_first().unwrap();
    match first {
        AttributePathSegment::Property { name } => {
            if let Value::Object(obj) = base {
                let entry = obj
                    .entry(name.clone())
                    .or_insert_with(|| Value::Object(indexmap::IndexMap::new()));
                set_at_path(entry, rest, value);
            } else {
                let mut obj = indexmap::IndexMap::new();
                let mut child = Value::Object(indexmap::IndexMap::new());
                set_at_path(&mut child, rest, value);
                obj.insert(name.clone(), child);
                *base = Value::Object(obj);
            }
        }
        AttributePathSegment::Index { index } => {
            if let Value::Array(arr) = base {
                let idx = *index as usize;
                if idx < arr.len() {
                    set_at_path(&mut arr[idx], rest, value);
                }
            }
        }
        AttributePathSegment::DynamicKey { .. } => {
            // Handled in executor
        }
    }
}