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
use std::{fmt::Display, str::FromStr};
use proc_macro2::TokenStream;
use quote::quote;
use syn::LitStr;
#[doc(hidden)]
pub fn qname(item: TokenStream) -> Result<TokenStream, syn::Error> {
let s: LitStr = syn::parse2(item)?;
let _qname: QName = s.value().parse().map_err(|_| syn::Error::new(s.span(), "Invalid QName"))?;
Ok(quote! {
::qname::QName::new_unchecked(#s)
})
}
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct QName {
pub(crate) namespace: Option<String>,
pub(crate) local_part: String,
pub(crate) prefixed_name: String,
}
impl Display for QName {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(&self.prefixed_name)
}
}
#[derive(Debug, Clone, Copy)]
pub struct Error;
impl std::error::Error for Error {}
impl Display for Error {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("Invalid QName")
}
}
impl FromStr for QName {
type Err = Error;
fn from_str(s: &str) -> Result<Self, Self::Err> {
QName::new(s)
}
}
impl QName {
pub fn new(name: &str) -> Result<QName, Error> {
if !is_valid_qname(name) {
return Err(Error);
}
Ok(match name.split_once(":") {
Some((ns, local)) => Self {
namespace: Some(ns.to_string()),
local_part: local.to_string(),
prefixed_name: format!("{ns}:{local}"),
},
None => Self {
namespace: None,
local_part: name.to_string(),
prefixed_name: name.to_string(),
},
})
}
pub fn new_unchecked(name: &str) -> QName {
if !is_valid_qname(name) {
panic!("Input '{name}' is not a valid QName.");
}
match name.split_once(":") {
Some((ns, local)) => Self {
namespace: Some(ns.to_string()),
local_part: local.to_string(),
prefixed_name: format!("{ns}:{local}"),
},
None => Self {
namespace: None,
local_part: name.to_string(),
prefixed_name: name.to_string(),
},
}
}
pub fn namespace(&self) -> Option<&str> {
self.namespace.as_deref()
}
pub fn local_part(&self) -> &str {
&self.local_part
}
pub fn prefixed_name(&self) -> &str {
&self.prefixed_name
}
}
pub fn is_valid_qname(input: &str) -> bool {
fn is_name_start_char(ch: char) -> bool {
match ch {
':' | 'A'..='Z' | '_' | 'a'..='z' => return true,
_ => {}
}
match ch as u32 {
0xC0..=0xD6
| 0xD8..=0xF6
| 0xF8..=0x2FF
| 0x370..=0x37D
| 0x37F..=0x1FFF
| 0x200C..=0x200D
| 0x2070..=0x218F
| 0x2C00..=0x2FEF
| 0x3001..=0xD7FF
| 0xF900..=0xFDCF
| 0xFDF0..=0xFFFD
| 0x10000..=0xEFFFF => true,
_ => false,
}
}
fn is_name_char(ch: char) -> bool {
if is_name_start_char(ch) {
return true;
}
match ch {
'-' | '.' | '0'..='9' => return true,
_ => {}
}
match ch as u32 {
0xb7 | 0x0300..=0x036F | 0x203F..=0x2040 => true,
_ => false,
}
}
let mut chars = input.chars();
let is_valid = match chars.next() {
Some(ch) => is_name_start_char(ch),
None => false,
};
if !is_valid {
return false;
}
chars.all(is_name_char)
}
