#![deny(missing_docs)]
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum MemberNameKind<'a> {
Standard,
AtMember {
namespace: &'a str,
member: &'a str,
},
ExtensionMember {
namespace: &'a str,
member: &'a str,
},
}
fn is_globally_allowed(c: char) -> bool {
c.is_ascii_alphanumeric() || ('\u{0080}'..='\u{FFFF}').contains(&c)
}
fn is_interior_allowed(c: char) -> bool {
is_globally_allowed(c) || c == '-' || c == '_' || c == ' '
}
fn check_standard_name(name: &str) -> Result<(), String> {
let mut chars = name.chars();
let first = match chars.next() {
None => return Err("must not be empty".into()),
Some(c) => c,
};
if !is_globally_allowed(first) {
return Err(format!(
"must start with [a-zA-Z0-9\\u{{0080}}-\\u{{FFFF}}], got '{first}'"
));
}
let mut last = first;
for c in chars {
if !is_interior_allowed(c) {
return Err(format!("invalid interior character '{c}'"));
}
last = c;
}
if last != first && !is_globally_allowed(last) {
return Err(format!(
"must end with [a-zA-Z0-9\\u{{0080}}-\\u{{FFFF}}], got '{last}'"
));
}
Ok(())
}
pub fn classify_member_name(name: &str) -> Result<MemberNameKind<'_>, String> {
if name.is_empty() {
return Err("member name must not be empty".into());
}
if let Some(rest) = name.strip_prefix('@') {
let Some((namespace, member)) = rest.split_once(':') else {
return Err("@-member must contain ':' separator (format: @namespace:member)".into());
};
if namespace.is_empty() {
return Err("@-member namespace must not be empty".into());
}
if member.is_empty() {
return Err("@-member member must not be empty".into());
}
check_standard_name(namespace).map_err(|reason| format!("namespace: {reason}"))?;
check_standard_name(member).map_err(|reason| format!("member: {reason}"))?;
return Ok(MemberNameKind::AtMember { namespace, member });
}
if let Some((namespace, member)) = name.split_once(':') {
if member.contains(':') {
return Err("extension member name must contain exactly one ':' separator".into());
}
if namespace.is_empty() {
return Err("extension namespace must not be empty".into());
}
if member.is_empty() {
return Err("extension member must not be empty".into());
}
check_standard_name(namespace).map_err(|reason| format!("namespace: {reason}"))?;
check_standard_name(member).map_err(|reason| format!("member: {reason}"))?;
return Ok(MemberNameKind::ExtensionMember { namespace, member });
}
check_standard_name(name)?;
Ok(MemberNameKind::Standard)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn valid_standard_names() {
for name in [
"title",
"a",
"1",
"first-name",
"first_name",
"first name",
"field1",
] {
assert_eq!(
classify_member_name(name).unwrap(),
MemberNameKind::Standard,
"{name}"
);
}
}
#[test]
fn valid_unicode_names() {
assert_eq!(
classify_member_name("\u{00E9}tag").unwrap(),
MemberNameKind::Standard
);
assert_eq!(
classify_member_name("\u{00E9}").unwrap(),
MemberNameKind::Standard
);
assert_eq!(
classify_member_name("\u{FFFF}").unwrap(),
MemberNameKind::Standard
);
}
#[test]
fn invalid_standard_names() {
for name in [
"", "-foo", "foo-", "_foo", "foo_", " foo", "foo ", "foo!bar", "foo.bar",
] {
assert!(classify_member_name(name).is_err(), "{name}");
}
}
#[test]
fn valid_at_members() {
assert_eq!(
classify_member_name("@ext:comments").unwrap(),
MemberNameKind::AtMember {
namespace: "ext",
member: "comments",
}
);
assert_eq!(
classify_member_name("@\u{00E9}xt:field").unwrap(),
MemberNameKind::AtMember {
namespace: "\u{00E9}xt",
member: "field",
}
);
}
#[test]
fn invalid_at_members() {
for name in ["@extcomments", "@:comments", "@ext:", "@-ext:comments", "@"] {
assert!(classify_member_name(name).is_err(), "{name}");
}
}
#[test]
fn valid_extension_members() {
assert_eq!(
classify_member_name("atomic:operations").unwrap(),
MemberNameKind::ExtensionMember {
namespace: "atomic",
member: "operations",
}
);
assert_eq!(
classify_member_name("atomic:results").unwrap(),
MemberNameKind::ExtensionMember {
namespace: "atomic",
member: "results",
}
);
}
#[test]
fn invalid_extension_members() {
for name in [
":member",
"namespace:",
"-atomic:results",
"atomic:-results",
"atomic:results:extra",
] {
assert!(classify_member_name(name).is_err(), "{name}");
}
}
#[test]
fn at_member_takes_precedence_over_extension() {
assert!(matches!(
classify_member_name("@ext:foo").unwrap(),
MemberNameKind::AtMember { .. }
));
}
#[test]
fn bad_start_reason_is_stable() {
assert_eq!(
classify_member_name("-invalid").unwrap_err(),
"must start with [a-zA-Z0-9\\u{0080}-\\u{FFFF}], got '-'"
);
}
}