use super::CharRange;
use std::fmt;
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) enum SetMember {
Literal(char),
Range(CharRange),
Named(String),
Labelled {
family: String,
member: Box<SetMember>,
},
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct SetDefinition {
pub name: String,
pub members: Vec<SetMember>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) enum ParseError {
NoMembers { name: String },
UnusableName { name: String },
BadCodePoint { token: String },
ReversedRange { token: String },
BadLabel { token: String },
}
const CODE_POINT: &str = "U+";
const COMMENT: char = '\u{0023}';
const UNUSABLE: &str = "cannot name a set: a name is 2 or more \
characters and is never written U+XXXX";
const LABEL: &str = "is not `<family>:<member>`: both halves are required \
and a label takes no second label";
const LABEL_MARK: char = '\u{003A}';
impl ParseError {
fn token(&self) -> &str {
match self {
Self::NoMembers { name } | Self::UnusableName { name } => name,
Self::BadCodePoint { token }
| Self::ReversedRange { token }
| Self::BadLabel { token } => token,
}
}
const fn reason(&self) -> &'static str {
match self {
Self::NoMembers { .. } => "grants nothing",
Self::UnusableName { .. } => UNUSABLE,
Self::BadCodePoint { .. } => "is not a code point",
Self::ReversedRange { .. } => "ends below where it starts",
Self::BadLabel { .. } => LABEL,
}
}
}
impl fmt::Display for ParseError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "'{}' {}", self.token(), self.reason())
}
}
impl std::error::Error for ParseError {}
pub(crate) fn parse_line(
line: &str,
) -> Result<Option<SetDefinition>, ParseError> {
let content = line.trim();
if content.is_empty() || content.starts_with(COMMENT) {
return Ok(None);
}
let mut tokens = content.split_whitespace();
let Some(name) = tokens.next() else {
return Ok(None);
};
check_name(name)?;
let members = tokens.map(member).collect::<Result<Vec<_>, _>>()?;
definition(name, members)
}
fn definition(
name: &str,
members: Vec<SetMember>,
) -> Result<Option<SetDefinition>, ParseError> {
if members.is_empty() {
return Err(ParseError::NoMembers {
name: name.to_owned(),
});
}
Ok(Some(SetDefinition {
name: name.to_owned(),
members,
}))
}
fn check_name(name: &str) -> Result<(), ParseError> {
match member(name)? {
SetMember::Named(_) => Ok(()),
SetMember::Literal(_)
| SetMember::Range(_)
| SetMember::Labelled { .. } => Err(ParseError::UnusableName {
name: name.to_owned(),
}),
}
}
fn member(token: &str) -> Result<SetMember, ParseError> {
if let Some(digits) = token.strip_prefix(CODE_POINT) {
return code_form(token, digits);
}
let mut chars = token.chars();
match (chars.next(), chars.next()) {
(Some(only), None) => Ok(SetMember::Literal(only)),
_ => unlabelled_or_labelled(token),
}
}
fn unlabelled_or_labelled(token: &str) -> Result<SetMember, ParseError> {
match token.split_once(LABEL_MARK) {
None => Ok(SetMember::Named(token.to_owned())),
Some((family, rest)) => labelled(token, family, rest),
}
}
fn labelled(
token: &str,
family: &str,
rest: &str,
) -> Result<SetMember, ParseError> {
let bad = || ParseError::BadLabel {
token: token.to_owned(),
};
if family.is_empty() || rest.is_empty() {
return Err(bad());
}
match member(rest)? {
SetMember::Labelled { .. } => Err(bad()),
inner => Ok(SetMember::Labelled {
family: family.to_owned(),
member: Box::new(inner),
}),
}
}
fn code_form(token: &str, digits: &str) -> Result<SetMember, ParseError> {
match digits.split_once('\u{002D}') {
None => code_point(token, digits)
.map(|point| SetMember::Range(CharRange::single(point))),
Some((low, high)) => span(token, low, high),
}
}
fn span(token: &str, low: &str, high: &str) -> Result<SetMember, ParseError> {
let upper = high.strip_prefix(CODE_POINT).ok_or_else(|| {
ParseError::BadCodePoint {
token: token.to_owned(),
}
})?;
let start = code_point(token, low)?;
let end = code_point(token, upper)?;
CharRange::new(start, end)
.map(SetMember::Range)
.ok_or_else(|| ParseError::ReversedRange {
token: token.to_owned(),
})
}
fn code_point(token: &str, digits: &str) -> Result<char, ParseError> {
hex(digits).ok_or_else(|| ParseError::BadCodePoint {
token: token.to_owned(),
})
}
pub(crate) fn code_points(token: &str) -> Option<String> {
token
.strip_prefix(CODE_POINT)?
.split("+U+")
.map(hex)
.collect()
}
fn hex(digits: &str) -> Option<char> {
if digits.is_empty() || !digits.bytes().all(|b| b.is_ascii_hexdigit()) {
return None;
}
char::from_u32(u32::from_str_radix(digits, 16).ok()?)
}
#[cfg(test)]
mod tests {
use super::{CharRange, ParseError, SetMember, parse_line};
fn members(line: &str) -> Result<Vec<SetMember>, ParseError> {
parse_line(line)
.map(|parsed| parsed.map(|set| set.members).unwrap_or_default())
}
#[test]
fn blank_and_comment_declare_nothing() {
assert_eq!(parse_line(" "), Ok(None));
assert_eq!(parse_line("# a note"), Ok(None));
assert_eq!(parse_line(" # indented note"), Ok(None));
}
#[test]
fn a_single_character_is_a_literal() {
let one = Ok(vec![SetMember::Literal('\u{00A9}')]);
assert_eq!(members("legal \u{00A9}"), one);
}
#[test]
fn a_two_character_token_is_a_set_name() {
let named = Ok(vec![SetMember::Named("box".to_owned())]);
assert_eq!(members("spec box"), named);
}
#[test]
fn a_code_point_is_a_single_range() {
let point = SetMember::Range(CharRange::single('\u{2014}'));
assert_eq!(members("dash U+2014"), Ok(vec![point]));
}
#[test]
fn a_span_is_a_range() {
let range = CharRange {
start: '\u{2500}',
end: '\u{257F}',
};
let span = SetMember::Range(range);
assert_eq!(members("box U+2500-U+257F"), Ok(vec![span]));
}
#[test]
fn the_name_itself_is_not_a_member() {
assert_eq!(
parse_line("ab cd").map(|set| set.map(|s| s.name)),
Ok(Some("ab".to_owned()))
);
}
#[test]
fn a_set_granting_nothing_is_rejected() {
let err = Err(ParseError::NoMembers {
name: "lonely".to_owned(),
});
assert_eq!(parse_line("lonely"), err);
}
#[test]
fn a_one_character_name_is_rejected() {
let err = Err(ParseError::UnusableName {
name: "x".to_owned(),
});
assert_eq!(parse_line("x U+2014"), err);
}
#[test]
fn a_name_spelled_as_a_code_point_is_rejected() {
let err = Err(ParseError::UnusableName {
name: "U+2014".to_owned(),
});
assert_eq!(parse_line("U+2014 U+2015"), err);
}
#[test]
fn a_surrogate_is_not_a_code_point() {
let err = Err(ParseError::BadCodePoint {
token: "U+D800".to_owned(),
});
assert_eq!(parse_line("bad U+D800"), err);
}
#[test]
fn nonsense_digits_are_rejected() {
let err = Err(ParseError::BadCodePoint {
token: "U+ZZZZ".to_owned(),
});
assert_eq!(parse_line("bad U+ZZZZ"), err);
}
#[test]
fn a_signed_code_point_is_rejected() {
let err = Err(ParseError::BadCodePoint {
token: "U++41".to_owned(),
});
assert_eq!(parse_line("bad U++41"), err);
}
#[test]
fn a_span_without_the_second_prefix_is_rejected() {
let err = Err(ParseError::BadCodePoint {
token: "U+0041-005A".to_owned(),
});
assert_eq!(parse_line("bad U+0041-005A"), err);
}
#[test]
fn a_reversed_span_is_rejected() {
let err = Err(ParseError::ReversedRange {
token: "U+005A-U+0041".to_owned(),
});
assert_eq!(parse_line("bad U+005A-U+0041"), err);
}
#[test]
fn a_hyphen_alone_is_a_literal() {
let dash = Ok(vec![SetMember::Literal('\u{002D}')]);
assert_eq!(members("punct \u{002D}"), dash);
}
#[test]
fn several_members_keep_their_order() {
let parsed = members("mix \u{00A9} U+2014 box");
assert_eq!(
parsed,
Ok(vec![
SetMember::Literal('\u{00A9}'),
SetMember::Range(CharRange::single('\u{2014}')),
SetMember::Named("box".to_owned()),
])
);
}
#[test]
fn a_labelled_member_carries_its_family() {
let labelled = SetMember::Labelled {
family: "emoji".to_owned(),
member: Box::new(SetMember::Range(CharRange::single('\u{2705}'))),
};
assert_eq!(members("marks emoji:U+2705"), Ok(vec![labelled]));
}
#[test]
fn a_label_may_govern_a_set_name() {
let labelled = SetMember::Labelled {
family: "emoji".to_owned(),
member: Box::new(SetMember::Named("box".to_owned())),
};
assert_eq!(members("wide emoji:box"), Ok(vec![labelled]));
}
#[test]
fn a_label_with_a_missing_half_is_rejected() {
let no_family = Err(ParseError::BadLabel {
token: ":U+2705".to_owned(),
});
assert_eq!(parse_line("marks :U+2705"), no_family);
let no_member = Err(ParseError::BadLabel {
token: "emoji:".to_owned(),
});
assert_eq!(parse_line("marks emoji:"), no_member);
}
#[test]
fn a_label_on_a_label_is_rejected() {
let err = Err(ParseError::BadLabel {
token: "text:emoji:U+2705".to_owned(),
});
assert_eq!(parse_line("marks text:emoji:U+2705"), err);
}
#[test]
fn a_name_may_not_carry_the_label_mark() {
let err = Err(ParseError::UnusableName {
name: "a:b".to_owned(),
});
assert_eq!(parse_line("a:b U+2705"), err);
}
}