use crate::model::Authorship;
use crate::token::{is_particle, Token, TokenKind};
const AUTHOR_SUFFIXES: &[&str] = &[
"f", "fil", "filius", "j", "jr", "junior", "jun", "sr", "senior", "sen", "ms", "ined", "Bis",
"bis",
];
const GENERATIONAL_SUFFIXES: &[&str] = &["II", "III", "IV", "VI", "VII", "VIII", "IX"];
#[derive(Debug)]
pub(crate) struct AuthState {
pub combination: Authorship,
pub basionym: Authorship,
pub basionym_present: bool,
pub year_range: bool,
pub has_filius: bool,
pub sanctioning_author: Option<String>,
pub unparsed_from: i32,
pub unparsed_text: Option<String>,
}
impl Default for AuthState {
fn default() -> Self {
AuthState {
combination: Authorship::default(),
basionym: Authorship::default(),
basionym_present: false,
year_range: false,
has_filius: false,
sanctioning_author: None,
unparsed_from: -1,
unparsed_text: None,
}
}
}
pub(crate) fn parse(tokens: &[Token], from: usize) -> AuthState {
let mut s = AuthState::default();
let mut i = from;
let n = tokens.len();
if i < n && tokens[i].kind == TokenKind::OpenParen {
if let Some(close) = find_close(tokens, i) {
let bas_from = i + 1;
let mut bas_end = close;
if let Some(bas_colon) = find_last_colon(tokens, bas_from, bas_end) {
if bas_colon > bas_from {
bas_end = bas_colon;
}
}
if has_upper_word(tokens, bas_from, bas_end) {
let yr = parse_authors(tokens, bas_from, bas_end, &mut s.basionym);
s.year_range |= yr;
s.has_filius |= contains_filius_suffix(tokens, bas_from, bas_end);
s.basionym_present = true;
} else {
let open_tok = &tokens[i];
let close_tok = &tokens[close];
s.unparsed_from = i as i32;
s.unparsed_text = Some(slice_text(tokens, open_tok.start, close_tok.end));
}
i = close + 1;
}
}
if i < n {
let comb_from = i;
let mut comb_end = n;
if let Some(colon) = find_last_colon(tokens, comb_from, comb_end) {
if colon > comb_from {
let mut sb = String::new();
append_author_words(tokens, colon + 1, comb_end, &mut sb);
if !sb.is_empty() {
s.sanctioning_author = Some(sb);
comb_end = colon;
}
}
}
let yr = parse_authors(tokens, comb_from, comb_end, &mut s.combination);
s.year_range |= yr;
s.has_filius |= contains_filius_suffix(tokens, comb_from, comb_end);
i = n;
}
if i < n {
let first = &tokens[i];
let last = &tokens[n - 1];
s.unparsed_from = i as i32;
s.unparsed_text = Some(slice_text(tokens, first.start, last.end));
}
s
}
fn find_last_colon(tokens: &[Token], from: usize, to: usize) -> Option<usize> {
let mut depth = 0i32;
let mut last = None;
for (j, tok) in tokens.iter().enumerate().take(to).skip(from) {
match tok.kind {
TokenKind::OpenParen | TokenKind::OpenBracket => depth += 1,
TokenKind::CloseParen | TokenKind::CloseBracket => depth -= 1,
TokenKind::Colon if depth == 0 => last = Some(j),
_ => {}
}
}
last
}
fn find_close(tokens: &[Token], open_idx: usize) -> Option<usize> {
let mut depth = 1i32;
for (j, tok) in tokens.iter().enumerate().skip(open_idx + 1) {
match tok.kind {
TokenKind::OpenParen => depth += 1,
TokenKind::CloseParen => {
depth -= 1;
if depth == 0 {
return Some(j);
}
}
_ => {}
}
}
None
}
fn parse_authors(tokens: &[Token], from: usize, to: usize, into: &mut Authorship) -> bool {
let mut authors: Vec<String> = Vec::new();
let mut ex_authors: Option<Vec<String>> = None;
let mut cur = String::new();
let mut year_range = false;
let mut i = from;
while i < to {
let t = &tokens[i];
if t.kind == TokenKind::Number && (3..=4).contains(&t.text.chars().count()) {
flush(&mut cur, &mut authors);
let mut year = t.text.clone();
let in_brackets_initial = i > from && tokens[i - 1].kind == TokenKind::OpenBracket;
i += 1;
if i < to && tokens[i].kind == TokenKind::Other && tokens[i].text == "?" {
year.push('?');
i += 1;
}
let in_brackets =
in_brackets_initial && i < to && tokens[i].kind == TokenKind::CloseBracket;
if in_brackets {
if into.imprint_year.is_none() {
into.imprint_year = Some(year);
}
i += 1; continue;
}
if into.year.is_none() {
into.year = Some(year);
} else if into.imprint_year.is_none() {
into.imprint_year = Some(year);
}
if i + 1 < to {
let sep = &tokens[i];
if sep.kind == TokenKind::Other && (sep.text == "-" || sep.text == "/") {
let nx = &tokens[i + 1];
if nx.kind == TokenKind::Number && (1..=4).contains(&nx.text.chars().count()) {
year_range = true;
i += 2;
}
}
}
if i < to {
let nx = &tokens[i];
if nx.kind == TokenKind::Word
&& starts_lower(&nx.text)
&& is_year_disambiguator(&nx.text)
{
i += 1;
}
}
continue;
}
if t.kind == TokenKind::Word && t.text == "ex" {
flush(&mut cur, &mut authors);
ex_authors = Some(authors.clone());
authors.clear();
i += 1;
continue;
}
if t.kind == TokenKind::Ampersand
|| (t.kind == TokenKind::Word
&& (t.text.eq_ignore_ascii_case("and") || t.text.eq_ignore_ascii_case("et")))
|| (t.kind == TokenKind::Word && t.text == "y")
{
flush(&mut cur, &mut authors);
i += 1;
continue;
}
if t.kind == TokenKind::Semicolon {
flush(&mut cur, &mut authors);
i += 1;
continue;
}
if t.kind == TokenKind::Comma {
let mut j = i + 1;
while j < to
&& (tokens[j].kind == TokenKind::Ampersand
|| (tokens[j].kind == TokenKind::Word
&& (tokens[j].text.eq_ignore_ascii_case("and")
|| tokens[j].text.eq_ignore_ascii_case("et"))))
{
j += 1;
}
if j < to {
let next = &tokens[j];
if next.kind == TokenKind::Number {
flush(&mut cur, &mut authors);
i += 1;
continue;
}
if next.kind == TokenKind::Word
&& (starts_upper(&next.text) || is_particle(&next.text))
{
flush(&mut cur, &mut authors);
i += 1;
continue;
}
}
flush(&mut cur, &mut authors);
i += 1;
continue;
}
if t.kind == TokenKind::Word && starts_lower(&t.text) && is_particle(&t.text) {
append_space(&mut cur);
cur.push_str(&t.text);
i += 1;
while i < to && tokens[i].kind == TokenKind::Dot {
cur.push('.');
i += 1;
}
continue;
}
if t.kind == TokenKind::Word && starts_upper(&t.text) {
let text = t.text.clone();
if !cur.is_empty()
&& contains_lower(&cur)
&& !cur.ends_with('.')
&& !ends_with_particle_only(&cur)
&& GENERATIONAL_SUFFIXES.contains(&text.to_uppercase().as_str())
{
append_space(&mut cur);
cur.push_str(&text.to_uppercase());
i += 1;
continue;
}
if !cur.is_empty()
&& text.chars().count() <= 3
&& is_all_upper(&text)
&& contains_lower(&cur)
&& !cur.ends_with('.')
&& !ends_with_particle_only(&cur)
{
let mut initials = text.clone();
let mut j = i + 1;
while j < to && tokens[j].kind == TokenKind::Dot {
initials.push('.');
j += 1;
}
let mut k = j;
if k < to {
let peek = &tokens[k];
if peek.kind == TokenKind::Other
&& peek.text == "-"
&& k + 1 < to
&& tokens[k + 1].kind == TokenKind::Word
&& tokens[k + 1].text.chars().count() == 1
{
initials.push('-');
initials.push_str(&tokens[k + 1].text);
k += 2;
while k < to && tokens[k].kind == TokenKind::Dot {
initials.push('.');
k += 1;
}
}
}
let middle_initial_surname_follows = j > i + 1
&& k < to
&& tokens[k].kind == TokenKind::Word
&& starts_upper(&tokens[k].text)
&& contains_lower(&tokens[k].text);
if !middle_initial_surname_follows {
let surname = cur.trim().to_string();
cur.clear();
authors.push(format!("{}{}", format_initials(&initials), surname));
i = k;
continue;
}
}
let text = normalise_author_case(&t.text);
append_space(&mut cur);
cur.push_str(&text);
i += 1;
if text.chars().count() == 1
&& text.chars().next().is_some_and(|c| c.is_uppercase())
&& (i >= to || tokens[i].kind != TokenKind::Dot)
{
cur.push('.');
}
while i < to {
let nx = &tokens[i];
if nx.kind == TokenKind::Dot {
cur.push('.');
i += 1;
continue;
}
if nx.kind == TokenKind::Word {
let nxt = nx.text.clone();
if AUTHOR_SUFFIXES.contains(&nxt.as_str()) {
if !cur.is_empty() && !cur.ends_with('.') {
cur.push(' ');
}
cur.push_str(&nxt);
i += 1;
if i < to && tokens[i].kind == TokenKind::Dot {
cur.push('.');
i += 1;
}
continue;
}
if starts_upper(&nx.text) && !cur.is_empty() && cur.ends_with('.') {
cur.push_str(&normalise_author_case(&nx.text));
i += 1;
continue;
}
break;
}
break;
}
continue;
}
if t.kind == TokenKind::Word
&& t.text.chars().count() <= 3
&& AUTHOR_SUFFIXES.contains(&t.text.to_lowercase().as_str())
{
if cur.is_empty() && !authors.is_empty() {
let mut last = authors.pop().expect("just checked non-empty");
if !last.ends_with('.') {
last.push('.');
}
last.push_str(&t.text);
authors.push(last);
} else {
if !cur.is_empty() && !cur.ends_with('.') {
cur.push('.');
}
cur.push_str(&t.text);
}
i += 1;
if i < to && tokens[i].kind == TokenKind::Dot {
if !cur.is_empty() && !cur.ends_with('.') {
cur.push('.');
} else if !authors.is_empty() {
let last_idx = authors.len() - 1;
if !authors[last_idx].ends_with('.') {
authors[last_idx].push('.');
}
}
i += 1;
}
continue;
}
if t.kind == TokenKind::Word {
append_space(&mut cur);
cur.push_str(&t.text);
i += 1;
if i < to && tokens[i].kind == TokenKind::Dot {
cur.push('.');
i += 1;
}
continue;
}
if t.kind == TokenKind::Other && t.text == "'" {
let has_gap = !cur.is_empty() && i > 0 && tokens[i - 1].end < t.start;
if has_gap {
append_space(&mut cur);
}
cur.push('\'');
i += 1;
if i < to && tokens[i].kind == TokenKind::Word {
cur.push_str(&tokens[i].text);
i += 1;
}
continue;
}
if t.kind == TokenKind::Other && t.text == "?" && !cur.is_empty() {
i += 1;
if i < to && tokens[i].kind == TokenKind::Word {
cur.push_str(&tokens[i].text);
i += 1;
}
continue;
}
if t.kind == TokenKind::Other
&& t.text == "-"
&& !cur.is_empty()
&& cur.ends_with('.')
&& i + 1 < to
&& tokens[i + 1].kind == TokenKind::Word
{
let nx_text = tokens[i + 1].text.clone();
cur.push('-');
if nx_text.chars().count() == 1 {
cur.push_str(&nx_text);
i += 2;
if i < to && tokens[i].kind == TokenKind::Dot {
cur.push('.');
i += 1;
}
continue;
}
i += 1;
continue;
}
if t.kind == TokenKind::Other
&& t.text == "/"
&& !cur.is_empty()
&& i + 1 < to
&& tokens[i + 1].kind == TokenKind::Word
{
cur.push('/');
cur.push_str(&tokens[i + 1].text);
i += 2;
continue;
}
i += 1;
}
flush(&mut cur, &mut authors);
if !authors.is_empty() {
into.authors = invert_all(&authors);
}
if let Some(ex) = ex_authors {
if !ex.is_empty() {
into.ex_authors = invert_all(&ex);
}
}
year_range
}
fn invert_all(authors: &[String]) -> Vec<String> {
let mut out = Vec::with_capacity(authors.len());
let mut i = 0;
while i < authors.len() {
let cur = &authors[i];
if i + 1 < authors.len() {
let next = &authors[i + 1];
if looks_like_surname(cur) && looks_like_initials(next) {
out.push(format!("{}{}", format_initials(next), cur));
i += 2;
continue;
}
}
out.push(invert_author(cur));
i += 1;
}
out
}
fn invert_author(s: &str) -> String {
let s = s.trim();
if s.is_empty() {
return String::new();
}
if let Some(comma) = s.find(',') {
if comma > 0 && !s[comma + 1..].contains(',') {
let surname = s[..comma].trim();
let initials = s[comma + 1..].trim();
if looks_like_surname(surname) && looks_like_initials(initials) {
return format!("{}{}", format_initials(initials), surname);
}
}
}
if let Some(last_space) = s.rfind(' ') {
if last_space > 0 {
let first = s[..last_space].trim();
let last = s[last_space + 1..].trim();
if last.contains('.')
&& looks_like_surname(first)
&& looks_like_initials(last)
&& !contains_particle(first)
{
return format!("{}{}", format_initials(last), first);
}
}
}
s.to_string()
}
fn looks_like_surname(s: &str) -> bool {
if s.chars().count() < 2 {
return false;
}
match s.chars().next() {
Some(c) if c.is_uppercase() => {}
_ => return false,
}
s.chars().any(|c| c.is_lowercase())
}
fn looks_like_initials(s: &str) -> bool {
if s.is_empty() {
return false;
}
let mut letters = 0u32;
let mut first_letter_seen = false;
let mut prev_hyphen = false;
for c in s.chars() {
if c == '.' || c == ' ' {
continue;
}
if c == '-' {
prev_hyphen = true;
continue;
}
if !c.is_alphabetic() {
return false;
}
letters += 1;
if letters > 4 {
return false;
}
let upper = c.is_uppercase();
if !first_letter_seen {
if !upper {
return false;
}
first_letter_seen = true;
} else if !upper && !prev_hyphen {
return false;
}
prev_hyphen = false;
}
letters > 0
}
fn format_initials(s: &str) -> String {
let had_dots = s.contains('.');
let cleaned: String = s.chars().filter(|&c| c != '.' && c != ' ').collect();
if cleaned.contains('-') {
let mut b = String::new();
for c in cleaned.chars() {
if c == '-' {
b.push('-');
} else if had_dots {
b.push(c);
b.push('.');
} else {
b.extend(c.to_uppercase());
}
}
if !had_dots {
b.push('.');
}
return b;
}
let mut b = String::new();
for c in cleaned.chars() {
b.extend(c.to_uppercase());
b.push('.');
}
b
}
fn is_year_disambiguator(s: &str) -> bool {
let mut chars = s.chars();
match chars.next() {
Some(c) if c.is_lowercase() => {}
_ => return false,
}
chars.all(|c| c.is_ascii_digit())
}
fn is_all_upper(s: &str) -> bool {
let mut any = false;
for c in s.chars() {
if c.is_alphabetic() {
any = true;
if !c.is_uppercase() {
return false;
}
}
}
any
}
fn starts_upper(s: &str) -> bool {
s.chars().next().is_some_and(|c| c.is_uppercase())
}
fn starts_lower(s: &str) -> bool {
s.chars().next().is_some_and(|c| c.is_lowercase())
}
fn ends_with_particle_only(cur: &str) -> bool {
let s = cur.trim();
if s.is_empty() {
return true;
}
let last = s
.split(|c: char| c.is_whitespace() || c == '.')
.rfind(|p| !p.is_empty())
.unwrap_or("");
is_particle(last)
}
fn contains_lower(s: &str) -> bool {
s.chars().any(|c| c.is_lowercase())
}
fn contains_particle(s: &str) -> bool {
s.split_whitespace().any(is_particle)
}
fn flush(cur: &mut String, authors: &mut Vec<String>) {
if !cur.is_empty() {
authors.push(cur.trim().to_string());
cur.clear();
}
}
fn append_space(cur: &mut String) {
match cur.chars().last() {
Some(' ') | Some('.') | Some('-') | None => {}
Some(_) => cur.push(' '),
}
}
fn append_author_words(tokens: &[Token], from: usize, to: usize, sb: &mut String) {
let mut i = from;
while i < to {
if tokens[i].kind == TokenKind::Word {
if !sb.is_empty() && !sb.ends_with('.') {
sb.push(' ');
}
sb.push_str(&normalise_author_case(&tokens[i].text));
i += 1;
while i < to && tokens[i].kind == TokenKind::Dot {
sb.push('.');
i += 1;
}
} else {
i += 1;
}
}
}
fn normalise_author_case(s: &str) -> String {
if s.chars().count() < 4 {
return s.to_string();
}
let all_upper = !s.chars().any(|c| c.is_alphabetic() && !c.is_uppercase());
if !all_upper {
return s.to_string();
}
let mut b = String::with_capacity(s.len());
let mut first = true;
for c in s.chars() {
if c.is_alphabetic() {
if first {
b.push(c);
first = false;
} else {
b.extend(c.to_lowercase());
}
} else {
b.push(c);
first = true;
}
}
b
}
fn slice_text(tokens: &[Token], start: usize, end: usize) -> String {
let mut sb = String::new();
for t in tokens {
if t.start >= start && t.end <= end {
sb.push_str(&t.text);
}
}
sb
}
fn has_upper_word(tokens: &[Token], from: usize, to: usize) -> bool {
tokens[from..to]
.iter()
.any(|t| t.kind == TokenKind::Word && starts_upper(&t.text))
}
fn contains_filius_suffix(tokens: &[Token], from: usize, to: usize) -> bool {
let mut start = from;
for (j, tok) in tokens.iter().enumerate().take(to).skip(from) {
if tok.kind == TokenKind::Word && tok.text == "ex" {
start = j + 1;
}
}
for j in start..to {
let t = &tokens[j];
if t.kind != TokenKind::Word {
continue;
}
let w = t.text.as_str();
if !(w == "f" || w == "fil" || w == "filius") {
continue;
}
if j > 0 && tokens[j - 1].end < t.start {
return true;
}
if j == 0 {
return true;
}
}
false
}
#[cfg(test)]
mod tests {
use super::*;
use crate::token::tokenize;
fn parse_str(input: &str) -> AuthState {
let tokens = tokenize(input);
parse(&tokens, 0)
}
fn authors(state: &AuthState) -> &[String] {
&state.combination.authors
}
#[test]
fn walker_f_flips_to_f_walker() {
assert_eq!(authors(&parse_str("Walker F")), &["F.Walker".to_string()]);
}
#[test]
fn run_on_all_caps_list_flips_every_author() {
assert_eq!(
authors(&parse_str("Balsamo M Fregni E Tongiorgi MA")),
&[
"M.Balsamo".to_string(),
"E.Fregni".to_string(),
"M.A.Tongiorgi".to_string()
]
);
}
#[test]
fn balsamo_m_todaro_ma_variant() {
assert_eq!(
authors(&parse_str("Balsamo M Todaro MA")),
&["M.Balsamo".to_string(), "M.A.Todaro".to_string()]
);
}
#[test]
fn comma_form_walker_f_also_flips() {
assert_eq!(authors(&parse_str("Walker, F.")), &["F.Walker".to_string()]);
assert_eq!(authors(&parse_str("Walker, F")), &["F.Walker".to_string()]);
}
#[test]
fn particle_chain_keeps_h_da_c_monteiro_together() {
assert_eq!(
authors(&parse_str("H. da C. Monteiro")),
&["H.da C.Monteiro".to_string()]
);
}
#[test]
fn isolated_zhang_f_before_separator_still_flips() {
assert_eq!(
authors(&parse_str("Zhang F & Pan Z-X")),
&["F.Zhang".to_string(), "Z-X.Pan".to_string()]
);
}
#[test]
fn middle_initial_surname_follows_keeps_one_author() {
assert_eq!(
authors(&parse_str("Calder & Roy L. Taylor")),
&["Calder".to_string(), "Roy L.Taylor".to_string()]
);
}
#[test]
fn dotted_hyphenated_initials_preserve_case_and_dots() {
assert_eq!(
authors(&parse_str("Y.-j. Wang")),
&["Y.-j.Wang".to_string()]
);
assert_eq!(
authors(&parse_str("C.-K. Yang")),
&["C.-K.Yang".to_string()]
);
}
#[test]
fn comma_inverted_hyphenated_initials() {
assert_eq!(
authors(&parse_str("Wang, Y.-j.")),
&["Y.-j.Wang".to_string()]
);
assert_eq!(
authors(&parse_str("Yang, C.-K.")),
&["C.-K.Yang".to_string()]
);
assert_eq!(
authors(&parse_str("Wang, Y.-j. & Liu, Z.-q.")),
&["Y.-j.Wang".to_string(), "Z.-q.Liu".to_string()]
);
}
#[test]
fn generational_suffix_stays_upper_and_behind_surname() {
assert_eq!(
authors(&parse_str("Loeblich III")),
&["Loeblich III".to_string()]
);
}
#[test]
fn generational_suffix_is_matched_case_insensitively_but_rendered_upper() {
assert_eq!(
authors(&parse_str("Loeblich Iii")),
&["Loeblich III".to_string()]
);
}
#[test]
fn generational_suffix_with_year_and_basionym() {
let s = parse_str("(Paulsen) Loeblich III, 1969");
assert_eq!(s.basionym.authors, vec!["Paulsen".to_string()]);
assert_eq!(s.combination.authors, vec!["Loeblich III".to_string()]);
assert_eq!(s.combination.year, Some("1969".to_string()));
assert!(s.basionym_present);
}
#[test]
fn bare_initials_i_v_x_are_not_generational_suffixes() {
assert_eq!(authors(&parse_str("Smith V")), &["V.Smith".to_string()]);
}
#[test]
fn dot_then_apostrophe_particle_glues_with_no_gap() {
assert_eq!(
authors(&parse_str("L.'t Mannetje")),
&["L.'t Mannetje".to_string()]
);
}
#[test]
fn glued_apostrophe_inside_a_word_is_a_single_token_already() {
assert_eq!(authors(&parse_str("M'Coy")), &["M'Coy".to_string()]);
assert_eq!(
authors(&parse_str("Abdallah & Sa'ad")),
&["Abdallah".to_string(), "Sa'ad".to_string()]
);
}
#[test]
fn leading_apostrophe_particle_with_no_preceding_gap() {
assert_eq!(authors(&parse_str("'t Hart")), &["'t Hart".to_string()]);
}
#[test]
fn apostrophe_particle_preceded_by_a_space_gets_a_space_back() {
assert_eq!(
authors(&parse_str("Henk 't Hart")),
&["Henk 't Hart".to_string()]
);
}
#[test]
fn question_mark_transcription_artefact_glues_silently() {
assert_eq!(
authors(&parse_str("Istv?nffi, 1898")),
&["Istvnffi".to_string()]
);
assert_eq!(
parse_str("Istv?nffi, 1898").combination.year,
Some("1898".to_string())
);
}
#[test]
fn basionym_and_combination_authors_with_year() {
let s = parse_str("(L.) L., 1753");
assert_eq!(s.basionym.authors, vec!["L.".to_string()]);
assert_eq!(s.combination.authors, vec!["L.".to_string()]);
assert_eq!(s.combination.year, Some("1753".to_string()));
assert!(s.basionym_present);
}
#[test]
fn basionym_only_no_trailing_combination() {
let s = parse_str("(Wang & Liu, 1996)");
assert_eq!(
s.basionym.authors,
vec!["Wang".to_string(), "Liu".to_string()]
);
assert_eq!(s.basionym.year, Some("1996".to_string()));
assert!(s.basionym_present);
assert!(s.combination.authors.is_empty());
assert_eq!(s.unparsed_from, -1);
}
#[test]
fn basionym_bracketed_imprint_year() {
let s = parse_str("(Peters, 1876 [1877])");
assert_eq!(s.basionym.authors, vec!["Peters".to_string()]);
assert_eq!(s.basionym.year, Some("1876".to_string()));
assert_eq!(s.basionym.imprint_year, Some("1877".to_string()));
}
#[test]
fn lowercase_only_parens_are_not_a_basionym_and_are_parked_unparsed() {
let s = parse_str("(ilic) L.");
assert!(!s.basionym_present);
assert!(s.basionym.authors.is_empty());
assert_eq!(s.unparsed_from, 0);
assert_eq!(s.unparsed_text, Some("(ilic)".to_string()));
assert_eq!(s.combination.authors, vec!["L.".to_string()]);
}
#[test]
fn basionym_colon_sanctioning_is_dropped_inside_parens() {
let s = parse_str("(Fr. : Fr.) Fr.");
assert_eq!(s.basionym.authors, vec!["Fr.".to_string()]);
assert_eq!(s.combination.authors, vec!["Fr.".to_string()]);
assert_eq!(s.sanctioning_author, None);
}
#[test]
fn top_level_colon_splits_off_sanctioning_author() {
let s = parse_str("L. : Fr.");
assert_eq!(s.combination.authors, vec!["L.".to_string()]);
assert_eq!(s.sanctioning_author, Some("Fr.".to_string()));
}
#[test]
fn pers_colon_fr_sanctioning() {
let s = parse_str("Pers. : Fr.");
assert_eq!(s.combination.authors, vec!["Pers.".to_string()]);
assert_eq!(s.sanctioning_author, Some("Fr.".to_string()));
}
#[test]
fn plain_year_only() {
let s = parse_str("1771");
assert_eq!(s.combination.year, Some("1771".to_string()));
assert!(s.combination.authors.is_empty());
}
#[test]
fn second_plain_year_becomes_imprint_year() {
let s = parse_str("Ehrenberg, 1870, 1869");
assert_eq!(s.combination.authors, vec!["Ehrenberg".to_string()]);
assert_eq!(s.combination.year, Some("1870".to_string()));
assert_eq!(s.combination.imprint_year, Some("1869".to_string()));
}
#[test]
fn unquoted_bracketed_year_is_imprint_year() {
let s = parse_str("Storr, 1970 [1969]");
assert_eq!(s.combination.authors, vec!["Storr".to_string()]);
assert_eq!(s.combination.year, Some("1970".to_string()));
assert_eq!(s.combination.imprint_year, Some("1969".to_string()));
}
#[test]
fn bracketed_year_wins_as_imprint_even_when_the_only_year_given() {
let s = parse_str("Fruhstorfer, [1912]");
assert_eq!(s.combination.authors, vec!["Fruhstorfer".to_string()]);
assert_eq!(s.combination.year, None);
assert_eq!(s.combination.imprint_year, Some("1912".to_string()));
}
#[test]
fn year_range_with_hyphen_keeps_first_year_and_sets_flag() {
let s = parse_str("Smith, 1845-1847");
assert_eq!(s.combination.year, Some("1845".to_string()));
assert!(s.year_range);
}
#[test]
fn year_range_with_short_second_year_and_slash() {
let s = parse_str("Smith, 1987/92");
assert_eq!(s.combination.year, Some("1987".to_string()));
assert!(s.year_range);
}
#[test]
fn non_range_year_does_not_set_year_range_flag() {
let s = parse_str("Smith, 1987");
assert_eq!(s.combination.year, Some("1987".to_string()));
assert!(!s.year_range);
}
#[test]
fn uncertain_trailing_question_mark_folds_into_year() {
let s = parse_str("Smith, 198?");
assert_eq!(s.combination.year, Some("198?".to_string()));
}
#[test]
fn trailing_year_disambiguator_letter_is_dropped() {
let s = parse_str("Smith, 1935h");
assert_eq!(s.combination.year, Some("1935".to_string()));
assert_eq!(s.combination.authors, vec!["Smith".to_string()]);
}
#[test]
fn short_number_that_is_not_year_shaped_is_silently_dropped() {
let s = parse_str("Smith 12");
assert_eq!(s.combination.authors, vec!["Smith".to_string()]);
assert_eq!(s.combination.year, None);
}
#[test]
fn ex_author_split() {
let s = parse_str("Wedd. ex Sch. Bip.");
assert_eq!(s.combination.ex_authors, vec!["Wedd.".to_string()]);
assert_eq!(s.combination.authors, vec!["Sch.Bip.".to_string()]);
}
#[test]
fn hort_ex_author_already_normalised_by_stripandstash() {
let s = parse_str("hort. ex Vilmorin");
assert_eq!(s.combination.ex_authors, vec!["hort.".to_string()]);
assert_eq!(s.combination.authors, vec!["Vilmorin".to_string()]);
}
#[test]
fn dot_glued_filius_chains_case_sensitively_no_separator() {
assert_eq!(authors(&parse_str("L.f")), &["L.f".to_string()]);
}
#[test]
fn spaced_filius_chains_with_a_separating_space() {
assert_eq!(authors(&parse_str("Hooker f.")), &["Hooker f.".to_string()]);
}
#[test]
fn bis_suffix_chains_onto_the_surname() {
assert_eq!(
authors(&parse_str("Yong Wang bis")),
&["Yong Wang bis".to_string()]
);
assert_eq!(
authors(&parse_str("A.Murray bis")),
&["A.Murray bis".to_string()]
);
}
#[test]
fn lone_suffix_after_comma_attaches_to_the_previous_completed_author() {
let s = parse_str("Smith, jr");
assert_eq!(s.combination.authors, vec!["Smith.jr".to_string()]);
}
#[test]
fn author_suffixes_case_insensitive_lone_branch_accepts_mixed_case_too() {
assert_eq!(authors(&parse_str("Smith, jR")), &["Smith.jR".to_string()]);
}
#[test]
fn spaced_f_sets_has_filius_flag() {
assert!(parse_str("Hooker f.").has_filius);
}
#[test]
fn glued_f_does_not_set_has_filius_flag() {
assert!(!parse_str("Burm.f.").has_filius);
}
#[test]
fn filius_before_ex_does_not_count() {
assert!(!parse_str("Baker f. ex Rose").has_filius);
}
#[test]
fn semicolon_separated_citation_list() {
assert_eq!(
authors(&parse_str("Choi,J.H.; Im,W.T.; Yoo,J.S.")),
&[
"J.H.Choi".to_string(),
"W.T.Im".to_string(),
"J.S.Yoo".to_string()
]
);
}
#[test]
fn slash_between_two_authors_stays_glued() {
assert_eq!(
authors(&parse_str("Smith/Jones")),
&["Smith/Jones".to_string()]
);
}
#[test]
fn stray_unmatched_open_paren_is_silently_skipped() {
let s = parse_str("Wedd. ex Sch. Bip. (");
assert_eq!(s.combination.ex_authors, vec!["Wedd.".to_string()]);
assert_eq!(s.combination.authors, vec!["Sch.Bip.".to_string()]);
}
#[test]
fn diacritic_surname_chains_through_dot() {
assert_eq!(authors(&parse_str("Müll.Arg.")), &["Müll.Arg.".to_string()]);
}
#[test]
fn all_caps_long_surname_is_title_cased() {
let s = parse_str("FISCHER 1885");
assert_eq!(s.combination.authors, vec!["Fischer".to_string()]);
assert_eq!(s.combination.year, Some("1885".to_string()));
}
#[test]
fn short_all_caps_word_is_kept_as_initials_not_title_cased() {
assert_eq!(
authors(&parse_str("Balsamo M Todaro MA")),
&["M.Balsamo".to_string(), "M.A.Todaro".to_string()]
);
}
#[test]
fn van_der_particle_chain_stays_lower_case() {
assert_eq!(
authors(&parse_str("van der Wulp")),
&["van der Wulp".to_string()]
);
}
#[test]
fn capitalised_van_particle_chain() {
assert_eq!(
authors(&parse_str("Van de Putte")),
&["Van de Putte".to_string()]
);
}
#[test]
fn ampersand_and_et_and_y_separators() {
assert_eq!(
authors(&parse_str("Xing, Yan & Yin")),
&["Xing".to_string(), "Yan".to_string(), "Yin".to_string()]
);
assert_eq!(
authors(&parse_str("Martinez y Saez")),
&["Martinez".to_string(), "Saez".to_string()]
);
}
#[test]
fn literal_or_is_not_a_recognised_separator() {
assert_eq!(
authors(&parse_str("Jarocki or Schinz")),
&["Jarocki or Schinz".to_string()]
);
}
#[test]
fn empty_span_returns_a_fully_default_state_without_panicking() {
let tokens = tokenize("Aus bus");
let s = parse(&tokens, tokens.len());
assert!(s.combination.authors.is_empty());
assert_eq!(s.unparsed_from, -1);
assert_eq!(s.unparsed_text, None);
}
#[test]
fn phase_c_never_fires_a_regression_pin() {
for input in ["Wedd. ex Sch. Bip. (", "(Wang & Liu, 1996)", "L. : Fr."] {
let s = parse_str(input);
assert_eq!(
s.unparsed_from, -1,
"input {input:?} unexpectedly hit phase C"
);
}
}
}