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

use std::path::Path;

use xmlserde_derives::XmlDeserialize;

use crate::{namespace::Namespace, version::Version, ParserError};

#[derive(Debug, XmlDeserialize)]
pub struct NamespaceInclude {
    #[xmlserde(name = b"name", ty = "attr")]
    name: String,
    #[xmlserde(name = b"version", ty = "attr")]
    version: Version,
}

impl NamespaceInclude {
    pub fn as_package(&self) -> String {
        format!("{}-{}", self.name, self.version)
    }

    pub fn as_package_file(&self) -> String {
        format!("{}-{}.gir", self.name, self.version)
    }
}

#[derive(Debug, XmlDeserialize)]
pub struct HeaderInclude {
    #[xmlserde(name = b"name", ty = "attr")]
    name: String,
}

impl HeaderInclude {
    pub fn name(&self) -> &str {
        &self.name
    }
}

#[derive(Debug, XmlDeserialize)]
pub struct Package {
    #[xmlserde(name = b"name", ty = "attr")]
    name: String,
}

impl Package {
    pub fn name(&self) -> &str {
        &self.name
    }
}

#[derive(Debug, XmlDeserialize)]
#[xmlserde(root = b"repository")]
pub struct Repository {
    #[xmlserde(name = b"version", ty = "attr")]
    version: Option<Version>,
    #[xmlserde(name = b"c:identifier-prefixes", ty = "attr")]
    c_identifier_prefixes: Option<String>,
    #[xmlserde(name = b"c:symbol-prefixes", ty = "attr")]
    c_symbol_prefixes: Option<String>,
    #[xmlserde(name = b"include", ty = "child")]
    includes: Vec<NamespaceInclude>,
    #[xmlserde(name = b"c:include", ty = "child")]
    c_includes: Vec<HeaderInclude>,
    #[xmlserde(name = b"package", ty = "child")]
    packages: Vec<Package>,
    #[xmlserde(name = b"namespace", ty = "child")]
    namespace: Namespace,
}

impl Repository {
    pub fn from_path(path: impl AsRef<Path>) -> Result<Self, ParserError> {
        let content = std::fs::read_to_string(path)?;
        let repository = xmlserde::xml_deserialize_from_str(&content).map_err(ParserError::Xml)?;
        Ok(repository)
    }

    pub fn version(&self) -> Option<&Version> {
        self.version.as_ref()
    }

    // TODO: split this by ","
    pub fn c_identifier_prefixes(&self) -> Option<&str> {
        self.c_identifier_prefixes.as_deref()
    }

    // TODO: split this by ","
    pub fn c_symbol_prefixes(&self) -> Option<&str> {
        self.c_symbol_prefixes.as_deref()
    }

    pub fn namespace_includes(&self) -> &[NamespaceInclude] {
        &self.includes
    }

    pub fn header_includes(&self) -> &[HeaderInclude] {
        &self.c_includes
    }

    pub fn packages(&self) -> &[Package] {
        &self.packages
    }

    pub fn namespace(&self) -> &Namespace {
        &self.namespace
    }
}