use crate::model::Authorship;
use crate::pipeline::cjk_names::{self, GivenName};
use crate::pipeline::double_surnames;
use crate::pipeline::rank_markers;
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"];
const ANON_WORDS: &[&str] = &[
"anon",
"anonymous",
"anonymus",
"anonyme",
"anonym",
"anonymi",
];
const BRACKET_NOTE_WORDS: &[&str] = &[
"auct",
"auctt",
"auctorum",
"hort",
"sensu",
"non",
"nec",
"not",
"sec",
"emend",
"fide",
"orth",
"nom",
"comb",
"sic",
"corrig",
"error",
"lapsus",
"misspelling",
"ms",
"msc",
"ined",
];
#[derive(Debug, Clone)]
pub(crate) struct AuthState {
pub combination: Authorship,
pub basionym: Authorship,
pub basionym_present: bool,
pub year_range: bool,
pub has_filius: bool,
pub combination_year_after_comma: bool,
pub combination_initials_first: bool,
pub manuscript_ex: bool,
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,
combination_year_after_comma: false,
combination_initials_first: false,
manuscript_ex: false,
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;
let mut bas_sanctioning = None;
if let Some(bas_colon) = find_last_colon(tokens, bas_from, bas_end) {
if bas_colon > bas_from {
let mut sb = String::new();
append_author_words(tokens, bas_colon + 1, close, &mut sb);
bas_sanctioning = is_sanctioning_author(&sb).then_some(sb);
bas_end = bas_colon;
}
}
if has_upper_word(tokens, bas_from, bas_end) || has_anon_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.manuscript_ex |= has_manuscript_ex(tokens, bas_from, bas_end);
s.basionym_present = true;
s.basionym.sanctioning_author = bas_sanctioning;
take_sanctioning_year(&tokens[bas_end..close], &mut s.basionym);
} 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;
} else if let Some((bas_from, bas_end)) = unclosed_basionym(tokens, i) {
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;
i = bas_end;
}
}
if i < n {
let comb_from = i;
let mut comb_end = n;
let mut comb_sanctioning = None;
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() {
comb_sanctioning = Some(sb);
comb_end = colon;
}
}
}
let mut sanctioning_from = comb_end;
if s.unparsed_from < 0 {
if let Some(k) = sentence_after_authorship(tokens, comb_from, comb_end)
.or_else(|| stray_lower_word(tokens, comb_from, comb_end, s.basionym_present))
{
s.unparsed_from = k as i32;
s.unparsed_text = Some(spaced_text(&tokens[k..n]));
comb_end = k;
comb_sanctioning = None;
sanctioning_from = n;
}
}
let yr = parse_authors(tokens, comb_from, comb_end, &mut s.combination);
s.year_range |= yr;
s.manuscript_ex |= has_manuscript_ex(tokens, comb_from, comb_end);
s.combination_year_after_comma = (comb_from..comb_end)
.find(|&k| is_year(&tokens[k]))
.is_some_and(|k| k > comb_from && tokens[k - 1].kind == TokenKind::Comma);
s.combination_initials_first = (comb_from..comb_end).any(|k| {
let initial = |j: usize| {
j + 1 < comb_end
&& tokens[j].kind == TokenKind::Word
&& tokens[j].text.chars().count() == 1
&& is_all_upper(&tokens[j].text)
&& tokens[j + 1].kind == TokenKind::Dot
};
let mut j = k;
while initial(j) {
j += 2;
}
j > k
&& j < comb_end
&& tokens[j].kind == TokenKind::Word
&& starts_upper(&tokens[j].text)
&& contains_lower(&tokens[j].text)
});
s.has_filius |= contains_filius_suffix(tokens, comb_from, comb_end);
s.combination.sanctioning_author = comb_sanctioning;
take_sanctioning_year(&tokens[sanctioning_from..n], &mut s.combination);
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
}
const LOWER_AUTHOR_WORDS: &[&str] = &[
"ex", "et", "and", "und", "den", "dem", "ver", "fils", "fratr", "frat", "fratt", "mss", "msc",
"mscr", "hort", "apud", "litt", "herb", "sched",
];
fn stray_lower_word(tokens: &[Token], from: usize, to: usize, after_author: bool) -> Option<usize> {
let mut depth = 0i32;
let mut seen_author = after_author;
for k in from..to {
let t = &tokens[k];
match t.kind {
TokenKind::OpenParen | TokenKind::OpenBracket => depth += 1,
TokenKind::CloseParen | TokenKind::CloseBracket => depth -= 1,
_ => {}
}
if depth != 0 || t.kind != TokenKind::Word {
continue;
}
if starts_upper(&t.text) {
seen_author = true;
continue;
}
let after_word = k > from && tokens[k - 1].kind == TokenKind::Word;
let glued_before = k > 0 && tokens[k - 1].end == t.start;
let glued_after = tokens.get(k + 1).is_some_and(|nx| {
nx.start == t.end && matches!(nx.kind, TokenKind::Word | TokenKind::Other)
});
let w = t.text.as_str();
let next_lower = tokens.get(k + 1).filter(|nx| {
k + 1 < to
&& nx.kind == TokenKind::Word
&& nx.text.chars().count() >= 3
&& nx.text.chars().all(|c| c.is_lowercase())
&& !is_particle(&nx.text)
&& nx.text != "the"
});
if w == "of" && next_lower.is_some() {
return Some(k);
}
if seen_author
&& !glued_before
&& w.chars().count() >= 3
&& rank_markers::match_infraspecific(w).is_some()
{
return Some(k);
}
if seen_author
&& !after_word
&& !glued_before
&& !glued_after
&& w.chars().count() >= 3
&& w.chars().all(|c| c.is_alphabetic() && c.is_lowercase())
&& !is_particle(w)
&& !AUTHOR_SUFFIXES.contains(&w)
&& !LOWER_AUTHOR_WORDS.contains(&w)
&& !ANON_WORDS.contains(&w)
{
return Some(k);
}
}
None
}
fn sentence_after_authorship(tokens: &[Token], from: usize, to: usize) -> Option<usize> {
let word_at = |k: usize| k < to && tokens[k].kind == TokenKind::Word;
let lower_word_at = |k: usize| {
word_at(k)
&& tokens[k].text.chars().all(|c| c.is_lowercase())
&& !is_particle(&tokens[k].text)
};
let name_after_ampersand = tokens[from].kind == TokenKind::Ampersand
&& word_at(from + 1)
&& starts_upper(&tokens[from + 1].text)
&& (lower_word_at(from + 2)
|| (from + 2 < to
&& tokens[from + 2].kind == TokenKind::Dot
&& lower_word_at(from + 3)));
if name_after_ampersand {
return Some(from);
}
let epithet_before = from > 0 && {
let w = tokens[from - 1].text.as_str();
tokens[from - 1].kind == TokenKind::Word
&& w.chars().count() >= 5
&& w.chars().all(|c| c.is_lowercase())
&& rank_markers::match_infraspecific_allow_notho(w).is_none()
&& rank_markers::match_infrageneric_allow_notho(w).is_none()
};
let prose_after = word_at(from + 1)
&& starts_upper(&tokens[from + 1].text)
&& contains_lower(&tokens[from + 1].text)
&& word_at(from + 2)
&& tokens[from + 2].text.chars().all(|c| c.is_lowercase())
&& !is_particle(&tokens[from + 2].text)
&& !LOWER_AUTHOR_WORDS.contains(&tokens[from + 2].text.as_str());
if tokens[from].kind == TokenKind::Dot && epithet_before && prose_after {
return Some(from + 1);
}
let mut depth = 0i32;
for k in from..to {
match tokens[k].kind {
TokenKind::OpenParen | TokenKind::OpenBracket => depth += 1,
TokenKind::CloseParen | TokenKind::CloseBracket => depth -= 1,
_ => {}
}
if depth == 0
&& is_year(&tokens[k])
&& tokens[k].text.chars().count() == 4
&& k + 1 < to
&& matches!(tokens[k + 1].kind, TokenKind::Dot | TokenKind::Semicolon)
&& word_at(k + 2)
{
return Some(k + 2);
}
}
None
}
fn unclosed_basionym(tokens: &[Token], open: usize) -> Option<(usize, usize)> {
let mut from = open + 1;
while from < tokens.len() && tokens[from].kind == TokenKind::OpenParen {
from += 1;
}
if tokens[from..]
.iter()
.any(|t| t.kind == TokenKind::CloseParen)
{
return None;
}
let surname_at = |k: usize| {
tokens
.get(k)
.is_some_and(|t| t.kind == TokenKind::Word && starts_upper(&t.text))
};
(from..tokens.len()).find_map(|k| {
let t = &tokens[k];
if is_year(t) && k > from && surname_at(k + 1) {
return Some((from, k + 1));
}
let filius = t.kind == TokenKind::Word
&& AUTHOR_SUFFIXES.contains(&t.text.as_str())
&& k > from
&& tokens.get(k + 1).is_some_and(|d| d.kind == TokenKind::Dot)
&& surname_at(k + 2)
&& contains_lower(&tokens[k + 2].text);
filius.then_some((from, k + 2))
})
}
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 after_separator: Vec<usize> = Vec::new();
let mut ex_after_separator: Vec<usize> = Vec::new();
let mut cur = String::new();
let mut year_range = false;
let mut bracketed_year: Option<String> = None;
let mut i = from;
let team_has_generation = tokens[from..to].windows(2).any(|w| {
w[0].kind == TokenKind::Word
&& contains_lower(&w[0].text)
&& w[1].kind == TokenKind::Word
&& starts_upper(&w[1].text)
&& GENERATIONAL_SUFFIXES.contains(&w[1].text.to_uppercase().as_str())
});
let brackets = BracketedAuthors::read(tokens, from, to);
while i < to {
if brackets.skip.is_some_and(|(start, _)| i == start) {
i = brackets.skip.expect("just checked").1;
continue;
}
if brackets.ex_at == Some(i) {
start_ex_authors(
&mut cur,
&mut authors,
&mut ex_authors,
&mut after_separator,
&mut ex_after_separator,
);
i += 1;
continue;
}
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 {
bracketed_year.get_or_insert(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.eq_ignore_ascii_case("imprint") || t.text.eq_ignore_ascii_case("not"))
&& into.year.is_some()
&& i > from
&& matches!(
tokens[i - 1].kind,
TokenKind::OpenParen | TokenKind::OpenBracket
)
&& i + 1 < to
&& tokens[i + 1].kind == TokenKind::Number
&& tokens[i + 1].text.chars().count() == 4
{
i += 1;
continue;
}
if let Some(len) = manuscript_ex_at(tokens, i, to) {
start_ex_authors(
&mut cur,
&mut authors,
&mut ex_authors,
&mut after_separator,
&mut ex_after_separator,
);
i += len;
continue;
}
if t.kind == TokenKind::Word && t.text == "ex" {
start_ex_authors(
&mut cur,
&mut authors,
&mut ex_authors,
&mut after_separator,
&mut ex_after_separator,
);
i += 1;
continue;
}
if t.kind == TokenKind::Word && t.text == "y" && y_joins_surnames(tokens, i, from, to) {
cur.push_str(" y");
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);
after_separator.push(authors.len());
i += 1;
continue;
}
if t.kind == TokenKind::Semicolon {
flush(&mut cur, &mut authors);
after_separator.push(authors.len());
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();
let dotted = i + 1 < to && tokens[i + 1].kind == TokenKind::Dot;
let generation_i = text == "I"
&& if dotted {
starts_with_initial(&cur) && author_ends_at(tokens, i + 2, to)
} else {
starts_with_initial(&cur) || team_has_generation
};
if !cur.is_empty()
&& contains_lower(&cur)
&& !cur.ends_with('.')
&& !ends_with_particle_only(&cur)
&& (generation_i || GENERATIONAL_SUFFIXES.contains(&text.to_uppercase().as_str()))
{
append_space(&mut cur);
cur.push_str(&text.to_uppercase());
i += 1 + usize::from(generation_i && dotted);
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 particle_initials = String::new();
if j > i + 1 {
j = take_initials_run(tokens, j, to, &mut initials);
if j + 2 < to
&& tokens[j].kind == TokenKind::Word
&& starts_lower(&tokens[j].text)
&& is_particle(&tokens[j].text)
&& tokens[j + 1].kind == TokenKind::Word
&& tokens[j + 1].text.chars().count() == 1
&& is_all_upper(&tokens[j + 1].text)
&& tokens[j + 2].kind == TokenKind::Dot
{
let mut after = String::new();
let end = take_initials_run(tokens, j + 1, to, &mut after);
particle_initials =
format!("{} {}", tokens[j].text, format_initials(&after));
j = end;
}
}
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 generation = generation_after_initials(tokens, k, to);
let middle_initial_surname_follows = generation.is_none()
&& j > i + 1
&& k < to
&& tokens[k].kind == TokenKind::Word
&& ((starts_upper(&tokens[k].text) && contains_lower(&tokens[k].text))
|| particle_surname_at(tokens, k, to));
if !middle_initial_surname_follows {
let surname = cur.trim().to_string();
cur.clear();
let mut author = format!(
"{}{}{}",
format_initials(&initials),
particle_initials,
surname
);
if let Some((suffix, next)) = generation {
author.push(' ');
author.push_str(&suffix);
k = next;
}
authors.push(author);
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())
&& manuscript_ex_at(tokens, i, to).is_none()
{
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 == "'"
&& ((i > from && tokens[i - 1].kind == TokenKind::Number)
|| (i + 1 < to && tokens[i + 1].kind == TokenKind::Number))
{
i += 1;
continue;
}
if t.kind == TokenKind::Other
&& t.text == "'"
&& cur.is_empty()
&& tokens.get(i + 1).is_some_and(|nx| {
nx.kind == TokenKind::Word && nx.start == t.end && starts_upper(&nx.text)
})
&& !tokens[i + 1..to]
.iter()
.any(|q| q.kind == TokenKind::Other && q.text == "'")
{
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 let Some(year) = bracketed_year {
if into.year.is_none() {
into.year = Some(year);
} else if into.imprint_year.is_none() {
into.imprint_year = Some(year);
}
}
if authors.len() == 1 && is_anon_word(&authors[0]) {
authors.clear();
into.anonymous = true;
}
if brackets.attributed {
into.anonymous = true;
}
if authors.is_empty() && !into.anonymous {
if let Some(ex) = ex_authors.take() {
authors = ex;
after_separator = std::mem::take(&mut ex_after_separator);
}
}
if !authors.is_empty() {
into.authors = invert_all(&authors, &after_separator);
}
if let Some(ex) = ex_authors {
if !ex.is_empty() {
into.ex_authors = invert_all(&ex, &ex_after_separator);
}
}
year_range
}
fn invert_all(authors: &[String], after_separator: &[usize]) -> 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 !after_separator.contains(&(i + 1)) {
let joins = match cjk_names::given_name_after(cur, next) {
Some(GivenName::Hyphenated) => true,
Some(GivenName::Joined) => !authors
.iter()
.enumerate()
.any(|(j, a)| j != i && j != i + 1 && cjk_names::is_bare_surname(a)),
None => false,
};
if joins {
out.push(format!("{next} {cur}"));
i += 2;
continue;
}
}
if after_separator.contains(&(i + 1)) && cur != "L." {
if let Some(surname) = shared_surname(cur, next) {
out.push(format!("{cur}{surname}"));
i += 1;
continue;
}
}
let joinable = !after_separator.contains(&(i + 1))
|| (!cur.ends_with('.') && !has_capital_run(next));
if joinable && 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 shared_surname<'a>(cur: &str, next: &'a str) -> Option<&'a str> {
let one_initial = |s: &str| {
let mut cs = s.chars();
cs.next().is_some_and(char::is_uppercase) && cs.next() == Some('.')
};
if cur.chars().count() != 2 || !one_initial(cur) || !one_initial(next) {
return None;
}
let surname = next[next.find('.')? + 1..].trim_start();
let mut cs = surname.chars();
(cs.next().is_some_and(char::is_uppercase) && cs.next().is_some_and(char::is_lowercase))
.then_some(surname)
}
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 take_initials_run(tokens: &[Token], mut j: usize, to: usize, out: &mut String) -> usize {
while j < to
&& tokens[j].kind == TokenKind::Word
&& tokens[j].text.chars().count() == 1
&& is_all_upper(&tokens[j].text)
&& ((j + 1 < to && tokens[j + 1].kind == TokenKind::Dot)
|| tokens[j].start == tokens[j - 1].end
|| (tokens[j].text != "I" && author_ends_at(tokens, j + 1, to)))
{
out.push_str(&tokens[j].text);
j += 1;
while j < to && tokens[j].kind == TokenKind::Dot {
out.push('.');
j += 1;
}
}
j
}
fn author_ends_at(tokens: &[Token], k: usize, to: usize) -> bool {
if k >= to {
return true;
}
let t = &tokens[k];
match t.kind {
TokenKind::Comma
| TokenKind::Semicolon
| TokenKind::Ampersand
| TokenKind::Number
| TokenKind::CloseParen
| TokenKind::CloseBracket => true,
TokenKind::Word => {
["in", "ex", "y"].contains(&t.text.as_str())
|| t.text.eq_ignore_ascii_case("and")
|| t.text.eq_ignore_ascii_case("et")
}
_ => false,
}
}
fn y_joins_surnames(tokens: &[Token], i: usize, from: usize, to: usize) -> bool {
let left = match tokens[from..i].iter().rev().take(2).collect::<Vec<_>>()[..] {
[w, ..] if w.kind == TokenKind::Word => w,
[d, w] if d.kind == TokenKind::Dot && w.kind == TokenKind::Word => w,
_ => return false,
};
let right = tokens[i + 1..to]
.iter()
.take_while(|t| t.kind == TokenKind::Word)
.find(|t| !double_surnames::skips(&t.text));
right.is_some_and(|right| double_surnames::joins(&left.text, &right.text))
}
fn particle_surname_at(tokens: &[Token], mut k: usize, to: usize) -> bool {
let start = k;
while k < to
&& tokens[k].kind == TokenKind::Word
&& starts_lower(&tokens[k].text)
&& is_particle(&tokens[k].text)
{
k += 1;
while k < to && tokens[k].kind == TokenKind::Dot {
k += 1;
}
}
let initial_follows = k + 1 < to
&& tokens[k + 1].kind == TokenKind::Word
&& tokens[k + 1].text.chars().count() == 1
&& is_all_upper(&tokens[k + 1].text);
k > start
&& k < to
&& tokens[k].kind == TokenKind::Word
&& starts_upper(&tokens[k].text)
&& contains_lower(&tokens[k].text)
&& !initial_follows
}
fn generation_after_initials(tokens: &[Token], k: usize, to: usize) -> Option<(String, usize)> {
if k >= to || tokens[k].kind != TokenKind::Word {
return None;
}
let text = &tokens[k].text;
let dotted = k + 1 < to && tokens[k + 1].kind == TokenKind::Dot;
let next = if dotted { k + 2 } else { k + 1 };
let upper = text.to_uppercase();
if GENERATIONAL_SUFFIXES.contains(&upper.as_str()) || (text == "I" && !dotted) {
return Some((upper, next));
}
let lower = text.to_lowercase();
if ["jr", "junior", "jun", "sr", "senior", "sen"].contains(&lower.as_str()) {
let dot = if dotted { "." } else { "" };
let suffix = format!("{}{}{dot}", &upper[..1], &lower[1..]);
return Some((suffix, next));
}
None
}
fn has_capital_run(s: &str) -> bool {
let mut prev_upper = false;
for c in s.chars() {
let upper = c.is_uppercase();
if upper && prev_upper {
return true;
}
prev_upper = upper;
}
false
}
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 starts_with_initial(cur: &str) -> bool {
let mut cs = cur.chars();
cs.next().is_some_and(char::is_uppercase) && cs.next() == Some('.')
}
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 take_sanctioning_year(tokens: &[Token], auth: &mut Authorship) {
if auth.year.is_none()
&& auth
.sanctioning_author
.as_deref()
.is_some_and(is_sanctioning_author)
{
auth.year = tokens
.iter()
.find(|t| {
t.kind == TokenKind::Number
&& t.text.len() == 4
&& t.text
.parse::<u16>()
.is_ok_and(|y| (1700..2100).contains(&y))
})
.map(|t| t.text.clone());
}
}
pub(crate) fn is_sanctioning_author(author: &str) -> bool {
["Fr", "Fries", "Pers", "Persoon"].iter().any(|f| {
author
.strip_prefix(f)
.is_some_and(|rest| !rest.starts_with(char::is_alphabetic))
})
}
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 spaced_text(tokens: &[Token]) -> String {
let mut sb = String::new();
for (k, t) in tokens.iter().enumerate() {
if k > 0 && tokens[k - 1].end < t.start {
sb.push(' ');
}
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) || is_elided_particle_surname(&t.text))
})
}
fn is_elided_particle_surname(s: &str) -> bool {
s.split('\'').skip(1).any(starts_upper)
}
fn is_anon_word(s: &str) -> bool {
let word = s.trim_end_matches('.');
ANON_WORDS.iter().any(|a| word.eq_ignore_ascii_case(a))
}
fn has_anon_word(tokens: &[Token], from: usize, to: usize) -> bool {
tokens[from..to]
.iter()
.any(|t| t.kind == TokenKind::Word && is_anon_word(&t.text))
}
fn manuscript_ex_at(tokens: &[Token], i: usize, to: usize) -> Option<usize> {
let t = &tokens[i];
if t.kind != TokenKind::Word || !matches!(t.text.as_str(), "ms" | "MS" | "Ms" | "mss" | "MSS") {
return None;
}
let mut k = i + 1;
if k < to && tokens[k].kind == TokenKind::Dot {
k += 1;
}
let author_follows = k + 1 < to
&& tokens[k].kind == TokenKind::Comma
&& tokens[k + 1].kind == TokenKind::Word
&& (starts_upper(&tokens[k + 1].text) || is_particle(&tokens[k + 1].text));
(i > 0 && author_follows).then_some(k + 1 - i)
}
pub(crate) fn has_manuscript_ex(tokens: &[Token], from: usize, to: usize) -> bool {
(from..to).any(|k| manuscript_ex_at(tokens, k, to).is_some())
}
fn start_ex_authors(
cur: &mut String,
authors: &mut Vec<String>,
ex_authors: &mut Option<Vec<String>>,
after_separator: &mut Vec<usize>,
ex_after_separator: &mut Vec<usize>,
) {
flush(cur, authors);
*ex_authors = Some(std::mem::take(authors));
*ex_after_separator = std::mem::take(after_separator);
}
fn is_year(t: &Token) -> bool {
t.kind == TokenKind::Number && (3..=4).contains(&t.text.chars().count())
}
#[derive(Debug, Default)]
struct BracketedAuthors {
attributed: bool,
skip: Option<(usize, usize)>,
ex_at: Option<usize>,
}
impl BracketedAuthors {
fn read(tokens: &[Token], from: usize, to: usize) -> Self {
let mut shape = BracketedAuthors::default();
let head = author_head_end(tokens, from, to);
let run = last_ex_outside_brackets(tokens, from, head).map_or(from, |ex| ex + 1);
if run >= head {
return shape;
}
let first = &tokens[run];
if first.kind == TokenKind::OpenBracket {
let Some(close) = matching_bracket(tokens, run, head) else {
return shape;
};
if close + 1 == head && looks_like_author_run(tokens, run + 1, close, false) {
shape.attributed = true;
} else if run == from
&& close + 1 < head
&& tokens[close + 1].kind == TokenKind::Word
&& starts_upper(&tokens[close + 1].text)
&& looks_like_author_run(tokens, run + 1, close, true)
{
if tokens[close - 1].text != "ex" {
shape.ex_at = Some(close);
}
}
} else if first.kind == TokenKind::Word && is_anon_word(&first.text) {
let mut open = run + 1;
if open < head && tokens[open].kind == TokenKind::Dot {
open += 1;
}
if open < head && tokens[open].kind == TokenKind::OpenBracket {
if let Some(close) = matching_bracket(tokens, open, head) {
if close + 1 == head && looks_like_author_run(tokens, open + 1, close, false) {
shape.attributed = true;
shape.skip = Some((run, open));
}
}
}
}
shape
}
}
fn author_head_end(tokens: &[Token], from: usize, to: usize) -> usize {
let mut depth = 0i32;
let mut end = to;
for j in from..to {
match tokens[j].kind {
TokenKind::OpenBracket if j + 1 < to && is_year(&tokens[j + 1]) => {
end = j;
break;
}
TokenKind::OpenBracket => depth += 1,
TokenKind::CloseBracket => depth -= 1,
TokenKind::Number if depth == 0 && is_year(&tokens[j]) => {
end = j;
break;
}
_ => {}
}
}
while end > from && tokens[end - 1].kind == TokenKind::Comma {
end -= 1;
}
end
}
fn last_ex_outside_brackets(tokens: &[Token], from: usize, to: usize) -> Option<usize> {
let mut depth = 0i32;
let mut last = None;
for (j, t) in tokens.iter().enumerate().take(to).skip(from) {
match t.kind {
TokenKind::OpenBracket => depth += 1,
TokenKind::CloseBracket => depth -= 1,
TokenKind::Word if depth == 0 && t.text == "ex" => last = Some(j),
_ => {}
}
}
last
}
fn matching_bracket(tokens: &[Token], open: usize, to: usize) -> Option<usize> {
let mut depth = 0i32;
for (j, t) in tokens.iter().enumerate().take(to).skip(open) {
match t.kind {
TokenKind::OpenBracket => depth += 1,
TokenKind::CloseBracket => {
depth -= 1;
if depth == 0 {
return Some(j);
}
}
_ => {}
}
}
None
}
fn looks_like_author_run(tokens: &[Token], from: usize, to: usize, trailing_ex: bool) -> bool {
if from >= to || !matches!(tokens[to - 1].kind, TokenKind::Word | TokenKind::Dot) {
return false;
}
let mut surname = false;
for (j, t) in tokens.iter().enumerate().take(to).skip(from) {
match t.kind {
TokenKind::Word => {
let word = t.text.as_str();
let lower = word.to_lowercase();
if lower == "in" || lower == "apud" {
return false;
}
if starts_upper(word) || is_elided_particle_surname(word) {
if BRACKET_NOTE_WORDS.contains(&lower.as_str()) {
return false;
}
surname |= word.chars().filter(|c| c.is_alphabetic()).count() >= 2;
} else if !(is_particle(word)
|| matches!(word, "et" | "and" | "y" | "al")
|| AUTHOR_SUFFIXES.contains(&lower.as_str())
|| is_anon_word(word)
|| (trailing_ex && word == "ex" && j + 1 == to))
{
return false;
}
}
TokenKind::Dot | TokenKind::Comma | TokenKind::Ampersand => {}
TokenKind::Other if t.text == "-" || t.text == "'" => {}
_ => return false,
}
}
surname
}
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 || tokens[j - 1].kind == TokenKind::Dot) {
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 trailing_dotted_initials_keep_their_order() {
assert_eq!(authors(&parse_str("Sars G.O.")), &["G.O.Sars".to_string()]);
assert_eq!(authors(&parse_str("Sars G. O.")), &["G.O.Sars".to_string()]);
assert_eq!(authors(&parse_str("Sars G.O")), &["G.O.Sars".to_string()]);
assert_eq!(
authors(&parse_str("de Souza J.I")),
&["J.I.de Souza".to_string()]
);
assert_eq!(
authors(&parse_str("Smith A.B.C.")),
&["A.B.C.Smith".to_string()]
);
assert_eq!(
authors(&parse_str("Sars G.O. & Smith A.B.")),
&["G.O.Sars".to_string(), "A.B.Smith".to_string()]
);
}
#[test]
fn particle_surname_after_the_initials_keeps_them() {
assert_eq!(
authors(&parse_str("Gosewijn W.J. van Niewenhuizen")),
&["Gosewijn W.J.van Niewenhuizen".to_string()]
);
assert_eq!(
authors(&parse_str("Dumas & Wagner Rafael M. de Souza")),
&["Dumas".to_string(), "Wagner Rafael M.de Souza".to_string()]
);
assert_eq!(
authors(&parse_str("W.J. de Wilde")),
&["W.J.de Wilde".to_string()]
);
assert_eq!(
authors(&parse_str("Zijlstra C. van Hoof R. and Cook R.")),
&[
"C.Zijlstra".to_string(),
"R.van Hoof".to_string(),
"R.Cook".to_string()
]
);
}
#[test]
fn particle_inside_trailing_initials_keeps_one_author() {
assert_eq!(
authors(&parse_str("Sowerby J. de C.")),
&["J.de C.Sowerby".to_string()]
);
assert_eq!(
authors(&parse_str("Sowerby J.de C.")),
&["J.de C.Sowerby".to_string()]
);
assert_eq!(
authors(&parse_str("Cicchino & Castro D. del C.")),
&["Cicchino".to_string(), "D.del C.Castro".to_string()]
);
}
#[test]
fn spaced_undotted_last_initial_keeps_its_place() {
assert_eq!(authors(&parse_str("Sars G. O")), &["G.O.Sars".to_string()]);
assert_eq!(
authors(&parse_str("Machingambi N. M, Dreyer L. L & Roets F.")),
&[
"N.M.Machingambi".to_string(),
"L.L.Dreyer".to_string(),
"F.Roets".to_string()
]
);
assert_eq!(
authors(&parse_str("Sharma Y. P & Mehmood")),
&["Y.P.Sharma".to_string(), "Mehmood".to_string()]
);
assert_eq!(
authors(&parse_str("Balsamo M. F Tongiorgi")),
&["M.Balsamo".to_string(), "F.Tongiorgi".to_string()]
);
}
#[test]
fn generation_after_trailing_initials_stays_behind_the_surname() {
assert_eq!(
authors(&parse_str("Sowerby G.B. II")),
&["G.B.Sowerby II".to_string()]
);
assert_eq!(
authors(&parse_str("Sowerby G. III")),
&["G.Sowerby III".to_string()]
);
assert_eq!(
authors(&parse_str("Sowerby G.B. I")),
&["G.B.Sowerby I".to_string()]
);
assert_eq!(
authors(&parse_str("Schuurmans Stekhoven J.H. Jr")),
&["J.H.Schuurmans Stekhoven Jr".to_string()]
);
assert_eq!(
authors(&parse_str("TURNBOW R. H. JR., FRANKLIN R. T.")),
&["R.H.Turnbow Jr.".to_string(), "R.T.Franklin".to_string()]
);
assert_eq!(authors(&parse_str("Kim I.")), &["I.Kim".to_string()]);
}
#[test]
fn several_middle_initials_before_a_surname_keep_one_author() {
assert_eq!(
authors(&parse_str("Roy G.O. Taylor")),
&["Roy G.O.Taylor".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 an_elided_particle_surname_is_a_basionym_author() {
let s = parse_str("(d'Orbigny, 1826)");
assert!(s.basionym_present);
assert_eq!(s.basionym.authors, vec!["d'Orbigny".to_string()]);
assert_eq!(s.basionym.year, Some("1826".to_string()));
assert_eq!(s.unparsed_from, -1);
let s = parse_str("(d'Urv.) Mill.");
assert_eq!(s.basionym.authors, vec!["d'Urv.".to_string()]);
assert_eq!(s.combination.authors, vec!["Mill.".to_string()]);
}
#[test]
fn basionym_colon_sanctioning_is_kept_on_the_basionym() {
let s = parse_str("(Wulfen : Fr.) Schum.");
assert_eq!(s.basionym.authors, vec!["Wulfen".to_string()]);
assert_eq!(s.basionym.sanctioning_author.as_deref(), Some("Fr."));
assert_eq!(s.combination.authors, vec!["Schum.".to_string()]);
assert_eq!(s.combination.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.combination.sanctioning_author, Some("Fr.".to_string()));
}
#[test]
fn a_basionym_keeps_only_fries_or_persoon_after_its_colon() {
let s = parse_str("(Pers. : Fr)");
assert_eq!(s.basionym.sanctioning_author.as_deref(), Some("Fr"));
let s = parse_str("(Baba 1949: Burn 1962)");
assert_eq!(s.basionym.authors, vec!["Baba".to_string()]);
assert_eq!(s.basionym.sanctioning_author, None);
}
#[test]
fn sanctioning_authors_are_fries_and_persoon() {
for a in ["Fr.", "Fr", "Fries", "Pers.", "Pers", "Persoon"] {
assert!(is_sanctioning_author(a), "{a}");
}
for a in ["Fritsch", "Persson", "2ller", "Burn"] {
assert!(!is_sanctioning_author(a), "{a}");
}
}
#[test]
fn pers_colon_fr_sanctioning() {
let s = parse_str("Pers. : Fr.");
assert_eq!(s.combination.authors, vec!["Pers.".to_string()]);
assert_eq!(s.combination.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 a_bracketed_year_on_its_own_is_the_year() {
let s = parse_str("Fruhstorfer, [1912]");
assert_eq!(s.combination.authors, vec!["Fruhstorfer".to_string()]);
assert_eq!(s.combination.year, Some("1912".to_string()));
assert_eq!(s.combination.imprint_year, None);
}
#[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_after_an_abbreviation_sets_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 y Saez".to_string()]
);
assert_eq!(
authors(&parse_str("Ruiz-Carranza y Lynch")),
&["Ruiz-Carranza".to_string(), "Lynch".to_string()]
);
assert_eq!(
authors(&parse_str("Isbrücker & Nico, 1992 Nijssen, Ortega y Nico")),
&["Isbrücker", "Nico", "Nijssen", "Ortega", "Nico"].map(String::from)
);
}
#[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"
);
}
}
}