queryst 0.1.1

Rust query string parser with nesting support
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
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179

use serialize::json::{Json, ToJson};

use mutable_json::MutableJson;
use helpers::{object_from_list, next_index, create_array, push_item_to_array};

fn merge_object_and_array(to: &mut Json, from: &Json) -> Option<Json> {
    let tree = to.as_object_mut().unwrap();
    let vec = from.as_array().unwrap();
    let index = next_index(tree);

    for (idx, item) in vec.iter().enumerate() {
        tree.insert((index + idx).to_string(), item.clone());
    }

    None
}

fn merge_object_and_merger(to: &mut Json, from: &Json) -> Option<Json> {
    
    let to_tree = to.as_object_mut().unwrap();
    let from_tree = from.as_object().unwrap();

    let to_index = from_tree.get(&"__idx".to_string()).unwrap().as_u64().unwrap().to_string();
    let source_obj = from_tree.get(&"__object".to_string()).unwrap();
    let has_dest_obj = {
        match to_tree.get(&to_index) {
            Some(&Json::Object(_)) => true,
            Some(&Json::Array(_)) => true,
            Some(_) => false,
            None => false
        }
    };

    if has_dest_obj {
        let merge_result = merge(to_tree.get_mut(&to_index).unwrap(), source_obj);
        match merge_result {
            Some(result) => { to_tree.insert(to_index, result); },
            None => ()
        }
    } else {
        to_tree.insert(to_index, source_obj.clone());
    }

    None
}

fn merge_object_and_object(to: &mut Json, from: &Json) -> Option<Json> {
    let to_tree = to.as_object_mut().unwrap();
    let from_tree = from.as_object().unwrap();

    for (key, value) in from_tree.iter() {
        let has_dest_obj = {
            match to_tree.get(key) {
                Some(_) => true,
                None => false
            }
        };

        if has_dest_obj {
            let merge_result = merge(to_tree.get_mut(key).unwrap(), value);
            match merge_result {
                Some(result) => { to_tree.insert(key.to_string(), result); },
                None => ()
            }
        } else {
            let value = if is_merger(value) {
                let mut list = create_array();
                merge(&mut list, value).unwrap_or(list)
            } else {
                value.clone()
            };
            to_tree.insert(key.to_string(), value);
        }
        
    }

    None
}

fn merge_list_and_list(to: &mut Json, from: &Json) -> Option<Json> {
    let to_vec = to.as_array_mut().unwrap();
    let from_vec = from.as_array().unwrap();

    for value in from_vec.iter() {
        to_vec.push(value.clone());
    }

    None
}

fn merge_list_and_merger(to: &mut Json, from: &Json) -> Option<Json> {
    
    let to_vec = to.as_array_mut().unwrap();

    let from_tree = from.as_object().unwrap();
    let to_index = from_tree.get(&"__idx".to_string()).unwrap().as_u64().unwrap() as uint;
    let source_obj = from_tree.get(&"__object".to_string()).unwrap();

    if to_index < to_vec.len() {
        // merge existing item
        let merge_result = merge(&mut to_vec[to_index], source_obj);
        match merge_result {
            Some(result) => { 
                to_vec.remove(to_index);
                to_vec.insert(to_index, result);
            },
            None => ()
        }
        None
    } else if to_index == to_vec.len() {
        to_vec.insert(to_index, source_obj.clone());
        None
    } else {
        let mut new_obj = object_from_list(&to_vec.to_json());
        merge_object_and_merger(&mut new_obj, from);
        return Some(new_obj);
    }
}

fn is_merger(obj: &Json) -> bool {
    if !obj.is_object() {
        return false;
    }

    let tree = obj.as_object().unwrap();
    let idx = tree.get(&"__idx".to_string());
    match idx {
        Some(idx) => idx.is_number(),
        None => false
    }
}

fn merge_list_and_object(to: &mut Json, from: &Json) -> Option<Json> {
    let mut to_tree = object_from_list(to);
    merge(&mut to_tree, from);
    Some(to_tree)
}

fn merge_string_and_json(to: &mut Json, from: &Json) -> Option<Json> {
    let mut list = create_array();
    push_item_to_array(&mut list, to.clone());
    push_item_to_array(&mut list, from.clone());

    Some(list)
}

fn merge_list_and_string(to: &mut Json, from: &Json) -> Option<Json> {
    push_item_to_array(to, from.clone());
    None
}

pub fn merge(to: &mut Json, from: &Json) -> Option<Json> {

    match to {
        &Json::Object(_) => {
            match from {
                &Json::Array(_) => merge_object_and_array(to, from),
                &Json::Object(_) if is_merger(from) => merge_object_and_merger(to, from),
                &Json::Object(_) => merge_object_and_object(to, from),
                &Json::String(_) => return Some(from.clone()),
                _ => panic!("Unknown merge")
            }
        }
        &Json::Array(_) => {
            match from {
                &Json::Array(_) => merge_list_and_list(to, from),
                &Json::Object(_) if is_merger(from) => merge_list_and_merger(to, from),
                &Json::Object(_) => merge_list_and_object(to, from),
                &Json::String(_) => merge_list_and_string(to, from),
                _ => panic!("Unknown merge")
            }
        },
        &Json::String(_) => {
            return merge_string_and_json(to, from)
        }
        _ => panic!("Unknown merge")
    }

}