threemf2 0.1.2

3MF (3D Manufacturing Format) file format support
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

use crate::io::XmlNamespace;

pub(crate) fn try_strip_leading_slash(target: &str) -> &str {
    match target.strip_prefix('/') {
        Some(stripped) => stripped,
        None => target,
    }
}

/// Extracts xmlns attribute declarations from an XML element attribute definitions
pub fn parse_xmlns_attributes(tag_content: &str) -> Vec<XmlNamespace> {
    let mut attributes = Vec::new();
    let mut chars = tag_content.chars().peekable();

    while let Some(ch) = chars.next() {
        if ch == 'x' {
            // Check for "xmlns" or "xmlns:"
            let mut attr_name = String::from("x");
            let mut is_xmlns = true;

            // Read rest of potential "xmlns" or "xmlns:"
            for expected in ['m', 'l', 'n', 's'] {
                if chars.peek() == Some(&expected) {
                    attr_name.push(chars.next().unwrap());
                } else {
                    is_xmlns = false;
                    break;
                }
            }

            if is_xmlns {
                let prefix = if chars.peek() == Some(&':') {
                    chars.next(); // consume ':'
                    // Read namespace prefix
                    let mut prefix_str = String::new();
                    while let Some(&ch) = chars.peek() {
                        if ch.is_alphabetic() || ch == '_' || ch == '-' {
                            prefix_str.push(chars.next().unwrap());
                        } else {
                            break;
                        }
                    }
                    Some(prefix_str)
                } else {
                    None
                };

                // Expect equals sign
                if chars.next() == Some('=') && chars.next() == Some('"') {
                    let mut uri = String::new();
                    // Read until closing quote
                    for ch in chars.by_ref() {
                        if ch == '"' {
                            break;
                        }
                        uri.push(ch);
                    }
                    attributes.push(XmlNamespace { prefix, uri });
                }
            }
        }
    }

    attributes
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_parse_xmlns_attributes_simple() {
        let xml = r#"<model xmlns="http://schemas.microsoft.com/3dmanufacturing/core/2015/02" unit="millimeter">"#;
        let attrs = parse_xmlns_attributes(xml);
        assert_eq!(
            attrs,
            vec![XmlNamespace {
                prefix: None,
                uri: "http://schemas.microsoft.com/3dmanufacturing/core/2015/02".to_string()
            }]
        );
    }

    #[test]
    fn test_parse_xmlns_attributes_prefixed() {
        let xml = r#"<model xmlns="http://core" xmlns:p="http://prod" xmlns:b="http://beam">"#;
        let attrs = parse_xmlns_attributes(xml);
        assert_eq!(
            attrs,
            vec![
                XmlNamespace {
                    prefix: None,
                    uri: "http://core".to_string()
                },
                XmlNamespace {
                    prefix: Some("p".to_string()),
                    uri: "http://prod".to_string()
                },
                XmlNamespace {
                    prefix: Some("b".to_string()),
                    uri: "http://beam".to_string()
                },
            ]
        );
    }

    #[test]
    fn test_parse_xmlns_attributes_empty() {
        let xml = r#"<model unit="millimeter">"#;
        let attrs = parse_xmlns_attributes(xml);
        assert_eq!(attrs, Vec::<XmlNamespace>::new());
    }

    #[test]
    fn test_parse_xmlns_attributes_mixed() {
        let xml = r#"<model xmlns="http://core" unit="millimeter" xmlns:p="http://prod" requiredextensions="ext">"#;
        let attrs = parse_xmlns_attributes(xml);
        assert_eq!(
            attrs,
            vec![
                XmlNamespace {
                    prefix: None,
                    uri: "http://core".to_string()
                },
                XmlNamespace {
                    prefix: Some("p".to_string()),
                    uri: "http://prod".to_string()
                },
            ]
        );
    }
}