patch-xml 0.0.3

Load and patch xml files. Pre-alpha version. No stable interface until version 0.1.0.
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

use std::str::FromStr;

#[derive(Debug, Clone)]
pub enum CaptureReference {
    Number(usize),
    Name(String),
    WholeExpression,
}

#[derive(Debug, Clone)]
pub struct SegmentReference {
    pub path: String,
    pub capture: CaptureReference,
}

#[derive(Debug, Clone)]
pub enum Segment {
    String(String),
    Reference(SegmentReference),
}

impl From<String> for SegmentReference {
    fn from(segment_reference_string: String) -> Self {
        let parts: Vec<&str> = segment_reference_string.split(":").collect();
        if parts.len() == 0 {
            panic!("Empty references are not allowed");
        } else if parts.len() == 1 {
            SegmentReference {
                path: parts.get(0).unwrap().to_string(),
                capture: CaptureReference::WholeExpression,
            }
        } else if parts.len() == 2 {
            let capture_reference = parts.get(1).unwrap().to_string();
            match usize::from_str(&capture_reference) {
                Ok(index) => SegmentReference {
                    path: parts.get(0).unwrap().to_string(),
                    capture: CaptureReference::Number(index),
                },
                Err(_) => SegmentReference {
                    path: parts.get(0).unwrap().to_string(),
                    capture: CaptureReference::Name(capture_reference),
                },
            }
        } else {
            panic!("A reference must have a path and optionally a capture-reference. Not more.");
        }
    }
}

impl From<&str> for SegmentReference {
    fn from(segment_reference_string: &str) -> Self {
        SegmentReference::from(segment_reference_string.to_string())
    }
}

impl Segment {
    pub fn to_string(&self) -> String {
        match self {
            Segment::String(segment) => segment.clone(),
            Segment::Reference(reference) => format!("[{}]", reference.to_string()),
        }
    }
}

impl PartialEq for Segment {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Segment::String(s1), Segment::String(s2)) => s1 == s2,
            (Segment::Reference(s1), Segment::Reference(s2)) => s1 == s2,
            _ => false,
        }
    }
}

impl SegmentReference {
    pub fn to_string(&self) -> String {
        match &self.capture {
            CaptureReference::Number(n) => format!("{}:{}", self.path, n).to_string(),
            CaptureReference::Name(n) => format!("{}:{}", self.path, n).to_string(),
            CaptureReference::WholeExpression => format!("{}", self.path).to_string(),
        }
    }
}

impl PartialEq for SegmentReference {
    fn eq(&self, other: &Self) -> bool {
        self.path == other.path
            && match (&self.capture, &other.capture) {
                (CaptureReference::WholeExpression, CaptureReference::WholeExpression) => true,
                (CaptureReference::Name(n1), CaptureReference::Name(n2)) => n1 == n2,
                (CaptureReference::Number(n1), CaptureReference::Number(n2)) => n1 == n2,
                (_, _) => false,
            }
    }
}