xml-disassembler 0.4.8

Disassemble XML into smaller, manageable files and reassemble on demand.
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

//! Parse element during disassembly - unified strategy handling.

use crate::builders::build_disassembled_file;
use crate::types::{UnifiedParseResult, XmlElementArrayMap, XmlElementParams};
use serde_json::{Map, Value};

fn is_nested_object(element: &Value) -> bool {
    element
        .as_object()
        .map(|obj| {
            obj.keys()
                .any(|k| !k.starts_with('#') && !k.starts_with('@') && k != "?xml")
        })
        .unwrap_or(false)
}

pub async fn parse_element_unified(params: XmlElementParams<'_>) -> UnifiedParseResult {
    let XmlElementParams {
        element,
        disassembled_path,
        unique_id_elements,
        root_element_name,
        root_attributes,
        key,
        leaf_count,
        has_nested_elements,
        format,
        xml_declaration,
        strategy,
        leaf_content: _,
    } = params;

    let is_array = element.is_array();
    let is_nested_obj = is_nested_object(&element);
    let is_nested = is_array || is_nested_obj;

    if is_nested {
        if strategy == "grouped-by-tag" {
            let mut nested = XmlElementArrayMap::new();
            nested.insert(key.to_string(), vec![element.clone()]);
            return UnifiedParseResult {
                leaf_content: Value::Object(Map::new()),
                leaf_count,
                has_nested_elements: true,
                nested_groups: Some(nested),
            };
        } else {
            let _ = build_disassembled_file(crate::types::BuildDisassembledFileOptions {
                content: element.clone(),
                disassembled_path,
                output_file_name: None,
                subdirectory: Some(key),
                wrap_key: Some(key),
                is_grouped_array: false,
                root_element_name,
                root_attributes: root_attributes.clone(),
                format,
                xml_declaration: xml_declaration.clone(),
                unique_id_elements,
            })
            .await;
            return UnifiedParseResult {
                leaf_content: Value::Object(Map::new()),
                leaf_count,
                has_nested_elements: true,
                nested_groups: None,
            };
        }
    }

    let mut leaf_content = Map::new();
    leaf_content.insert(key.to_string(), Value::Array(vec![element]));
    UnifiedParseResult {
        leaf_content: Value::Object(leaf_content),
        leaf_count: leaf_count + 1,
        has_nested_elements,
        nested_groups: None,
    }
}