use std::borrow::Cow;
use std::sync::LazyLock;
use fancy_regex::Regex as FancyRegex;
use regex::Regex;
use crate::model::{warnings, NamePart, NameType, NomCode, ParsedName, Rank};
use crate::pipeline::ParseContext;
use crate::token;
use crate::unicode::java_trim;
use unicode_normalization::UnicodeNormalization;
pub(crate) fn run(ctx: &mut ParseContext) {
let mut s = ctx.working.clone();
s = repair_colon_diacritics(ctx, s);
s = flag_uncertain_authorship(ctx, s);
s = extract_generic_author(ctx, s);
s = strip_quoted_monomial(ctx, s);
s = apply_missing_genus_placeholder(ctx, s);
s = strip_leading_genus_qualifier(ctx, s);
s = strip_rank_lineage(ctx, s);
s = strip_leading_species_label(ctx, s);
s = strip_infra_rank_letters(ctx, s);
s = normalise_letter_subdivision_marker(ctx, s);
s = repair_question_mark_in_word(ctx, s);
s = strip_strain_designation(ctx, s);
s = stash_trailing_rank_marker_code(ctx, s);
s = stash_organism_label_tail(ctx, s);
s = stash_trailing_strain_code(ctx, s);
s = stash_trailing_culture_accession(ctx, s);
s = stash_bracketed_annotation(ctx, s);
s = stash_underscore_designation(ctx, s);
s = split_underscore_binomial(s);
s = GLUED_ABBREVIATED_AUTHOR.replace(&s, "$1 $2$3").into_owned();
s = strip_imprint_years(ctx, s);
s = strip_null_between_epithets(ctx, s);
s = normalise_hyphens(ctx, s);
s = split_hyphen_glued_author(ctx, s);
s = replace_homoglyphs(ctx, s);
s = repair_win1252_artefacts(ctx, s);
s = normalise_double_underscores(ctx, s);
s = stash_trailing_otu_code(ctx, s);
s = strip_serovar_serotype(ctx, s);
s = strip_angle_bracket_authorship(ctx, s);
s = strip_html(ctx, s);
s = strip_candidatus(ctx, s);
s = normalise_hort_ex_placeholder(ctx, s);
s = strip_cultivar_group_grex(ctx, s);
s = lower_shouted_qualifier(s);
s = strip_rank_nova(ctx, s);
s = strip_quoted_attributed_author(s);
s = strip_quoted_cultivar(ctx, s);
s = strip_extinct_dagger(ctx, s);
s = strip_tinfr_marker(ctx, s);
s = strip_doubtful_genus_brackets(ctx, s);
s = strip_sic_and_corrig(ctx, s);
s = stash_synonym_bracket(ctx, s);
s = strip_quoted_spelling_variant(ctx, s);
s = strip_bracketed_nom_note(ctx, s);
s = strip_nom_note(ctx, s);
s = strip_not_validly_published(ctx, s);
s = strip_authorship_placeholders(ctx, s);
s = strip_trailing_species_word(ctx, s);
s = strip_pro_parte(ctx, s);
s = strip_pro_sp_annotation(ctx, s);
s = strip_approved_lists(ctx, s);
s = strip_mihi(ctx, s);
s = normalise_anon(ctx, s);
s = strip_colon_concept_reference(ctx, s);
s = strip_bracketed_tax_note(ctx, s);
s = strip_paren_tax_note(ctx, s);
s = strip_sensu_lato_remainder(ctx, s);
s = strip_sensu_stricto_ss(ctx, s);
s = strip_tax_note(ctx, s);
s = strip_aggregate_suffix(ctx, s);
s = strip_published_page(ctx, s);
s = strip_in_press(ctx, s);
s = strip_in_author_citations(ctx, s);
s = strip_ipni_citation(ctx, s);
s = strip_period_separated_reference(ctx, s);
s = strip_comma_prefixed_reference(ctx, s);
s = strip_manuscript_marker(ctx, s);
s = strip_supra_rank_prefix(ctx, s);
s = strip_leading_infrageneric_marker(ctx, s);
s = stash_phrase_name(ctx, s);
ctx.working = s;
}
static YEAR_4DIGIT: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?-u:\b\d{4}\b)").unwrap());
fn has_earlier_year(s: &str, end: usize) -> bool {
YEAR_4DIGIT.is_match(&s[..end])
}
fn fancy_replace_all(
re: &FancyRegex,
s: &str,
replacement: impl Fn(&fancy_regex::Captures<'_, str>) -> String,
) -> String {
let mut result = String::with_capacity(s.len());
let mut last = 0usize;
for m in re.captures_iter(s) {
let caps = match m {
Ok(c) => c,
Err(_) => break,
};
let whole = caps.get(0).expect("group 0 is always present in a match");
result.push_str(&s[last..whole.start()]);
result.push_str(&replacement(&caps));
last = whole.end();
}
result.push_str(&s[last..]);
result
}
static TRAILING_QMARK: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?-u:\s\?\s*)$").unwrap());
static UNCERTAIN_AUTHOR_QMARK: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"\p{L}\?\s*(?:$|[&,])").unwrap());
static UNCERTAIN_AUTHOR_OR: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"\p{Lu}\p{L}*\s+or\s+\p{Lu}").unwrap());
static UNCERTAIN_AUTHOR_SLASH: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"\p{L}\s*/\s*\p{L}").unwrap());
fn flag_uncertain_authorship(ctx: &mut ParseContext, mut s: String) -> String {
if TRAILING_QMARK.is_match(&s) {
ctx.name.doubtful = true;
ctx.name.add_warning(warnings::QUESTION_MARKS_REMOVED);
s = java_trim(&TRAILING_QMARK.replace_all(&s, "")).to_string();
}
if UNCERTAIN_AUTHOR_QMARK.is_match(&s)
|| UNCERTAIN_AUTHOR_OR.is_match(&s)
|| UNCERTAIN_AUTHOR_SLASH.is_match(&s)
{
ctx.name.doubtful = true;
ctx.name.add_warning(warnings::UNCERTAIN_AUTHORSHIP);
}
s
}
static INFRAGEN_AUTHOR_BEFORE_MARKER: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(
r"^((?:[×xX]\s?)?\p{Lu}[\p{Ll}]+)\s+((?:\(\s*[^()]*\)\s*)?\p{Lu}[\p{L}.'\-]*(?:\s+\p{Lu}[\p{L}.'\-]*)*)\s+((?:notho)?(?:subg|subgen|subgenus|sect|subsect|supersect|ser|subser|superser|divisio|div|tr|subtr|unr)\.?\s+\p{Lu}[\p{Ll}]+)$",
)
.unwrap()
});
fn extract_generic_author(ctx: &mut ParseContext, s: String) -> String {
if let Some(caps) = INFRAGEN_AUTHOR_BEFORE_MARKER.captures(&s) {
let author = caps.get(2).unwrap().as_str();
ctx.pending_generic_author = Some(java_trim(author).to_string());
return format!(
"{} {}",
caps.get(1).unwrap().as_str(),
caps.get(3).unwrap().as_str()
);
}
s
}
static QUOTED_MONOMIAL: LazyLock<FancyRegex> =
LazyLock::new(|| FancyRegex::new(r#"^(['"])\s*([\p{Lu}][\p{L}-]+)\s*\1(\s+.+)?$"#).unwrap());
fn strip_quoted_monomial(ctx: &mut ParseContext, s: String) -> String {
if let Ok(Some(caps)) = QUOTED_MONOMIAL.captures(&s) {
ctx.quoted_monomial = Some(caps.get(1).unwrap().as_str().to_string());
ctx.name.doubtful = true;
let tail = caps.get(3).map(|m| m.as_str()).unwrap_or("");
return java_trim(&format!("{}{}", caps.get(2).unwrap().as_str(), tail)).to_string();
}
s
}
static MISSING_GENUS_EPITHET: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"^[a-z][a-z\-]+(?-u:\s+)\p{Lu}.*$").unwrap());
static MISSING_GENUS_NOTE_KEYWORD: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"^(?:non|nec|not|sensu|sec|auct|auctt|fide|emend|ss|s|cf|aff|hort)(?-u:\b).*$")
.unwrap()
});
fn first_word(s: &str) -> &str {
match s.find(token::is_whitespace_java) {
Some(idx) => &s[..idx],
None => s,
}
}
fn apply_missing_genus_placeholder(ctx: &mut ParseContext, s: String) -> String {
let mut missing: Option<String> = None;
let mut emit_warning = false;
if s.starts_with("\"? ") || s.starts_with("\"?\t") {
let rest: String = s.chars().skip(3).collect();
missing = Some(format!("? {}", java_trim(&rest)));
} else if let Some(rest) = s
.strip_prefix('?')
.map(java_trim)
.filter(|r| r.chars().next().is_some_and(char::is_lowercase))
{
missing = Some(format!("? {rest}"));
} else if s.starts_with("Missing ") {
let rest: String = s.chars().skip(8).collect();
if rest.chars().next().is_some_and(|c| c.is_lowercase()) {
missing = Some(format!("? {rest}"));
}
} else if s.chars().count() > 1
&& s.chars().next().is_some_and(|c| c.is_lowercase())
&& MISSING_GENUS_EPITHET.is_match(&s)
&& !MISSING_GENUS_NOTE_KEYWORD.is_match(&s)
&& !token::is_particle(first_word(&s))
{
missing = Some(format!("? {s}"));
emit_warning = true;
}
if let Some(missing) = missing {
ctx.name.type_ = NameType::Placeholder;
if emit_warning {
ctx.name.add_warning(warnings::MISSING_GENUS);
}
return missing;
}
s
}
static LEADING_GENUS_QUALIFIER: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"^(?:(\?)(?-u:\s*)|(?i:(cf|aff))\.?(?-u:\s+))((?:<[^>]+>)?\p{Lu}\p{Ll}.*)$")
.unwrap()
});
fn strip_leading_genus_qualifier(ctx: &mut ParseContext, s: String) -> String {
let Some(caps) = LEADING_GENUS_QUALIFIER.captures(&s) else {
return s;
};
if caps.get(1).is_some() {
ctx.name.set_epithet_qualifier(NamePart::Generic, "?");
ctx.name.doubtful = true;
ctx.name.add_warning(warnings::QUESTION_MARKS_REMOVED);
} else {
let q = format!("{}.", caps[2].to_ascii_lowercase());
ctx.name.set_epithet_qualifier(NamePart::Generic, &q);
}
ctx.qualified_genus = true;
caps[3].to_string()
}
static LINEAGE_HEAD_PAIR: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(&format!(
r"^(?:{LINEAGE_MARKERS})\.(?-u:\s+)[\p{{Lu}}][\p{{L}}]+(?-u:\s+)((?:{LINEAGE_MARKERS})\..+)$"
))
.unwrap()
});
static LINEAGE_LAST: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(&format!(
r"^(?:\(({LINEAGE_MARKERS})\.(?-u:\s+)([\p{{Lu}}][\p{{L}}]+)\)|({LINEAGE_MARKERS})\.(?-u:\s+)([\p{{Lu}}][\p{{L}}]+(?:(?-u:\s).*)?))$"
))
.unwrap()
});
const LINEAGE_MARKERS: &str =
"phy|subphy|cla|subc|infc|supo|ord|subo|info|supf|fam|subf|supergen|gen";
fn lineage_marker_rank(marker: &str) -> Option<Rank> {
Some(match marker {
"phy" => Rank::Phylum,
"subphy" => Rank::Subphylum,
"cla" => Rank::Class,
"subc" => Rank::Subclass,
"infc" => Rank::Infraclass,
"supo" => Rank::Superorder,
"ord" => Rank::Order,
"subo" => Rank::Suborder,
"info" => Rank::Infraorder,
"supf" => Rank::Superfamily,
"fam" => Rank::Family,
"subf" => Rank::Subfamily,
"supergen" => Rank::Supergenus,
"gen" => Rank::Genus,
_ => return None,
})
}
fn strip_rank_lineage(ctx: &mut ParseContext, s: String) -> String {
let mut path = s.as_str();
while let Some(caps) = LINEAGE_HEAD_PAIR.captures(path) {
path = caps.get(1).unwrap().as_str();
}
let Some(caps) = LINEAGE_LAST.captures(path) else {
return s;
};
let (marker, taxon) = match (caps.get(1), caps.get(3)) {
(Some(m), _) => (m.as_str(), caps.get(2).unwrap().as_str()),
(None, Some(m)) => (m.as_str(), caps.get(4).unwrap().as_str()),
(None, None) => return s,
};
match lineage_marker_rank(marker) {
Some(rank) => {
ctx.name.rank = rank;
taxon.to_string()
}
None => s,
}
}
static LEADING_SPECIES_LABEL: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(
r"^(?:[Ss]p|[Ss]pec)\.(?-u:\s+)([\p{Lu}][\p{L}.]*(?:(?-u:\s+)\([\p{Lu}][\p{L}]*\))?(?-u:\s+)[\p{Ll}].*)$",
)
.unwrap()
});
static BINOMIAL_HEAD: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(
r"^[\p{Lu}][\p{L}.]*(?:(?-u:\s+)\([\p{Lu}][\p{L}]*\))?(?-u:\s+)[\p{Ll}][\p{L}\-]*(?:(?-u:\s+)[^\p{Ll}].*)?$",
)
.unwrap()
});
fn strip_leading_species_label(ctx: &mut ParseContext, s: String) -> String {
let Some(caps) = LEADING_SPECIES_LABEL.captures(&s) else {
return s;
};
let name = caps[1].to_string();
if BINOMIAL_HEAD.is_match(&name) {
ctx.name.rank = Rank::Species;
}
name
}
static GREEK_MARKER_TEST: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"[\p{Ll}.](?-u:\s*)[\x{03B1}-\x{03C9}\x{237A}](?:(?-u:\s+)|\.(?-u:\s*))\p{Ll}")
.unwrap()
});
static STAR_MARKER_TEST: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"\p{Ll}(?-u:\s+)\*+(?-u:\s+)\p{Ll}").unwrap());
static GREEK_MARKER: LazyLock<FancyRegex> = LazyLock::new(|| {
FancyRegex::new(
r"([\p{Ll}.])[ \t\n\x0B\f\r]*[\x{03B1}-\x{03C9}\x{237A}](?:[ \t\n\x0B\f\r]+|\.[ \t\n\x0B\f\r]*)(?=[\p{Ll}])",
)
.unwrap()
});
static STAR_MARKER: LazyLock<FancyRegex> = LazyLock::new(|| {
FancyRegex::new(r"(?<=\p{Ll})[ \t\n\x0B\f\r]+\*+[ \t\n\x0B\f\r]+(?=\p{Ll})").unwrap()
});
fn strip_infra_rank_letters(_ctx: &mut ParseContext, s: String) -> String {
if s.contains('\u{237A}') || GREEK_MARKER_TEST.is_match(&s) || STAR_MARKER_TEST.is_match(&s) {
let s = fancy_replace_all(&GREEK_MARKER, &s, |caps| format!("{} ", &caps[1]));
return fancy_replace_all(&STAR_MARKER, &s, |_| " ".to_string());
}
s
}
static LETTER_SUBDIVISION_MARKER: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(
r"^(\p{Lu}[\p{Ll}-]+\s+[\p{Ll}][\p{Ll}-]+(?:\s+\p{Lu}[\p{Ll}]*\.?)*)\s+((?:[a-z]\.){1,3}[a-z]?)\s+([\p{Ll}][\p{Ll}-]{2,})\s*$",
)
.unwrap()
});
const LETTER_SUBDIVISION: &str = "infrasubdivision";
const KNOWN_INFRASPECIFIC_MARKERS: &[&str] = &[
LETTER_SUBDIVISION,
"subsp",
"ssp",
"var",
"subvar",
"subv",
"f",
"forma",
"form",
"fo",
"subf",
"subforma",
"pv",
"pathovar",
"bv",
"biovar",
"ct",
"chemoform",
"sv",
"serovar",
"morph",
"morphovar",
"phagovar",
"nat",
"natio",
"mut",
"mutatio",
"agamosp",
"agamossp",
"agamovar",
"conv",
"convar",
"subspec",
"variety",
"fm",
"fma",
"prol",
"proles",
"ab",
"aberration",
"strain",
"str",
"st",
"*",
];
fn is_known_infraspecific_marker(word: &str) -> bool {
KNOWN_INFRASPECIFIC_MARKERS.contains(&word.to_lowercase().as_str())
}
fn normalise_letter_subdivision_marker(_ctx: &mut ParseContext, s: String) -> String {
if let Some(caps) = LETTER_SUBDIVISION_MARKER.captures(&s) {
let marker = caps.get(2).unwrap().as_str();
let segments: Vec<&str> = marker.split('.').filter(|seg| !seg.is_empty()).collect();
let real_marker = segments.len() == 1 && is_known_infraspecific_marker(segments[0]);
if !real_marker {
let g1 = caps.get(1).unwrap().as_str();
let g3 = caps.get(3).unwrap().as_str();
return format!("{g1} {LETTER_SUBDIVISION} {g3}");
}
}
s
}
static LETTER_QMARK_LETTER: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"\p{L}\?\p{L}").unwrap());
static QMARK_BETWEEN_LETTERS: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(\p{L})\?(\p{L})").unwrap());
static LETTER_FFFD_LETTER: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(\p{L})\x{FFFD}+(\p{L})").unwrap());
fn remove_replacement_characters(name: &mut ParsedName, mut s: String) -> String {
if s.contains('\u{FFFD}') && LETTER_FFFD_LETTER.is_match(&s) {
while LETTER_FFFD_LETTER.is_match(&s) {
s = LETTER_FFFD_LETTER.replace_all(&s, "$1$2").into_owned();
}
name.doubtful = true;
name.add_warning(warnings::UNUSUAL_CHARACTERS);
}
s
}
fn remove_qmarks_between_letters(mut s: String) -> String {
while LETTER_QMARK_LETTER.is_match(&s) {
s = QMARK_BETWEEN_LETTERS.replace_all(&s, "$1$2").into_owned();
}
s
}
fn repair_question_mark_in_word(ctx: &mut ParseContext, s: String) -> String {
let s = remove_replacement_characters(&mut ctx.name, s);
if s.contains('?') && LETTER_QMARK_LETTER.is_match(&s) {
let s = remove_qmarks_between_letters(s);
ctx.name.doubtful = true;
ctx.name.add_warning(warnings::QUESTION_MARKS_REMOVED);
return s;
}
s
}
static STRAIN_DESIGNATION: LazyLock<FancyRegex> = LazyLock::new(|| {
FancyRegex::new(
r#"(?i)[ \t\n\x0B\f\r]+(?:str|strain)\b[ \t\n\x0B\f\r]*\.?(?:[ \t\n\x0B\f\r]+(?:str|strain)\b[ \t\n\x0B\f\r]*\.?)*[ \t\n\x0B\f\r]*(['"])(.+?)\1[ \t\n\x0B\f\r]*$"#,
)
.unwrap()
});
fn strip_strain_designation(ctx: &mut ParseContext, s: String) -> String {
if let Ok(Some(caps)) = STRAIN_DESIGNATION.captures(s.as_str()) {
let whole = caps.get(0).unwrap();
let prefix = java_trim(&s[..whole.start()]).to_string();
if !prefix.is_empty() && prefix.chars().next().is_some_and(|c| c.is_uppercase()) {
ctx.name.phrase = Some(java_trim(&caps[2]).to_string());
ctx.name.type_ = NameType::Informal;
return format!("{prefix} str.");
}
}
s
}
static TRAILING_STRAIN_CODE: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(
r"^([\p{Lu}][\p{Ll}]+\s+(?:(?:cf|aff|nr|near)\.?\s+)?[\p{Ll}]+)\s+([dr]?RNA[a-zA-Z0-9_\-]*|[\p{Lu}][\p{L}\d:\-]*\d[\p{L}\d_\-:]*|\d(?:[\p{L}\d_:/.\-]*[\p{L}\d])?)\.?\s*$",
)
.unwrap()
});
static TRAILING_YEAR: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"^(?-u:[12]\d{3})$").unwrap());
static ORGANISM_LABEL_TAIL: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(
r"^((?:Candidatus\s+)?\p{Lu}\p{Ll}+\s+\p{Ll}*(?:bacteri(?:um|a)|archae(?:on|a|ote)|symbionts?))(?:\s+(.+?))?\s*$",
)
.unwrap()
});
fn stash_organism_label_tail(ctx: &mut ParseContext, s: String) -> String {
let Some(caps) = ORGANISM_LABEL_TAIL.captures(&s) else {
return s;
};
match caps.get(2) {
Some(tail) if LABEL_TAIL_AUTHOR.is_match(tail.as_str()) => s,
Some(tail) => {
ctx.name.type_ = NameType::Informal;
ctx.name.phrase = Some(tail.as_str().to_string());
caps[1].to_string()
}
None => {
if s.ends_with("symbiont")
|| s.ends_with("symbionts")
|| LABEL_HIGHER_ANCHOR.is_match(&s)
{
ctx.name.type_ = NameType::Informal;
}
s
}
}
}
static LABEL_TAIL_AUTHOR: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(
r"^\(?\p{Lu}\p{Ll}[\p{L}'.\-]*(?:(?:,? | & | et )\p{Lu}[\p{L}'.\-]+)*(?:,? (?:1[5-9]\d\d|20[0-2]\d))?\)?$",
)
.unwrap()
});
static LABEL_HIGHER_ANCHOR: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"^(?:Candidatus\s+\p{Lu}\p{Ll}+|\p{Lu}\p{Ll}*(?:ales|aceae|ota|etes|ia|ae|mycetes|phyta))\s").unwrap()
});
fn stash_trailing_strain_code(ctx: &mut ParseContext, s: String) -> String {
if let Some(caps) = TRAILING_STRAIN_CODE.captures(&s) {
let head = caps.get(1).unwrap().as_str();
let code = caps.get(2).unwrap().as_str();
if !TRAILING_YEAR.is_match(code)
&& !token::is_numeral_epithet(code)
&& !is_indet_species_marker(second_word(head))
{
ctx.name.phrase = Some(code.to_string());
ctx.name.type_ = NameType::Informal;
return head.to_string();
}
}
s
}
fn second_word(head: &str) -> &str {
head.split_whitespace().nth(1).unwrap_or("")
}
fn is_indet_species_marker(w: &str) -> bool {
w.eq_ignore_ascii_case("sp")
|| w.eq_ignore_ascii_case("spp")
|| w.eq_ignore_ascii_case("spec")
|| w.eq_ignore_ascii_case("species")
}
static TRAILING_RANK_MARKER_CODE: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(
r"^([\p{Lu}][\p{Ll}]+)\s+([\p{Ll}]+)\.?\s+([dr]?RNA[a-zA-Z0-9_\-]*|[\p{Lu}][\p{L}\d:]*\d[\p{L}\d_\-:]*|\d(?:[\p{L}\d_:/.\-]*[\p{L}\d])?)\.?\s*$",
)
.unwrap()
});
fn stash_trailing_rank_marker_code(ctx: &mut ParseContext, s: String) -> String {
let Some(caps) = TRAILING_RANK_MARKER_CODE.captures(&s) else {
return s;
};
let marker = caps.get(2).unwrap();
if is_indet_species_marker(marker.as_str()) || !is_rank_marker_word(marker.as_str()) {
return s;
}
let code_end = caps.get(3).unwrap().end();
ctx.name.phrase = Some(s[marker.start()..code_end].to_string());
ctx.name.type_ = NameType::Informal;
if let Some(rank) = super::rank_markers::match_infraspecific(marker.as_str()) {
ctx.name.rank = rank;
}
caps.get(1).unwrap().as_str().to_string()
}
static BRACKETED_ANNOTATION: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"^([\p{Lu}][\p{Ll}]+)(?-u:\s+)(\[[\p{Lu}][\p{L}\-]+\])(?-u:\s*)$").unwrap()
});
fn stash_bracketed_annotation(ctx: &mut ParseContext, s: String) -> String {
let Some(caps) = BRACKETED_ANNOTATION.captures(&s) else {
return s;
};
ctx.name.phrase = Some(caps[2].to_string());
ctx.name.type_ = NameType::Informal;
caps[1].to_string()
}
static UNDERSCORE_DESIGNATION: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(
r"^([\p{Lu}][\p{Ll}]+(?:(?-u:\s+)[\p{Ll}]+)?)(?-u:\s+)((?:n_)?(sp|ssp|subsp)_[\p{L}\d_]+(?:(?-u:\s+)\[[^\]]*\])?)(?-u:\s*)$",
)
.unwrap()
});
static GLUED_NEW_GENUS: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"^([\p{Lu}][\p{Ll}]+)_(n_gen(?:(?-u:\s+).*)?)$").unwrap());
static NEW_SPECIES_TAG: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?-u:\b)(?:n_)?sp_").unwrap());
static UNDERSCORE_BINOMIAL: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"^(\p{Lu}\p{Ll}+)_(\p{Ll}{3,})(\s|$)").unwrap());
static GLUED_ABBREVIATED_AUTHOR: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"^(\p{Lu}\p{Ll}+\s+\p{Ll}{4,})(\p{Lu}\p{Ll}+\.)(\s|$)").unwrap());
fn split_underscore_binomial(s: String) -> String {
match UNDERSCORE_BINOMIAL.captures(&s) {
Some(caps) if !matches!(&caps[2], "gen" | "genus" | "sp" | "spp" | "ssp" | "subsp") => {
UNDERSCORE_BINOMIAL.replace(&s, "$1 $2$3").into_owned()
}
_ => s,
}
}
fn stash_underscore_designation(ctx: &mut ParseContext, s: String) -> String {
if let Some(caps) = GLUED_NEW_GENUS.captures(&s) {
let tail = java_trim(&caps[2]).to_string();
ctx.name.rank = if NEW_SPECIES_TAG.is_match(&tail) {
Rank::Species
} else {
Rank::Genus
};
ctx.name.phrase = Some(tail);
ctx.name.type_ = NameType::Informal;
return caps[1].to_string();
}
let Some(caps) = UNDERSCORE_DESIGNATION.captures(&s) else {
return s;
};
ctx.name.rank = if &caps[3] == "sp" {
Rank::Species
} else {
Rank::Subspecies
};
ctx.name.phrase = Some(caps[2].to_string());
ctx.name.type_ = NameType::Informal;
caps[1].to_string()
}
static BRACKETED_FAMILY_GROUP: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"^\[[\p{Lu}][\p{Ll}]+(?:idae|inae|oidea|oideae|aceae)\]$").unwrap()
});
pub(crate) fn stash_bracketed_family_group_authorship(
authorship: &str,
name: &mut crate::model::ParsedName,
) -> bool {
let a = java_trim(authorship);
if !BRACKETED_FAMILY_GROUP.is_match(a) {
return false;
}
name.phrase = Some(match name.phrase.take() {
Some(p) if p.contains(a) => p,
Some(p) => format!("{p} {a}"),
None => a.to_string(),
});
name.type_ = NameType::Informal;
true
}
fn is_rank_marker_word(w: &str) -> bool {
rank_of_marker(w).is_some()
}
fn rank_of_marker(w: &str) -> Option<Rank> {
super::rank_markers::match_infrageneric(w)
.or_else(|| super::rank_markers::match_infraspecific(w))
}
static TRAILING_CULTURE_ACCESSION: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(&format!(
r"^([\p{{Lu}}][\p{{Ll}}]+[ ]+[\p{{Ll}}]+)[ ]+({}[ :=_\-]*(?:[A-Z]{{1,4}}\-)?[0-9][0-9A-Za-z.:\-]*)$",
super::culture_collections::acronym_alternation()
))
.unwrap()
});
fn stash_trailing_culture_accession(ctx: &mut ParseContext, s: String) -> String {
if let Some(caps) = TRAILING_CULTURE_ACCESSION.captures(&s) {
ctx.name.phrase = Some(caps.get(2).unwrap().as_str().to_string());
ctx.name.type_ = NameType::Informal;
return caps.get(1).unwrap().as_str().to_string();
}
s
}
static IMPRINT_YEAR_QUOTED: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r#"(?-u:\s*)[\[\(](?-u:\s*)"((?-u:\d{4})(?:[-\x{2013}](?-u:\d{4}))?)"(?-u:\s*)[\]\)](?-u:\s*)\.?(?-u:\s*)$"#).unwrap()
});
static IMPRINT_YEAR_KEYWORD: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"(?i)(?-u:\s*)\((?-u:\s*)(?:imprint|not)(?-u:\s+)((?-u:\d{4})(?:[-\x{2013}](?-u:\d{4}))?)(?-u:\s*)\)(?-u:\s*)\.?(?-u:\s*)$")
.unwrap()
});
static IMPRINT_YEAR_ALT: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?-u:\s+&\s+(\d{4})\s*\.?\s*)$").unwrap());
fn strip_imprint_years(ctx: &mut ParseContext, mut s: String) -> String {
if let Some(caps) = IMPRINT_YEAR_QUOTED.captures(&s) {
let whole = caps.get(0).unwrap();
ctx.set_pending_imprint_year(&caps[1]);
s = java_trim(&s[..whole.start()]).to_string();
}
if let Some(caps) = IMPRINT_YEAR_KEYWORD.captures(&s) {
let whole = caps.get(0).unwrap();
ctx.set_pending_imprint_year(&caps[1]);
s = java_trim(&s[..whole.start()]).to_string();
}
if let Some(caps) = IMPRINT_YEAR_ALT.captures(&s) {
let whole = caps.get(0).unwrap();
if has_earlier_year(&s, whole.start()) {
ctx.set_pending_imprint_year(&caps[1]);
s = java_trim(&s[..whole.start()]).to_string();
}
}
s
}
static NULL_EPITHET_TEST: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"[a-z](?-u:\s+)null(?-u:\s+)[a-z]+").unwrap());
static NULL_EPITHET_MID: LazyLock<FancyRegex> = LazyLock::new(|| {
FancyRegex::new(r"(?<=[a-z])[ \t\n\x0B\f\r]+null[ \t\n\x0B\f\r]+(?=[a-z])").unwrap()
});
fn strip_null_between_epithets(ctx: &mut ParseContext, s: String) -> String {
if NULL_EPITHET_TEST.is_match(&s) {
let s = fancy_replace_all(&NULL_EPITHET_MID, &s, |_| " ".to_string());
ctx.name.doubtful = true;
ctx.name.add_warning(warnings::NULL_EPITHET);
return s;
}
s
}
fn normalise_hyphens(ctx: &mut ParseContext, s: String) -> String {
let before = s.clone();
let s = s.replace(
['\u{2010}', '\u{2011}', '\u{2012}', '\u{2013}', '\u{2014}'],
"-",
);
if s != before {
ctx.name.add_warning(warnings::HOMOGLYHPS);
}
DOTTED_NUMERAL_EPITHET
.replace_all(&s, "$1$2-$3$4")
.into_owned()
}
static DOTTED_NUMERAL_EPITHET: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(\s)(\d{1,2})\.(\p{Ll}{4,})(\s|$)").unwrap());
fn replace_homoglyphs(ctx: &mut ParseContext, s: String) -> String {
let s = match OCR_ZERO.replace_all(&s, "${1}O${2}${3}") {
Cow::Owned(repl) => {
ctx.name.add_warning(warnings::HOMOGLYHPS);
repl
}
Cow::Borrowed(_) => s,
};
if crate::unicode::contains_homoglyphs(&s) {
let repl = crate::unicode::replace_homoglyphs(&s);
if repl != s {
ctx.name.add_warning(warnings::HOMOGLYHPS);
return repl;
}
}
s
}
static OCR_ZERO: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(^|[\s(\[,&])0(\p{Ll}+)([\s.,;)\]]|$)").unwrap());
static HYPHEN_GLUED_AUTHOR: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"^(\p{Lu}\p{Ll}+)-(\p{Lu}[\p{L}'.]*,?(?-u:\s+)\(?(?-u:\d{4})\)?)$").unwrap()
});
fn split_hyphen_glued_author(_ctx: &mut ParseContext, s: String) -> String {
let s = HYPHEN_GLUED_AUTHOR.replace(&s, "$1 $2");
DASH_BEFORE_EPITHET.replace(&s, "$1 $2").into_owned()
}
static DASH_BEFORE_EPITHET: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"^(\p{Lu}\p{Ll}+)(?-u:\s+)-(\p{Ll})").unwrap());
fn repair_win1252_artefacts_name(name: &mut ParsedName, s: String) -> String {
if s.contains('\u{00A1}')
|| s.contains('\u{00A2}')
|| s.contains('\u{00A3}')
|| s.contains('\u{201A}')
|| s.contains('\u{201E}')
|| s.contains('\u{2030}')
{
let before = s.clone();
let s = s
.replace('\u{00A1}', "i")
.replace('\u{00A2}', "c")
.replace('\u{00A3}', "L")
.replace('\u{201A}', "e")
.replace('\u{201E}', "a")
.replace('\u{2030}', "e");
if s != before {
name.add_warning(warnings::HOMOGLYHPS);
}
s
} else {
s
}
}
fn repair_win1252_artefacts(ctx: &mut ParseContext, s: String) -> String {
repair_win1252_artefacts_name(&mut ctx.name, s)
}
static COLON_DIACRITIC: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"[A-Za-z]:[123469]").unwrap());
fn repair_colon_diacritics(ctx: &mut ParseContext, s: String) -> String {
if !COLON_DIACRITIC.is_match(&s) {
return s;
}
let mut out = String::with_capacity(s.len());
let mut last = 0;
for m in COLON_DIACRITIC.find_iter(&s) {
if s[m.end()..].starts_with(|c: char| c.is_ascii_digit()) {
continue;
}
let letter = &m.as_str()[..1];
let mark = match &m.as_str()[2..] {
"1" => '\u{030A}',
"2" => '\u{0308}',
"3" => '\u{030C}',
"4" => '\u{0301}',
"6" => '\u{0303}',
_ => '\u{0300}',
};
let composed: String = format!("{letter}{mark}").nfc().collect();
if composed.chars().count() == 1 {
out.push_str(&s[last..m.start()]);
out.push_str(&composed);
last = m.end();
}
}
if last == 0 {
return s;
}
out.push_str(&s[last..]);
ctx.name.add_warning(warnings::HOMOGLYHPS);
ctx.coded_diacritics = true;
out
}
static DOUBLE_UNDERSCORE: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"_{2,}").unwrap());
fn normalise_double_underscores(_ctx: &mut ParseContext, s: String) -> String {
if s.contains("__") {
java_trim(&DOUBLE_UNDERSCORE.replace_all(&s, " ")).to_string()
} else {
s
}
}
static TRAILING_OTU_CODE: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?-u:\s+([A-Z0-9]{3,}_\d{3,}))$").unwrap());
fn stash_trailing_otu_code(ctx: &mut ParseContext, s: String) -> String {
if s.contains(' ') && ctx.pending_unparsed.is_none() {
if let Some(caps) = TRAILING_OTU_CODE.captures(&s) {
let code = caps.get(1).unwrap().as_str().to_string();
let whole = caps.get(0).unwrap();
let prefix = java_trim(&s[..whole.start()]).to_string();
ctx.set_pending_unparsed(&code);
ctx.pending_unparsed_trailing_tag = true;
return prefix;
}
}
s
}
static SEROVAR_TEST: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?i)(?-u:\b)(?:serotype|serovar)(?-u:\b)").unwrap());
static SEROVAR_PAREN: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(
r"(?i)(?-u:\s*)\((?-u:\s*)(?:serotype|serovar)(?-u:\s+)[^)]+\)(?-u:\s*)\.?(?-u:\s*)$",
)
.unwrap()
});
static SEROVAR_BARE: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(
r"(?i)(?-u:\s+)(?:serotype|serovar)(?-u:\s+)[^\t\n\x0B\f\r ]+(?:(?-u:\s+)(?:str\.?|strain)(?-u:\s+)[^\t\n\x0B\f\r ]+)?(?-u:\s*)\.?(?-u:\s*)$",
)
.unwrap()
});
fn strip_serovar_serotype(_ctx: &mut ParseContext, mut s: String) -> String {
if SEROVAR_TEST.is_match(&s) {
if let Some(m) = SEROVAR_PAREN.find(&s) {
s = java_trim(&s[..m.start()]).to_string();
}
if let Some(m) = SEROVAR_BARE.find(&s) {
s = java_trim(&s[..m.start()]).to_string();
}
}
s
}
static ANGLE_BRACKET_AUTHORSHIP: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"\s+<\s*(\p{Lu}[^>]*\s[^>]*)>\s*$").unwrap());
fn strip_angle_bracket_authorship(ctx: &mut ParseContext, s: String) -> String {
if s.contains('<') {
if let Some(m) = ANGLE_BRACKET_AUTHORSHIP.find(&s) {
ctx.name.add_warning(warnings::AUTHORSHIP_REMOVED);
ctx.name.add_warning(warnings::UNUSUAL_CHARACTERS);
ctx.name.doubtful = true;
return java_trim(&s[..m.start()]).to_string();
}
}
s
}
static HTML_TAG: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"<[^>]+>").unwrap());
static MULTI_SPACE: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?-u:\s{2,})").unwrap());
static BROKEN_AMP: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"&(?-u:\s*)amp(?-u:\b);?").unwrap());
static LETTER_ENTITY: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(concat!(
r"&(?:([A-Za-z])(acute|grave|circ|uml|tilde|ring|cedil|slash|caron)",
r"|(szlig|aelig|AElig|oelig|OElig|eth|ETH|thorn|THORN|quot|apos)",
r"|#([0-9]{1,6})|#[xX]([0-9A-Fa-f]{1,6}));?"
))
.unwrap()
});
fn decode_letter_entities(s: &str) -> std::borrow::Cow<'_, str> {
LETTER_ENTITY.replace_all(s, |c: ®ex::Captures| {
let decoded = if let (Some(letter), Some(mark)) = (c.get(1), c.get(2)) {
let base = letter.as_str().chars().next().unwrap_or(' ');
match (base, mark.as_str()) {
('o', "slash") => Some('ø'),
('O', "slash") => Some('Ø'),
(_, mark) => {
let combining = match mark {
"acute" => '\u{301}',
"grave" => '\u{300}',
"circ" => '\u{302}',
"uml" => '\u{308}',
"tilde" => '\u{303}',
"ring" => '\u{30A}',
"cedil" => '\u{327}',
"caron" => '\u{30C}',
_ => '\0',
};
unicode_normalization::char::compose(base, combining)
}
}
} else if let Some(name) = c.get(3) {
match name.as_str() {
"szlig" => Some('ß'),
"aelig" => Some('æ'),
"AElig" => Some('Æ'),
"oelig" => Some('œ'),
"OElig" => Some('Œ'),
"eth" => Some('ð'),
"ETH" => Some('Ð'),
"thorn" => Some('þ'),
"THORN" => Some('Þ'),
"quot" => Some('"'),
_ => Some('\''),
}
} else {
let code = match (c.get(4), c.get(5)) {
(Some(dec), _) => dec.as_str().parse::<u32>().ok(),
(_, Some(hex)) => u32::from_str_radix(hex.as_str(), 16).ok(),
_ => None,
};
code.and_then(char::from_u32).filter(|ch| !ch.is_control())
};
decoded.map_or_else(|| c[0].to_string(), String::from)
})
}
fn strip_html(ctx: &mut ParseContext, s: String) -> String {
if s.contains('<') || s.contains('&') {
let before_tags = s.clone();
let mut s = HTML_TAG.replace_all(&s, "").into_owned();
if s != before_tags {
ctx.name.add_warning(warnings::XML_TAGS);
}
let before_entities = s.clone();
s = BROKEN_AMP.replace_all(&s, "&").into_owned();
s = decode_letter_entities(&s)
.into_owned()
.replace("&", "&")
.replace("<", "<")
.replace(">", ">")
.replace(" ", " ");
if s != before_entities {
ctx.name.add_warning(warnings::HTML_ENTITIES);
}
return java_trim(&MULTI_SPACE.replace_all(&s, " ")).to_string();
}
s
}
static WHITESPACE: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?-u:\s+)").unwrap());
fn collapse_whitespace(s: &str) -> String {
java_trim(&WHITESPACE.replace_all(s, " ")).to_string()
}
static CANDIDATUS_PREFIX: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r#"(?i)^(?-u:["']?(?:Candidatus|Ca\.)\s+)"#).unwrap());
fn strip_candidatus(ctx: &mut ParseContext, s: String) -> String {
if let Some(m) = CANDIDATUS_PREFIX.find(&s) {
ctx.name.candidatus = true;
ctx.name.code = Some(NomCode::Bacterial);
let mut rest = s[m.end()..].to_string();
if rest.ends_with('"') || rest.ends_with('\'') {
rest.pop();
}
return rest;
}
s
}
static CV_EX: LazyLock<FancyRegex> =
LazyLock::new(|| FancyRegex::new(r"\bcv\.(?=[ \t\n\x0B\f\r]+ex[ \t\n\x0B\f\r]+)").unwrap());
static HORT_EX: LazyLock<FancyRegex> =
LazyLock::new(|| FancyRegex::new(r"\bHort\.(?=[ \t\n\x0B\f\r]+ex[ \t\n\x0B\f\r]+)").unwrap());
static HORTUS_EX: LazyLock<FancyRegex> = LazyLock::new(|| {
FancyRegex::new(r"\bhortus[a]?\b(?=[ \t\n\x0B\f\r]+ex[ \t\n\x0B\f\r]+)").unwrap()
});
static HT_MARKER: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?-u:\bht\.)").unwrap());
fn normalise_hort_ex_placeholder(_ctx: &mut ParseContext, s: String) -> String {
let s = fancy_replace_all(&CV_EX, &s, |_| "hort.".to_string());
let s = fancy_replace_all(&HORT_EX, &s, |_| "hort.".to_string());
let s = fancy_replace_all(&HORTUS_EX, &s, |_| "hort.".to_string());
HT_MARKER.replace_all(&s, "hort.").into_owned()
}
static CULTIVAR_GROUP_GREX: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"\s+([\p{Lu}][\p{L}]+(?:\s+[\p{Lu}][\p{L}]+)*)\s+(Group|grex|gx)\s*$").unwrap()
});
fn strip_cultivar_group_grex(ctx: &mut ParseContext, s: String) -> String {
if let Some(caps) = CULTIVAR_GROUP_GREX.captures(&s) {
ctx.name.cultivar_epithet = Some(java_trim(caps.get(1).unwrap().as_str()).to_string());
ctx.name.code = Some(NomCode::Cultivars);
ctx.name.rank = if caps.get(2).unwrap().as_str() == "Group" {
Rank::CultivarGroup
} else {
Rank::Grex
};
let whole = caps.get(0).unwrap();
return java_trim(&s[..whole.start()]).to_string();
}
s
}
static QUOTED_CULTIVAR_END: LazyLock<FancyRegex> = LazyLock::new(|| {
FancyRegex::new(r#"[ \t\n\x0B\f\r]+(cv\.?[ \t\n\x0B\f\r]+)?(['"])([^'"]+)\2[ \t\n\x0B\f\r]*$"#)
.unwrap()
});
static RANK_MARKER_SUFFIX: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?-u:\b(?:sp|spec|subsp|ssp|var|form|f)\.?)$").unwrap());
static QUOTED_CULTIVAR_MID: LazyLock<FancyRegex> = LazyLock::new(|| {
FancyRegex::new(concat!(
r#"\s+(?:cv\.?\s+)?(['"])([^'"]+)\1(\s+[\p{Lu}].*)$"#,
r#"|\s+(?:cv\.?\s+)?(['"])(\p{Lu}[^'"]*)\4(\s+(?:(?:de|den|der|van|von|du|da|dos|la|le|ten|ter|zu|zur)\s+){1,2}[\p{Lu}].*)$"#,
))
.unwrap()
});
static AUTHOR_START: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"^([\p{Lu}][\p{Ll}]+(?:\s+(?:[×x]\s?)?[\p{Ll}]+)?)\s+([\p{Lu}][\p{L}.]+.*)$")
.unwrap()
});
fn find_author_start(prefix: &str) -> Option<usize> {
AUTHOR_START
.captures(prefix)
.map(|caps| caps.get(2).unwrap().start())
}
static QUOTED_CULTIVAR_OPEN: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r#"\s+(cv\.?\s+)?(['"])(\p{Ll}[\p{Ll} ]*)\s*$"#).unwrap());
static TRAILING_CV: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?-u:\s+cv\.?\s*)$").unwrap());
static CV_MARKER: LazyLock<FancyRegex> =
LazyLock::new(|| FancyRegex::new(r"[ \t\n\x0B\f\r]+cv\.?(?=[ \t\n\x0B\f\r]|$)").unwrap());
static SHOUTED_QUALIFIER: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"^(\p{Lu}\p{Ll}+(?:\s+\p{Ll}+)?\s+)(CF|AFF)\.?(\s+\p{Ll}.*|\s*)$").unwrap()
});
fn lower_shouted_qualifier(s: String) -> String {
match SHOUTED_QUALIFIER.captures(&s) {
Some(c)
if !c[1]
.split_whitespace()
.any(|w| matches!(w, "sp" | "spp" | "spec")) =>
{
format!("{}{}.{}", &c[1], c[2].to_lowercase(), &c[3])
}
_ => s,
}
}
static RANK_NOVA: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"\s(ab|var|f|forma|subsp|ssp|morpha)\.\s+n\.\s+(\p{Ll}{3,})(\s|$)").unwrap()
});
fn strip_rank_nova(ctx: &mut ParseContext, s: String) -> String {
let Some(caps) = RANK_NOVA.captures(&s) else {
return s;
};
ctx.name
.add_nomenclatural_note(&format!("{}. n.", &caps[1]));
RANK_NOVA.replace(&s, " $1. $2$3").into_owned()
}
static QUOTED_ATTRIBUTED_AUTHOR: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(
r#"^(\p{Lu}\p{Ll}+(?:\s+\(\p{Lu}\p{Ll}+\))?\s+\p{Ll}[\p{Ll}-]+(?:\s+\p{Ll}[\p{Ll}-]+)?)\s+"+(\p{Lu}[\p{L}.'\-]*(?:\s\p{Lu}[\p{L}.'\-]*)?)(,?\s+\d{4})?"\s+(\p{Lu}.*)$"#,
)
.unwrap()
});
fn strip_quoted_attributed_author(s: String) -> String {
let Some(caps) = QUOTED_ATTRIBUTED_AUTHOR.captures(&s) else {
return s;
};
let last = caps[1].split_whitespace().last().unwrap_or_default();
if matches!(last, "sp" | "spp" | "species" | "spec") {
return s;
}
format!("{} {} MS, {}", &caps[1], &caps[2], &caps[4])
}
static AUTHORSHIP_QUOTED_ATTRIBUTED: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r#"^"+(\p{Lu}[\p{L}.'\-]*(?:\s\p{Lu}[\p{L}.'\-]*)?)(?:,?\s+\d{4})?"\s+(\p{Lu}.*)$"#)
.unwrap()
});
fn strip_quoted_cultivar(ctx: &mut ParseContext, mut s: String) -> String {
let cm = QUOTED_CULTIVAR_END.captures(&s).ok().flatten();
let cm_found = cm.is_some();
let has_cv_marker = cm.as_ref().is_some_and(|c| c.get(1).is_some());
let preceding = cm
.as_ref()
.map(|c| java_trim(&s[..c.get(0).unwrap().start()]).to_string());
let is_rank_marker_prefix = !has_cv_marker
&& preceding
.as_deref()
.is_some_and(|p| RANK_MARKER_SUFFIX.is_match(p));
if cm_found && !is_rank_marker_prefix {
let caps = cm.unwrap();
let match_start = caps.get(0).unwrap().start();
let epithet = java_trim(caps.get(3).unwrap().as_str()).to_string();
ctx.name.cultivar_epithet = Some(epithet);
ctx.name.code = Some(NomCode::Cultivars);
ctx.name.rank = Rank::Cultivar;
s = java_trim(&s[..match_start]).to_string();
s = java_trim(&TRAILING_CV.replace_all(&s, "")).to_string();
return s;
}
if let Some(caps) = QUOTED_CULTIVAR_MID.captures(&s).ok().flatten() {
let match_start = caps.get(0).unwrap().start();
let group = |k: usize| caps.get(k).or_else(|| caps.get(k + 3)).unwrap().as_str();
let epithet = java_trim(group(2)).to_string();
let tail = group(3).to_string();
let prefix = java_trim(&s[..match_start]).to_string();
ctx.name.cultivar_epithet = Some(epithet);
ctx.name.code = Some(NomCode::Cultivars);
ctx.name.rank = Rank::Cultivar;
let name_part = match find_author_start(&prefix) {
Some(author_start) if author_start > 0 => {
ctx.pending_specific_author = Some(java_trim(&prefix[author_start..]).to_string());
java_trim(&prefix[..author_start]).to_string()
}
_ => prefix,
};
s = java_trim(&format!("{name_part}{tail}")).to_string();
s = java_trim(&fancy_replace_all(&CV_MARKER, &s, |_| String::new())).to_string();
return s;
}
if let Some(caps) = QUOTED_CULTIVAR_OPEN.captures(&s) {
let has_cv = caps.get(1).is_some();
let match_start = caps.get(0).unwrap().start();
let epithet = java_trim(caps.get(3).unwrap().as_str()).to_string();
let preceding_open = java_trim(&s[..match_start]).to_string();
let is_rank_prefix = !has_cv && RANK_MARKER_SUFFIX.is_match(&preceding_open);
if !is_rank_prefix {
ctx.name.cultivar_epithet = Some(epithet);
ctx.name.code = Some(NomCode::Cultivars);
ctx.name.rank = Rank::Cultivar;
s = java_trim(&s[..match_start]).to_string();
s = java_trim(&TRAILING_CV.replace_all(&s, "")).to_string();
}
}
s
}
static DAGGER: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"[†✝]").unwrap());
fn strip_extinct_dagger(ctx: &mut ParseContext, s: String) -> String {
if s.contains('†') || s.contains('✝') {
ctx.name.extinct = true;
let no_dagger = DAGGER.replace_all(&s, " ");
return collapse_whitespace(&no_dagger);
}
s
}
static TINFR_MARKER: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?-u:\b[tT]\.?\s*infr\.?\s+)").unwrap());
fn strip_tinfr_marker(_ctx: &mut ParseContext, s: String) -> String {
if s.contains("infr") {
return TINFR_MARKER.replace_all(&s, "").into_owned();
}
s
}
static DOUBTFUL_GENUS_BRACKET: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"^\[\s*([\p{Lu}][\p{L}\-]+)\s*\](\s|$)").unwrap());
fn strip_doubtful_genus_brackets(ctx: &mut ParseContext, s: String) -> String {
if let Some(caps) = DOUBTFUL_GENUS_BRACKET.captures(&s) {
ctx.name.doubtful = true;
ctx.name.add_warning(warnings::DOUBTFUL_GENUS);
let whole = caps.get(0).unwrap();
let g1 = caps.get(1).unwrap().as_str();
let g2 = caps.get(2).unwrap().as_str();
return java_trim(&format!("{g1}{g2}{}", &s[whole.end()..])).to_string();
}
s
}
static SIC_WITH_COMMENT: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?-u:\s*)[(\[](?-u:\s*)sic(?-u:\s*),([^)\]]+)[)\]]").unwrap());
static SIC: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?-u:\s*[(\[]\s*sic\s*!?\s*[)\]])").unwrap());
static CORRIG: LazyLock<FancyRegex> = LazyLock::new(|| {
FancyRegex::new(
r"[ \t\n\x0B\f\r]*[(\[][ \t\n\x0B\f\r]*corrig\.?[ \t\n\x0B\f\r]*[)\]]|(?<=[ \t\n\x0B\f\r])corrig\.?(?=[ \t\n\x0B\f\r]|$)",
)
.unwrap()
});
fn strip_sic_and_corrig(ctx: &mut ParseContext, mut s: String) -> String {
if let Some(caps) = SIC_WITH_COMMENT.captures(&s) {
ctx.name.original_spelling = Some(true);
let inner = java_trim(caps.get(1).unwrap().as_str()).to_string();
let squished = WHITESPACE.replace_all(&inner, "").into_owned();
ctx.set_pending_unparsed(&format!("(sic,{squished})"));
let whole = caps.get(0).unwrap();
let (start, end) = (whole.start(), whole.end());
s = format!("{}{}", &s[..start], &s[end..]);
}
if let Some(m) = SIC.find(&s) {
ctx.name.original_spelling = Some(true);
let (start, end) = (m.start(), m.end());
s = format!("{}{}", &s[..start], &s[end..]);
}
let padded = format!(" {s}");
if let Ok(Some(_)) = CORRIG.find(&padded) {
ctx.name.original_spelling = Some(false);
let stripped = fancy_replace_all(&CORRIG, &padded, |_| String::new());
s = collapse_whitespace(&stripped);
}
s
}
static SYNONYM_BRACKET: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"(?-u:\s*)\[(?-u:\s*)=(?-u:\s*)[^\]]+\](?-u:\s*)\.?(?-u:\s*)$").unwrap()
});
fn stash_synonym_bracket(ctx: &mut ParseContext, s: String) -> String {
if let Some(m) = SYNONYM_BRACKET.find(&s) {
let tail = java_trim(&s[m.start()..]).to_string();
ctx.set_pending_unparsed(&tail);
ctx.name.doubtful = true;
let mut kept = java_trim(&s[..m.start()]).to_string();
while kept.ends_with(',') {
kept.pop();
kept = java_trim(&kept).to_string();
}
return kept;
}
s
}
static ET_WORD: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?-u:\bet\b)").unwrap());
static AND_WORD: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?-u:\band\b)").unwrap());
static SPACE_AROUND_DOT: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?-u:\s*\.\s*)").unwrap());
static DOT_BEFORE_ALNUM: LazyLock<FancyRegex> =
LazyLock::new(|| FancyRegex::new(r"\.(?=[\p{L}0-9])").unwrap());
static SPACE_AROUND_AMP: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?-u:\s*&\s*)").unwrap());
const FULL_WORD_NOM_NOTES: &[&str] = &["correct", "error"];
fn normalise_nom_note(raw: &str) -> String {
let mut s = collapse_whitespace(raw);
let et_replaced = ET_WORD.replace_all(&s, "&");
s = AND_WORD.replace_all(&et_replaced, "&").into_owned();
s = SPACE_AROUND_DOT.replace_all(&s, ".").into_owned();
s = fancy_replace_all(&DOT_BEFORE_ALNUM, &s, |_| ". ".to_string());
s = SPACE_AROUND_AMP.replace_all(&s, " & ").into_owned();
s = java_trim(&MULTI_SPACE.replace_all(&s, " ")).to_string();
if s.len() >= 5 && s.as_bytes()[..5].eq_ignore_ascii_case(b"nomen") {
while s.ends_with('.') {
s.pop();
}
return java_trim(&s).to_string();
}
if !s.is_empty() && !s.ends_with('.') {
let last_word = match s.rfind(' ') {
Some(idx) => &s[idx + 1..],
None => s.as_str(),
};
if !FULL_WORD_NOM_NOTES.contains(&last_word.to_lowercase().as_str()) {
s.push('.');
}
}
s
}
static QUOTED_SPELLING_VARIANT: LazyLock<FancyRegex> = LazyLock::new(|| {
FancyRegex::new(
r#"^(\S+\s+.*?(?:\p{Ll}{2}|\.|\p{Lu}\p{Ll}*))\s*\(\s*((['"])\p{Ll}[\p{Ll}-]+\3)\s*\)\s*$"#,
)
.unwrap()
});
static AUTHORSHIP_QUOTED_SPELLING: LazyLock<FancyRegex> = LazyLock::new(|| {
FancyRegex::new(r#"^(.*?)\s*\(\s*((['"])\p{Ll}[\p{Ll}-]+\3)\s*\)\s*$"#).unwrap()
});
fn strip_quoted_spelling_variant(ctx: &mut ParseContext, s: String) -> String {
let Ok(Some(caps)) = QUOTED_SPELLING_VARIANT.captures(&s) else {
return s;
};
let before = caps.get(1).unwrap().as_str();
let last = before.split_whitespace().last().unwrap_or_default();
if matches!(last, "sp." | "spp." | "sp" | "spp" | "cf." | "aff.") {
return s;
}
ctx.name
.add_nomenclatural_note(caps.get(2).unwrap().as_str());
java_trim(before).to_string()
}
static BRACKETED_NOM_NOTE: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(
r"(?i)(?-u:\s*)[\[\(](?-u:\s*)((?:nom|nomen|comb|orth|typ|ined|in(?-u:\s+)sched)(?-u:\b)[^\]\)]*)[\]\)](?-u:\s*)$",
)
.unwrap()
});
fn strip_bracketed_nom_note(ctx: &mut ParseContext, s: String) -> String {
if let Some(caps) = BRACKETED_NOM_NOTE.captures(&s) {
let raw = java_trim(caps.get(1).unwrap().as_str()).to_string();
if MANUSCRIPT_KEYWORD.is_match(&raw) {
ctx.name.manuscript = true;
}
ctx.name.nomenclatural_note = Some(normalise_nom_note(&raw));
let match_start = caps.get(0).unwrap().start();
let mut kept = java_trim(&s[..match_start]).to_string();
if kept.ends_with(',') {
kept = java_trim(&kept[..kept.len() - 1]).to_string();
}
return kept;
}
s
}
static NOM_NOTE: LazyLock<FancyRegex> = LazyLock::new(|| {
FancyRegex::new(concat!(
r"\s+(",
r"(?i:nomen\s+(?:nudum|novum|dubium|oblitum|illegitimum|invalidum|conservandum|rejiciendum|protectum|inquirendum)\b\.?)",
r"|(?i:nom|comb|orth|nomen)\b\.?(?:(?!\s+in\s+\p{Lu})[\s.&]*[a-z][a-z.]*)*+",
r"|(?i:sp|spec|gen|fam|var|form)\b\.?\s*(?i:nov)\b\.?(?:\s+ined\b\.?)?(?:\s+(?i:sp|spec|gen|fam|var|form)\b\.?\s*(?i:nov)\b\.?(?:\s+ined\b\.?)?)*",
r"|(?i:nov)\b\.?\s+(?i:sp|spec|gen|fam|var|form)\b\.?",
r"|(?:sp|gen|subsp|ssp)\.\s*n\b\.?|n\.\s*(?:sp|gen|subsp|ssp)\b\.?",
r"|(?:in\s+obs\b\.?,?\s*)?pro\s+syn\b\.?",
r")\s*(?=$|,\s*non(?:n\.?)?\b|,\s*nec\b|,\s*emend\b|,\s*sensu\b|,\s*auctt?\b|,\s*fide\b|\s+in\s+\p{Lu}|\s+\(.*\)\s*\.?\s*$|\s+\p{Lu})",
))
.unwrap()
});
static SP_NOV_PREFIX: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?i)^(?:sp|spec)(?-u:\b)\.?(?-u:\s+)nov.*$").unwrap());
static NOVA_ABBREVIATED: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"^(?:(?:sp|gen|subsp|ssp)\.\s*n\b\.?|n\.\s*(?:sp|gen|subsp|ssp)\b\.?)$").unwrap()
});
static SINGLE_TITLE_WORD: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"^[\p{Lu}][\p{Ll}]+$").unwrap());
static MANUSCRIPT_KEYWORD: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?i)(?-u:\b)(?:ined|ms|msc|unpublished)(?-u:\b)").unwrap());
static NOM_NOTE_RANK_HINT: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?i)^(?-u:(gen|fam|var|form|sp|spec)\b\.?)").unwrap());
fn strip_nom_note(ctx: &mut ParseContext, s: String) -> String {
let caps = match NOM_NOTE.captures(&s) {
Ok(Some(c)) => c,
_ => return s,
};
let match_start = caps.get(0).unwrap().start();
let match_end = caps.get(0).unwrap().end();
let raw = java_trim(caps.get(1).unwrap().as_str()).to_string();
if NOVA_ABBREVIATED.is_match(&raw) {
let after = java_trim(&s[match_end..]);
let code_follows = after
.split_whitespace()
.next()
.is_some_and(|w| w.chars().any(|c| c.is_ascii_digit() || c == '_'));
let stashed = ctx.name.phrase.is_some() || ctx.pending_unparsed.is_some();
let after_bare_genus = SINGLE_TITLE_WORD.is_match(java_trim(&s[..match_start]))
&& (!after.is_empty() || stashed);
let subspecies = raw.contains("ssp") || raw.contains("subsp");
if code_follows || after_bare_genus || subspecies {
return s;
}
}
let norm = normalise_nom_note(&raw);
ctx.name.add_nomenclatural_note(&norm);
let before = java_trim(&s[..match_start]).to_string();
let after = java_trim(&s[match_end..]).to_string();
let mut result = if after.is_empty() {
before.clone()
} else {
format!("{before} {after}")
};
result = java_trim(&result).to_string();
while result.ends_with(',') {
result.pop();
result = java_trim(&result).to_string();
}
if (SP_NOV_PREFIX.is_match(&raw) || NOVA_ABBREVIATED.is_match(&raw))
&& SINGLE_TITLE_WORD.is_match(&before)
{
result = format!("{before} sp.");
}
if MANUSCRIPT_KEYWORD.is_match(&raw) {
ctx.name.manuscript = true;
}
if ctx.name.rank == Rank::Unranked {
if let Some(hint) = NOM_NOTE_RANK_HINT.captures(&raw) {
match hint.get(1).unwrap().as_str().to_lowercase().as_str() {
"gen" => ctx.name.rank = Rank::Genus,
"fam" => ctx.name.rank = Rank::Family,
"var" => ctx.name.rank = Rank::Variety,
"form" => ctx.name.rank = Rank::Form,
_ => {}
}
}
}
result
}
static AUTHORSHIP_PLACEHOLDER: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(concat!(
r"(?-u:[\s,]*\s)(?:",
r"(?i:not(?-u:\s+)(?:applicable|given|known|recorded|found|specified|available|provided|stated))",
r"|(?i:author(?-u:\s+)unknown|unknown(?-u:\s+)author)",
r"|Unknown|UNKNOWN|Missing|MISSING|None|NONE|NA|N/A|Author\??(?:,(?-u:\s*)\[0000\])?",
r")(?-u:\s*)\.?(?-u:\s*)$",
))
.unwrap()
});
fn strip_authorship_placeholders(ctx: &mut ParseContext, s: String) -> String {
match find_placeholder(&s) {
Some(start) => {
ctx.name.add_warning(warnings::AUTHORSHIP_REMOVED);
java_trim(&s[..start]).to_string()
}
None => s,
}
}
pub(crate) fn without_authorship_placeholder(s: &str) -> &str {
find_placeholder(s).map_or(s, |start| &s[..start])
}
static LONE_PARTICLE: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?-u:[\s,]*\s)(?:de|del|da|du|van|von)(?-u:\s*)$").unwrap());
fn find_placeholder(s: &str) -> Option<usize> {
AUTHORSHIP_PLACEHOLDER
.find(s)
.map(|m| m.start())
.filter(|&start| !s[..start].ends_with(':'))
.or_else(|| {
let start = LONE_PARTICLE.find(s)?.start();
let words: Vec<&str> = s[..start].split_whitespace().collect();
match words.as_slice() {
[] => Some(start),
[_genus] => None,
[.., last] => rank_of_marker(last.trim_end_matches('.'))
.is_none()
.then_some(start),
}
})
}
pub(crate) fn strip_authorship_placeholder(authorship: &str, name: &mut ParsedName) -> String {
let padded = format!(" {authorship}");
if let Some(start) = find_placeholder(&padded) {
name.add_warning(warnings::AUTHORSHIP_REMOVED);
return java_trim(&padded[..start]).to_string();
}
authorship.to_string()
}
static NOT_VALIDLY_PUBLISHED: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(
r"(?i)(?-u:[\s,]*\s)(not(?-u:\s+)(?:validly|effectively)(?-u:\s+)publ(?:ished|\.)?)(?-u:\s*)$",
)
.unwrap()
});
fn strip_not_validly_published(ctx: &mut ParseContext, s: String) -> String {
strip_not_validly_published_note(&s, &mut ctx.name)
}
pub(crate) fn strip_not_validly_published_note(s: &str, name: &mut ParsedName) -> String {
if let Some(caps) = NOT_VALIDLY_PUBLISHED.captures(s) {
let note = caps.get(1).unwrap().as_str();
if !name
.nomenclatural_note
.as_deref()
.is_some_and(|existing| contains_words(existing, note))
{
name.add_nomenclatural_note(note);
}
return java_trim(&s[..caps.get(0).unwrap().start()]).to_string();
}
s.to_string()
}
static TRAILING_SPECIES_WORD_TEST: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"^[\p{Lu}][\p{Ll}]+(?-u:\s+)species(?-u:\s*)\.?$").unwrap());
static TRAILING_SPECIES_WORD: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?-u:\s+species\s*)\.?$").unwrap());
fn strip_trailing_species_word(_ctx: &mut ParseContext, s: String) -> String {
if TRAILING_SPECIES_WORD_TEST.is_match(&s) {
if let Some(m) = TRAILING_SPECIES_WORD.find(&s) {
return java_trim(&s[..m.start()]).to_string();
}
}
s
}
static PRO_PARTE: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(
r"(?i)(?-u:(?:\s*,\s*|\s+)(?:pro(?:\s+(?:max|maj|min)\.?)?\s+parte|p\.\s*p\.[A-Z]?)\s*)$",
)
.unwrap()
});
static NOTE_KEYWORD: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?i)(?-u:\b(?:sensu|auctt?|auctorum|sec)\b)").unwrap());
fn strip_pro_parte(ctx: &mut ParseContext, s: String) -> String {
if let Some(m) = PRO_PARTE.find(&s) {
if NOTE_KEYWORD.is_match(&s[..m.start()]) {
return s;
}
ctx.name.doubtful = true;
return java_trim(&s[..m.start()]).to_string();
}
s
}
static PRO_SP_ANNOTATION: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"(?i)(?-u:\s+\(\s*pro\s+(?:sp|spec|syn|hyb)\b\.?\s*\)\s*\.?\s*)$").unwrap()
});
fn strip_pro_sp_annotation(_ctx: &mut ParseContext, s: String) -> String {
if let Some(m) = PRO_SP_ANNOTATION.find(&s) {
return java_trim(&s[..m.start()]).to_string();
}
s
}
static APPROVED_LISTS: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"(?i)(?-u:\s*\(\s*Approved\s+Lists,?\s+\d{4}\s*\)\s*\.?\s*)(?:,?(?-u:\s*)(emend(?-u:\b).*))?$")
.unwrap()
});
fn strip_approved_lists(ctx: &mut ParseContext, s: String) -> String {
if let Some(caps) = APPROVED_LISTS.captures(&s) {
ctx.approved_lists = true;
let before = java_trim(&s[..caps.get(0).unwrap().start()]);
return match caps.get(1) {
Some(emend) => format!("{before} {}", emend.as_str()),
None => before.to_string(),
};
}
s
}
static MIHI_TEST: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?i)(?-u:\bmihi\b)").unwrap());
static MIHI: LazyLock<FancyRegex> =
LazyLock::new(|| FancyRegex::new(r"(?i)[ \t\n\x0B\f\r]+mihi\.?(?=[ \t\n\x0B\f\r]|$)").unwrap());
fn strip_mihi(ctx: &mut ParseContext, s: String) -> String {
if MIHI_TEST.is_match(&s) {
let before = s.clone();
let after = java_trim(&fancy_replace_all(&MIHI, &s, |_| String::new())).to_string();
if after != before {
ctx.name.add_warning(warnings::AUTHORSHIP_REMOVED);
}
return after;
}
s
}
static ANON_UPPER: LazyLock<FancyRegex> =
LazyLock::new(|| FancyRegex::new(r"(?<=[ \t\n\x0B\f\r])Anon\b\.?").unwrap());
static ANON_LOWER: LazyLock<FancyRegex> =
LazyLock::new(|| FancyRegex::new(r"(?<=[ \t\n\x0B\f\r])anon\b(?!\.)").unwrap());
fn normalise_anon(_ctx: &mut ParseContext, s: String) -> String {
normalise_anon_str(&s)
}
fn normalise_anon_str(s: &str) -> String {
let s = fancy_replace_all(&ANON_UPPER, s, |_| "anon.".to_string());
fancy_replace_all(&ANON_LOWER, &s, |_| "anon.".to_string())
}
static COLON_CONCEPT_REFERENCE: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"\s*:\s+(\p{Lu}[^:]*,\s*\d{3,4})\s*\.?\s*$").unwrap());
static IN_COLON: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(\s)(?:[Ii]n|\{in\}):(\s)").unwrap());
static SANCTIONING_AUTHOR: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"^(?:Fr\.|Fries\b|Pers\.|Persoon\b)").unwrap());
static ENDS_IN_YEAR: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"\d{4}[a-z]?\)?$").unwrap());
fn strip_colon_concept_reference(ctx: &mut ParseContext, s: String) -> String {
let s = IN_COLON.replace_all(&s, "${1}in${2}").into_owned();
if let Some(caps) = COLON_CONCEPT_REFERENCE.captures(&s) {
let note = java_trim(caps.get(1).unwrap().as_str()).to_string();
let before = java_trim(&s[..caps.get(0).unwrap().start()]);
if SANCTIONING_AUTHOR.is_match(¬e) && !ENDS_IN_YEAR.is_match(before) {
return s;
}
ctx.name.add_taxonomic_note(¬e);
let whole = caps.get(0).unwrap();
return java_trim(&s[..whole.start()]).to_string();
}
s
}
static LEADING_AUCT: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"^(Auct)").unwrap());
static LEADING_AUCTT: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"^(Auctt)").unwrap());
fn normalise_leading_auct(note: &str) -> String {
let step1 = LEADING_AUCT.replace(note, "auct");
LEADING_AUCTT.replace(&step1, "auctt").into_owned()
}
static BRACKETED_TAX_NOTE: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(
r"(?i)(?-u:\s*)\[(?-u:\s*)((?:auctt?|auctorum|sensu|sec|non|nec|not|misspelling|misapplied|misident)(?-u:\b)[^\]]*)\](?-u:\s*)\.?(?-u:\s*)$",
)
.unwrap()
});
fn strip_bracketed_tax_note(ctx: &mut ParseContext, s: String) -> String {
if let Some(caps) = BRACKETED_TAX_NOTE.captures(&s) {
let trimmed = java_trim(caps.get(1).unwrap().as_str());
let collapsed = WHITESPACE.replace_all(trimmed, " ");
let note = normalise_leading_auct(&collapsed);
ctx.name.add_taxonomic_note(¬e);
let whole = caps.get(0).unwrap();
return java_trim(&s[..whole.start()]).to_string();
}
s
}
static PAREN_SENSU_STRICTO: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"(?-u:\s*)\((?-u:\s*)(s\.(?-u:\s*)(?:str|s|l|lat|ampl)\.?)(?-u:\s*)\)").unwrap()
});
static PAREN_TAX_NOTE: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(
r"(?i)(?-u:\s*)\((?-u:\s*)((?:nec|non|not)(?-u:\s+)[^)]+|(?:auctt?|auctorum|sensu|sec|vide|synonym)(?-u:\b)[^)]*)\)(?-u:\s*)\.?(?-u:\s*)$",
)
.unwrap()
});
static PAREN_CONCEPT_NOTE: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"(?i)^(?:auctt?|auctorum|sensu|sec|vide|synonym)(?-u:\b)").unwrap()
});
static INDET_MARKER_WORD: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?i)(?-u:\b)(?:spp?|spec|species|indet)(?-u:\b)").unwrap());
static PAREN_NOTE_BEFORE_AUTHOR: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"\s\(\s*((?i:auctt?|auctorum|sensu|sec)\b[^)]*)\)\s*(\p{Lu})").unwrap()
});
static PAREN_HOMONYM_THEN_NOTE: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"\s(\(\s*(?i:non|nec|not)\s[^)]+\)\s*(?i:sensu|auct|sec)\b.*)$").unwrap()
});
static PAREN_AUCT_REPEATED: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"\s\(\s*(?i:auctt?\.?|auctorum)\s*\)\s*((?i:auct))").unwrap());
fn strip_paren_tax_note(ctx: &mut ParseContext, s: String) -> String {
if let Some(caps) = PAREN_SENSU_STRICTO.captures(&s) {
ctx.name
.add_taxonomic_note(&WHITESPACE.replace_all(caps.get(1).unwrap().as_str(), " "));
let whole = caps.get(0).unwrap();
let s = format!("{} {}", java_trim(&s[..whole.start()]), &s[whole.end()..]);
return strip_paren_tax_note(ctx, java_trim(&s).to_string());
}
if let Some(caps) = PAREN_AUCT_REPEATED.captures(&s) {
let (whole, next) = (caps.get(0).unwrap(), caps.get(1).unwrap());
let s = format!("{} {}", java_trim(&s[..whole.start()]), &s[next.start()..]);
return strip_paren_tax_note(ctx, s);
}
if let Some(caps) = PAREN_HOMONYM_THEN_NOTE.captures(&s) {
let note = collapse_whitespace(java_trim(caps.get(1).unwrap().as_str()));
ctx.name.add_taxonomic_note(¬e);
return java_trim(&s[..caps.get(0).unwrap().start()]).to_string();
}
if let Some(caps) = PAREN_NOTE_BEFORE_AUTHOR.captures(&s) {
let note = WHITESPACE.replace_all(java_trim(caps.get(1).unwrap().as_str()), " ");
ctx.name.add_taxonomic_note(&normalise_leading_auct(¬e));
let whole = caps.get(0).unwrap();
let author = caps.get(2).unwrap().start();
return format!("{} {}", java_trim(&s[..whole.start()]), &s[author..]);
}
if let Some(caps) = PAREN_TAX_NOTE.captures(&s) {
let whole = caps.get(0).unwrap();
if PAREN_CONCEPT_NOTE.is_match(caps.get(1).unwrap().as_str())
&& INDET_MARKER_WORD.is_match(&s[..whole.start()])
{
return s;
}
let note = normalise_leading_auct(java_trim(caps.get(1).unwrap().as_str()));
ctx.name.add_taxonomic_note(¬e);
return java_trim(&s[..whole.start()]).to_string();
}
s
}
static SENSU_LATO_REMAINDER: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(
r"(?-u:\s+)(s\.(?-u:\s*)l\.?|s\.(?-u:\s*)lat\.?|s\.(?-u:\s*)str\.?|s\.(?-u:\s*)ampl\.?)(?-u:\s+)(\S.*?)(?-u:\s*)$",
)
.unwrap()
});
fn strip_sensu_lato_remainder(ctx: &mut ParseContext, s: String) -> String {
if let Some(caps) = SENSU_LATO_REMAINDER.captures(&s) {
let marker = caps.get(1).unwrap().as_str();
let note = WHITESPACE.replace_all(marker, "").to_lowercase();
let remainder = java_trim(caps.get(2).unwrap().as_str()).to_string();
ctx.name.add_taxonomic_note(¬e);
let whole = caps.get(0).unwrap();
let name = java_trim(&s[..whole.start()]);
let after_epithet = !name.contains(' ')
|| name
.split_whitespace()
.last()
.is_some_and(|w| w.chars().all(char::is_lowercase));
if after_epithet && AUTHORSHIP_START.is_match(&remainder) {
return format!("{name} {remainder}");
}
ctx.set_pending_unparsed(&remainder);
return name.to_string();
}
s
}
static AUTHORSHIP_START: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(
r"^(?:\p{Lu}\p{Ll}*\.?(?:\s|,|$)|\(\p{Lu}[\p{L}.'\-]*(?:(?:\s+|\s*&\s*|\s+(?:et|ex|in)\s+)\p{Lu}[\p{L}.'\-]*)*(?:,?\s*\d{4})?\))",
)
.unwrap()
});
static SENSU_STRICTO_SS: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?-u:\s+)s\.(?-u:\s*)s\.?((?-u:\s+)\S.*?)?(?-u:\s*)$").unwrap());
fn strip_sensu_stricto_ss(ctx: &mut ParseContext, s: String) -> String {
if let Some(caps) = SENSU_STRICTO_SS.captures(&s) {
ctx.name.add_taxonomic_note("s.s.");
if let Some(junk) = caps.get(1) {
ctx.set_pending_unparsed(java_trim(junk.as_str()));
}
let whole = caps.get(0).unwrap();
return java_trim(&s[..whole.start()]).to_string();
}
s
}
static TAX_NOTE: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(concat!(
r"(?i)(?-u:\s+),?(?-u:\s*)(",
r"auctt?(?-u:\b)\.?(?:[,.]?(?-u:\s).*)?",
r"|auctorum(?-u:\b)(?:[,.]?(?-u:\s).*)?",
r"|sensu\.?(?:(?-u:\s).*)?",
r"|sec\.?(?:(?-u:\s).*)?",
r"|nec(?-u:\b)(?:(?-u:\s).*)?",
r"|nonn?\.?(?-u:\s+)\(?\p{Lu}.*",
r"|not(?-u:\s+)\(?(?-i:\p{Lu}(?:\p{Ll}|\.|\p{Lu}\.)).*",
r"|emend(?-u:\b)\.?(?-u:\s+)\(?\p{Lu}.*",
r"|(?-i:[Ee]m\.)(?-u:\s+)\(?(?-i:\p{Lu}).*",
r"|fide(?-u:\b)\.?(?-u:\s+)\(?\p{Lu}.*",
r"|(?-i:[Vv]ide)(?-u:\s+)\(?(?-i:\p{Lu}).*",
r"|(?-i:[Oo]f)(?-u:\s+)(?:authors(?-u:\b)|(?-i:\p{Lu})|d'|(?-i:de|van|von|la|le|du)(?-u:\s)).*",
r"|according(?-u:\s+)to(?-u:\s+)\p{Lu}.*",
r"|excl\.(?-u:\s+).*",
r"|ss(?-u:\b)\.?(?-u:\s+).*",
r"|(?-i:s\.(?-u:\s*)l\.?|s\.(?-u:\s*)str\.?|s\.(?-u:\s*)lat\.?|s\.(?-u:\s*)ampl\.?)",
r"|(?-i:sens\.(?-u:\s*)(?:str|lat|l|ampl)\.?)",
r"|(?-i:ampl\.)(?-u:\s+)\(?(?-i:\p{Lu}).*",
r")$",
))
.unwrap()
});
static INITIAL_DOT_SPACE: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?-u:\b)(\p{Lu})\.(?-u:\s+)([\p{Ll}][\p{Ll}]{3,})").unwrap());
static KEYWORD_ONLY_BRACKET: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"(?i)\[(?-u:\s*)(sensu|sec\.?|non|nec|not|auctt?\.?|auctorum)(?-u:\s*)\](?-u:\s+)")
.unwrap()
});
fn unwrap_keyword_only_bracket(s: &str) -> String {
KEYWORD_ONLY_BRACKET.replace_all(s, "$1 ").into_owned()
}
static BRACKETED_EMENDATION: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(
r"\(([^()]*?(?-u:\d{4}))(?-u:\s*),?(?-u:\s+)((?:[Ee]m\.|emend\.?)(?-u:\s+)\p{Lu}[^()]*)\)",
)
.unwrap()
});
fn lift_bracketed_emendation(s: &str) -> String {
BRACKETED_EMENDATION.replace(s, "($1) $2").into_owned()
}
static BRACKETED_OF: LazyLock<Regex> = LazyLock::new(|| {
let name = r"\p{Lu}[\p{L}'’.\-]*";
Regex::new(&format!(
r"\(({name}(?:\s+(?:&|and|et)\s+{name})*)\s+(of\s+\p{{Lu}}[^()]*)\)"
))
.unwrap()
});
fn lift_bracketed_of(s: &str) -> String {
let Some(caps) = BRACKETED_OF.captures(s) else {
return s.to_string();
};
let (whole, authors, note) = (caps.get(0).unwrap(), &caps[1], &caps[2]);
let before = java_trim(&s[..whole.start()]);
let basionym_place = before.is_empty()
|| before
.rsplit(char::is_whitespace)
.next()
.is_some_and(|w| w.chars().all(|c| c.is_lowercase() || c == '-'));
let last = authors.rsplit(char::is_whitespace).next().unwrap_or("");
let no_author = last.chars().count() < 2
|| ["not", "non", "north", "south", "east", "west"]
.iter()
.any(|w| last.eq_ignore_ascii_case(w));
if !basionym_place || no_author || CORPORATE_WORD.is_match(last) || !OF_AUTHORS.is_match(note) {
return s.to_string();
}
let rest = java_trim(&s[whole.end()..]);
let mut out = format!("{}({authors})", &s[..whole.start()]);
if !rest.is_empty() {
out.push(' ');
out.push_str(rest);
}
out.push(' ');
out.push_str(java_trim(note));
out
}
fn lift_bracketed_notes(s: &str) -> String {
lift_bracketed_of(&lift_bracketed_emendation(s))
}
static OF_AUTHORS: LazyLock<Regex> = LazyLock::new(|| {
let particle = r"(?:de|da|du|van|von|der|den|la|le|d')";
let name = format!(r"(?:{particle}\s*)*\p{{Lu}}[\p{{L}}'’.\-]*");
Regex::new(&format!(
r"^of\s+(?:(?:\p{{Lu}}\p{{Ll}}+\s+)?authors\b.*|{name}(?:\s+(?:{name}|{particle}|&|and|et))*(?:\s+et\s+al\.?)?(?:[,(\[].*|\s+[\[(]?\d{{4}}.*)?)$"
))
.unwrap()
});
static CORPORATE_WORD: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(concat!(
r"(?i)^(?:institute|institution|department|dept\.?|group|society|museum|university|academy|",
r"college|survey|committee|commission|board|ministry|school|faculty|laboratory|garden|",
r"gardens|herbarium|office|bureau|service|association|union|team|station|cent(?:er|re)|",
r"council|division|section|unit|members|staff|students|project|consortium|network)$",
))
.unwrap()
});
static IN_CITATION_START: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"\sin\s+\p{Lu}").unwrap());
fn find_tax_note(s: &str, authorship_only: bool) -> Option<(usize, usize)> {
let mut from = 0;
while let Some(caps) = TAX_NOTE.captures_at(s, from) {
let (whole, note) = (caps.get(0).unwrap(), caps.get(1).unwrap());
let raw = note.as_str();
let prefix = java_trim(&s[..whole.start()]);
let last_word = prefix.rsplit(char::is_whitespace).next().unwrap_or("");
let closed = prefix.matches('(').count() == prefix.matches(')').count();
let keep = if raw.starts_with("Em.") || raw.starts_with("em.") {
closed && follows_author(prefix, authorship_only)
} else if raw.starts_with("vide") || raw.starts_with("Vide") {
closed
} else if raw.starts_with("of ") || raw.starts_with("Of ") {
closed
&& OF_AUTHORS.is_match(raw)
&& !IN_CITATION_START.is_match(&s[..whole.start()])
&& !INDET_MARKER_WORD.is_match(last_word)
&& !CORPORATE_WORD.is_match(last_word)
} else {
true
};
if keep {
return Some((whole.start(), note.start()));
}
from = whole.start() + s[whole.start()..].chars().next().map_or(1, char::len_utf8);
}
None
}
fn follows_author(prefix: &str, authorship_only: bool) -> bool {
let words: Vec<&str> = prefix.split_whitespace().collect();
let Some(last) = words.last() else {
return false;
};
let author_like = last.ends_with(')')
|| last.ends_with(',')
&& last
.trim_end_matches(',')
.chars()
.all(|c| c.is_ascii_digit())
|| last.chars().all(|c| c.is_ascii_digit())
|| last.chars().next().is_some_and(char::is_uppercase);
author_like && (authorship_only || words.len() >= 2)
}
fn strip_tax_note(ctx: &mut ParseContext, s: String) -> String {
let s = lift_bracketed_notes(&unwrap_keyword_only_bracket(&s));
let Some((match_start, note_start)) = find_tax_note(&s, false) else {
return s;
};
let raw = java_trim(&s[note_start..]).to_string();
if raw.is_empty() {
return s;
}
if (raw.starts_with("auctorum") || raw.starts_with("not "))
&& note_keyword_is_epithet(&s[..match_start], ctx.requested_rank)
{
return s;
}
let with_dots = INITIAL_DOT_SPACE.replace_all(&raw, "$1.$2");
let norm = normalise_leading_auct(&with_dots);
ctx.name.taxonomic_note = Some(match ctx.name.taxonomic_note.take() {
None => norm,
Some(later) => format!("{norm} {later}"),
});
let mut result = java_trim(&s[..match_start]).to_string();
while result.ends_with(',') {
result.pop();
result = java_trim(&result).to_string();
}
result
}
static AGGREGATE: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(
r"(?i)(?-u:(?:\s+(?:agg\.?|aggregate|species\s+group|species\s+complex|group|complex)|\s*-\s*group|\s*-\s*aggregate)\s*)$",
)
.unwrap()
});
fn strip_aggregate_suffix(ctx: &mut ParseContext, s: String) -> String {
if let Some(m) = AGGREGATE.find(&s) {
ctx.aggregate = true;
return java_trim(&s[..m.start()]).to_string();
}
s
}
static PUBLISHED_PAGE: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"(?-u:\s*):(?-u:\s*)((?-u:\d+)(?:[-\x{2013}](?-u:\d+))?)(?-u:\s*)$").unwrap()
});
fn strip_published_page(ctx: &mut ParseContext, s: String) -> String {
if let Some(caps) = PUBLISHED_PAGE.captures(&s) {
let whole = caps.get(0).unwrap();
if !ends_with_year_citation(&s[..whole.start()]) {
return s;
}
ctx.name.published_in_page = Some(caps[1].to_string());
ctx.page_strip_verbatim = Some(whole.as_str().to_string());
return java_trim(&s[..whole.start()]).to_string();
}
s
}
static TRAILING_YEAR_CITATION: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?-u:\d{4})(?-u:[a-z])?[)\]]?(?-u:\s*)$").unwrap());
fn ends_with_year_citation(prefix: &str) -> bool {
TRAILING_YEAR_CITATION.is_match(prefix)
}
static IN_PRESS: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?i)(?-u:\s+in\s+press\b\.?)").unwrap());
fn strip_in_press(ctx: &mut ParseContext, s: String) -> String {
if let Some(m) = IN_PRESS.find(&s) {
ctx.name.manuscript = true;
ctx.name.add_nomenclatural_note("in press");
return format!("{}{}", &s[..m.start()], &s[m.end()..]);
}
s
}
pub(crate) fn strip_in_author_citations(ctx: &mut ParseContext, s: String) -> String {
let s = BRACKETED_IN_AUTHOR.replace_all(&s, "$1 in ").into_owned();
let s = DANGLING_IN.replace(&s, "").into_owned();
let before = ctx.name.published_in.clone();
let s = strip_in_author_in_parens(ctx, s);
let from_basionym = ctx.name.published_in != before;
let published_in = ctx.name.published_in.clone();
let s = strip_in_author_citation(ctx, s);
if from_basionym && ctx.name.published_in != published_in {
let own = ctx.name.published_in.as_deref().and_then(|p| {
published_in
.as_deref()
.and_then(|b| p.strip_prefix(b))
.map(|rest| java_trim(rest).to_string())
});
if let Some(own) = own {
ctx.name
.set_published_in(&before.map_or(own.clone(), |b| format!("{b} {own}")));
}
}
s
}
static BRACKETED_IN_AUTHOR: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"\[(\p{Lu}[^\[\]]*?)(?-u:\s+)(?:in|In)\](?-u:\s+)").unwrap());
static DANGLING_IN: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?-u:,?\s+)(?:in|In)(?-u:\s*)$").unwrap());
static IN_AUTHOR_IN_PARENS: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"\(([^()]*?)\s+(?:in|In|apud)\s+((?:\p{Lu}|anon\.)[^()]*?)\)").unwrap()
});
static IN_AUTHOR_YEAR: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?-u:,?\s*(\d{3,4})\s*\.?\s*)$").unwrap());
fn strip_in_author_in_parens(ctx: &mut ParseContext, s: String) -> String {
if let Some(caps) = IN_AUTHOR_IN_PARENS.captures(&s) {
let whole = caps.get(0).unwrap();
let bas_part = java_trim(&caps[1]).to_string();
let reference = java_trim(&caps[2]).to_string();
if !bas_part.is_empty() && reference.chars().count() >= 2 {
ctx.name.add_published_in(&reference);
let new_parens = match IN_AUTHOR_YEAR.captures(&reference) {
Some(ym) if !YEAR_4DIGIT.is_match(&bas_part) => {
format!("({bas_part}, {})", &ym[1])
}
_ => format!("({bas_part})"),
};
return format!("{}{}{}", &s[..whole.start()], new_parens, &s[whole.end()..]);
}
}
s
}
static IN_AUTHOR: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"(?-u:\s+)(?:in|In|apud)(?-u:\s+)((?:\p{Lu}[^\t\n\x0B\f\r ]|anon\.).*)$").unwrap()
});
static IN_AUTHOR_PAREN_YEAR: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?-u:\((\d{4})\))").unwrap());
fn strip_in_author_citation(ctx: &mut ParseContext, s: String) -> String {
if let Some(caps) = IN_AUTHOR.captures(&s) {
let whole = caps.get(0).unwrap();
let mut reference = java_trim(&caps[1]).to_string();
if reference.ends_with(").") {
reference.pop();
reference = java_trim(&reference).to_string();
}
if reference.chars().count() >= 2 {
ctx.name.add_published_in(&reference);
if let Some(pyear) = IN_AUTHOR_PAREN_YEAR.captures(&reference) {
ctx.set_pending_publication_year(&pyear[1]);
}
if let Some(ym) = IN_AUTHOR_YEAR.captures(&reference) {
ctx.set_pending_publication_year(&ym[1]);
}
return java_trim(&s[..whole.start()]).to_string();
}
}
s
}
static IPNI_CITATION: LazyLock<FancyRegex> =
LazyLock::new(|| FancyRegex::new(r"(?<=\s)[\p{Lu}][\p{L}.]+,\s+(.+\(\d{4}\))\.?\s*$").unwrap());
static IPNI_EMBEDDED_NOM_NOTE: LazyLock<FancyRegex> = LazyLock::new(|| {
FancyRegex::new(concat!(
r"(?i)[ \t\n\x0B\f\r]+((?:in[ \t\n\x0B\f\r]+obs\b\.?,?[ \t\n\x0B\f\r]*)?pro[ \t\n\x0B\f\r]+syn\b\.?",
r"|nom\b\.?(?:[ \t\n\x0B\f\r]+[a-zA-Z][a-zA-Z.]*)*",
r"|comb\b\.?(?:[ \t\n\x0B\f\r]+[a-zA-Z][a-zA-Z.]*)*",
r"|orth\b\.?(?:[ \t\n\x0B\f\r]+[a-zA-Z][a-zA-Z.]*)*)[ \t\n\x0B\f\r]*(?=\([0-9]{4}\))",
))
.unwrap()
});
static IPNI_YEAR: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?-u:\((\d{4})\)\s*\.?\s*)$").unwrap());
fn strip_ipni_citation(ctx: &mut ParseContext, s: String) -> String {
let caps = match IPNI_CITATION.captures(&s) {
Ok(Some(c)) => c,
_ => return strip_page_year_citation(ctx, s),
};
let group1 = caps.get(1).unwrap();
let mut reference = java_trim(group1.as_str()).to_string();
if let Ok(Some(nm)) = IPNI_EMBEDDED_NOM_NOTE.captures(&reference) {
let note_match = nm.get(1).unwrap();
ctx.name
.add_nomenclatural_note(java_trim(note_match.as_str()));
let spliced = format!(
"{} {}",
&reference[..note_match.start()],
&reference[note_match.end()..]
);
reference = java_trim(&MULTI_SPACE.replace_all(&spliced, " ")).to_string();
}
ctx.name.set_published_in(&reference);
if let Some(ym) = IPNI_YEAR.captures(&reference) {
ctx.set_pending_publication_year(&ym[1]);
}
let mut result = java_trim(&s[..group1.start()]).to_string();
if result.ends_with(',') {
result.pop();
result = java_trim(&result).to_string();
}
result
}
static PAGE_YEAR_TAIL: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"\d\s*:\s*[^:]*?\.\s+(\d{4})\.?\s*$").unwrap());
static VOLUME_PAGE: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"\d\s*:\s*\d").unwrap());
static TEAM_CONNECTOR: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"\s(?:&|and|et)\s").unwrap());
fn strip_page_year_citation(ctx: &mut ParseContext, s: String) -> String {
let Some(tail) = PAGE_YEAR_TAIL.captures(&s) else {
return s;
};
let volume_end = tail.get(0).unwrap().start() + 1;
let head = &s[..volume_end];
let title_comma = |from: usize| {
let mut depth = 0i32;
for (i, c) in head.char_indices() {
match c {
'(' | '[' => depth += 1,
')' | ']' => depth -= 1,
',' if i >= from && depth == 0 => {
let title = &head[i + 1..];
if title.trim_start().starts_with(char::is_uppercase)
&& !title.contains(['(', ')', '[', ']'])
&& !java_trim(&head[..i]).is_empty()
{
return Some(i);
}
}
_ => {}
}
}
None
};
let after_team = TEAM_CONNECTOR.find_iter(head).last().map_or(0, |m| m.end());
let Some(comma) = title_comma(after_team).or_else(|| title_comma(0)) else {
return s;
};
if PAGE_YEAR_TAIL.is_match(&s[..comma]) || VOLUME_PAGE.is_match(&s[..comma]) {
return s;
}
let reference = java_trim(&s[comma + 1..]).trim_end_matches('.');
ctx.name.set_published_in(java_trim(reference));
ctx.set_pending_publication_year(&tail[1]);
java_trim(&s[..comma]).to_string()
}
static PERIOD_SEPARATED_REFERENCE: LazyLock<FancyRegex> = LazyLock::new(|| {
FancyRegex::new(concat!(
r"\s+[\p{Lu}][\p{L}]{2,}\.\s+",
r"([\p{Lu}][\p{Ll}]{2,}[\p{L}.]*(?:\s+(?!(?:of|in|de|et|the|und|f\x{fc}r)\b)(?:[\p{Lu}][\p{L}.]+|[\p{Ll}][\p{L}]+))*+",
r"\s+(?:of|in|de|et|the|und|f\x{fc}r)\s+.*)$",
))
.unwrap()
});
static PAGE_RANGE_TEST: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?-u:\b\d{3,}-\d{3,}\b)").unwrap());
static PERIOD_REF_YEAR: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?-u:\b(\d{4})\b)").unwrap());
fn strip_period_separated_reference(ctx: &mut ParseContext, s: String) -> String {
let caps = match PERIOD_SEPARATED_REFERENCE.captures(&s) {
Ok(Some(c)) => c,
_ => return s,
};
let group1 = caps.get(1).unwrap();
let mut reference = java_trim(group1.as_str()).to_string();
if reference.ends_with('.') {
reference.pop();
}
ctx.name.set_published_in(&reference);
if PAGE_RANGE_TEST.is_match(&reference) {
ctx.name.add_warning(warnings::NOMENCLATURAL_REFERENCE);
} else if let Some(ym) = PERIOD_REF_YEAR.captures(&reference) {
ctx.set_pending_publication_year(&ym[1]);
}
let mut result = java_trim(&s[..group1.start()]).to_string();
if result.ends_with('.') {
result.pop();
result = java_trim(&result).to_string();
}
result
}
static COMMA_PREFIXED_REFERENCE: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(concat!(
r"\s+[\p{Lu}][\p{L}.]+,\s+",
r"([\p{Lu}][\p{Ll}]{2,}[\p{L}.]*(?:\s+(?:[\p{Lu}][\p{L}.]+|on|and|for))*",
r"\s+(?:of|in|de|et|the|und|f\x{fc}r)\s+.*)$",
))
.unwrap()
});
static AUTHOR_TEAM_TAIL: LazyLock<Regex> = LazyLock::new(|| {
let particle = r"(?:de|da|do|dos|van|von|der|den|du|le|la|di|del)";
let name = format!(
r"(?:{particle}\s+)*\p{{Lu}}[\p{{L}}'.\-]*(?:\s+(?:\p{{Lu}}[\p{{L}}'.\-]*|{particle}))*"
);
Regex::new(&format!(
r"^{name}(?:,\s+{name})*\s+(?:et|and|&)\s+(?:al\.?|{name})(?:(?:,\s*|\s+)\d{{4}}[a-z]?)?\.?$"
))
.unwrap()
});
fn strip_comma_prefixed_reference(ctx: &mut ParseContext, s: String) -> String {
if let Some(caps) = COMMA_PREFIXED_REFERENCE.captures(&s) {
let group1 = caps.get(1).unwrap();
let reference = java_trim(group1.as_str()).to_string();
if AUTHOR_TEAM_TAIL.is_match(&reference) {
return s;
}
ctx.name.set_published_in(&reference);
let mut result = java_trim(&s[..group1.start()]).to_string();
if result.ends_with(',') {
result.pop();
result = java_trim(&result).to_string();
}
ctx.name.add_warning(warnings::NOMENCLATURAL_REFERENCE);
return result;
}
s
}
static MANUSCRIPT_MARKER: LazyLock<Regex> =
LazyLock::new(|| Regex::new(&format!(r"(?i)(?-u:\s*,?\s+({MS_MARKERS})\s*)$")).unwrap());
const MS_MARKERS: &str = r"ined\.?|ms\.?|msc\.?|unpublished|in\s+litt(?:\.|eris)?|in\s+lit\.|in\s+sched(?:\.|is)|(?-i:i\.\s?l\.)";
static MANUSCRIPT_MARKER_BEFORE_YEAR: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(&format!(
r"(?i)(?-u:\s*,?\s+({MS_MARKERS})\s*,?\s*(\d{{4}}[a-z]?)\s*)$"
))
.unwrap()
});
fn strip_manuscript_marker(ctx: &mut ParseContext, s: String) -> String {
strip_trailing_manuscript_marker(&s, &mut ctx.name)
}
pub(crate) fn strip_trailing_manuscript_marker(s: &str, name: &mut ParsedName) -> String {
if let Some(caps) = MANUSCRIPT_MARKER_BEFORE_YEAR.captures(s) {
let (marker, year) = (caps.get(1).unwrap(), caps.get(2).unwrap());
let rest = strip_trailing_manuscript_marker(&s[..marker.end()], name);
let sep = if s[marker.end()..year.start()].contains(',') {
", "
} else {
" "
};
return format!("{rest}{sep}{}", year.as_str());
}
if let Some(caps) = MANUSCRIPT_MARKER.captures(s) {
let whole = caps.get(0).unwrap();
let tag = collapse_whitespace(&caps[1].to_lowercase());
name.manuscript = true;
if !name
.nomenclatural_note
.as_deref()
.is_some_and(|existing| contains_words(existing, &tag))
{
name.add_nomenclatural_note(&tag);
}
let rest = java_trim(&s[..whole.start()]);
return java_trim(DANGLING_EX.replace(rest, "").as_ref()).to_string();
}
s.to_string()
}
static DANGLING_EX: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?i)(?-u:\s+ex\.?)$").unwrap());
fn supra_rank_marker(word: &str) -> Option<Rank> {
match word {
"subfam" | "subfamily" => Some(Rank::Subfamily),
"trib" | "tribe" => Some(Rank::Tribe),
"subtrib" | "subtribe" => Some(Rank::Subtribe),
"supertrib" => Some(Rank::Supertribe),
"infratrib" => Some(Rank::Infratribe),
_ => None,
}
}
static SUPRA_RANK_PREFIX: LazyLock<FancyRegex> = LazyLock::new(|| {
FancyRegex::new(
r"(?i)^(?:[\p{Lu}][\p{L}]{2,}\s+)?(subfam(?:ily)?|subtrib(?:e)?|supertrib|infratrib|trib(?:e)?)\.?\s+(?=[\p{Lu}])",
)
.unwrap()
});
fn strip_supra_rank_prefix(ctx: &mut ParseContext, s: String) -> String {
if let Ok(Some(caps)) = SUPRA_RANK_PREFIX.captures(&s) {
let marker = caps.get(1).unwrap().as_str().to_lowercase();
if let Some(r) = supra_rank_marker(&marker) {
ctx.name.rank = r;
let whole = caps.get(0).unwrap();
return java_trim(&s[whole.end()..]).to_string();
}
}
s
}
fn infrageneric_marker_rank(word: &str) -> Option<Rank> {
match word {
"subg" | "subgen" | "subgenus" => Some(Rank::Subgenus),
"sect" | "section" => Some(Rank::SectionBotany),
"subsect" | "subsection" => Some(Rank::SubsectionBotany),
"supersect" | "suprasect" => Some(Rank::SupersectionBotany),
"ser" | "series" => Some(Rank::SeriesBotany),
"subser" | "subseries" => Some(Rank::SubseriesBotany),
_ => None,
}
}
fn bot_to_zool(rank: Rank) -> Option<Rank> {
match rank {
Rank::SectionBotany => Some(Rank::SectionZoology),
Rank::SubsectionBotany => Some(Rank::SubsectionZoology),
Rank::SupersectionBotany => Some(Rank::SupersectionZoology),
Rank::SeriesBotany => Some(Rank::SeriesZoology),
Rank::SubseriesBotany => Some(Rank::SubseriesZoology),
Rank::SuperseriesBotany => Some(Rank::SuperseriesZoology),
_ => None,
}
}
static LEADING_INFRAGEN_MARKER: LazyLock<FancyRegex> = LazyLock::new(|| {
FancyRegex::new(
r"(?i)^(subg|subgen|subgenus|sect|section|subsect|subsection|supersect|suprasect|ser|series|subser|subseries)\.?\s+(?=[\p{Lu}])",
)
.unwrap()
});
fn strip_leading_infrageneric_marker(ctx: &mut ParseContext, s: String) -> String {
if let Ok(Some(caps)) = LEADING_INFRAGEN_MARKER.captures(&s) {
let marker = caps.get(1).unwrap().as_str().to_lowercase();
if let Some(mut r) = infrageneric_marker_rank(&marker) {
if ctx.requested_code == Some(NomCode::Zoological) {
if let Some(zool) = bot_to_zool(r) {
r = zool;
}
}
ctx.name.rank = r;
if let Some(code) = r.code() {
if ctx.name.code.is_none() {
ctx.name.code = Some(code);
}
}
let whole = caps.get(0).unwrap();
return java_trim(&s[whole.end()..]).to_string();
}
}
s
}
fn phrase_rank_marker(word: &str) -> Option<Rank> {
match word {
"sp" | "spec" => Some(Rank::Species),
"subsp" | "ssp" => Some(Rank::Subspecies),
"var" => Some(Rank::Variety),
"form" | "f" => Some(Rank::Form),
_ => None,
}
}
static GENUS_SUBGENUS_TEST: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"^[\p{Lu}][\p{Ll}]+(?-u:\s+)\([\p{Lu}][\p{Ll}]+\)$").unwrap());
static PHRASE_GENUS_SUBGENUS: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"^([\p{Lu}][\p{Ll}]+)\s+\(([\p{Lu}][\p{Ll}]+)\)$").unwrap());
static PHRASE_NAME: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(concat!(
r"^([\p{Lu}][\p{Ll}]+(?:\s+\([\p{Lu}][\p{Ll}]+\))?(?:\s+[\p{Ll}]+)?(?:\s+[\p{Lu}][\p{L}.]+)*)",
r"\s+(sp|spec|subsp|ssp|var|form|f)\.?",
r"\s+(",
r#"[\p{Lu}A-Z\d'"][^(]*\(.+\)[^$]*?"#,
r#"|['"][^'"]+['"]"#,
r")\s*$",
))
.unwrap()
});
fn stash_phrase_name(ctx: &mut ParseContext, s: String) -> String {
let Some(caps) = PHRASE_NAME.captures(&s) else {
return s;
};
let prefix = collapse_whitespace(caps.get(1).unwrap().as_str());
let marker = caps.get(2).unwrap().as_str();
let phrase = collapse_whitespace(caps.get(3).unwrap().as_str());
let Some(rank) = phrase_rank_marker(&marker.to_lowercase()) else {
return s;
};
let author_start = find_author_start(&prefix);
let prefix_is_genus_only = !prefix.contains(' ');
ctx.name.phrase = Some(if prefix_is_genus_only && rank == Rank::Species {
format!("{marker}. {phrase}")
} else {
phrase
});
let prefix_is_genus_plus_subgenus = GENUS_SUBGENUS_TEST.is_match(&prefix);
if let Some(author_start) = author_start {
format!(
"{} {marker}. {}",
java_trim(&prefix[..author_start]),
java_trim(&prefix[author_start..]),
)
} else if prefix_is_genus_only && rank != Rank::Species {
ctx.name.rank = rank;
prefix
} else if prefix_is_genus_plus_subgenus {
ctx.name.rank = rank;
match PHRASE_GENUS_SUBGENUS.captures(&prefix) {
Some(gm) => {
ctx.name.infrageneric_epithet = Some(gm.get(2).unwrap().as_str().to_string());
gm.get(1).unwrap().as_str().to_string()
}
None => prefix,
}
} else {
format!("{prefix} {marker}.")
}
}
static STANDALONE_MS: LazyLock<Regex> =
LazyLock::new(|| Regex::new(&format!(r"(?i)^(?:{MS_MARKERS})$")).unwrap());
static LEADING_HOMONYM_PAREN: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?i)^(?-u:\(\s*(?:non|nec|not)\b)").unwrap());
static PAREN_NOTE: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(
r"(?i)\((?-u:\s*)((?:auctt?|auctorum|sensu|sec|vide|synonym)(?-u:\b)[^)]*|(?-i:s\.(?-u:\s*)(?:str|s|l|lat|ampl)\.?))(?-u:\s*)\)(?-u:\s*)",
)
.unwrap()
});
fn on_authorship(
ctx: &mut ParseContext,
s: String,
step: fn(&mut ParseContext, String) -> String,
) -> String {
java_trim(&step(ctx, format!(" {s}"))).to_string()
}
pub(crate) fn strip_authorship_leading_steps(ctx: &mut ParseContext, s: String) -> String {
let steps: [fn(&mut ParseContext, String) -> String; 10] = [
repair_colon_diacritics,
flag_uncertain_authorship,
strip_imprint_years,
normalise_hyphens,
replace_homoglyphs,
strip_angle_bracket_authorship,
strip_html,
normalise_hort_ex_placeholder,
strip_extinct_dagger,
stash_synonym_bracket,
];
steps
.into_iter()
.fold(s, |s, step| on_authorship(ctx, s, step))
}
pub(crate) fn strip_authorship_trailing_steps(ctx: &mut ParseContext, s: String) -> String {
let steps: [fn(&mut ParseContext, String) -> String; 10] = [
strip_pro_parte,
strip_pro_sp_annotation,
strip_approved_lists,
strip_mihi,
strip_colon_concept_reference,
strip_sensu_lato_remainder,
strip_sensu_stricto_ss,
strip_aggregate_suffix,
strip_published_page,
strip_in_press,
];
steps
.into_iter()
.fold(s, |s, step| on_authorship(ctx, s, step))
}
pub(crate) fn strip_authorship_reference_steps(ctx: &mut ParseContext, s: String) -> String {
let steps: [fn(&mut ParseContext, String) -> String; 3] = [
strip_ipni_citation,
strip_period_separated_reference,
strip_comma_prefixed_reference,
];
steps
.into_iter()
.fold(s, |s, step| on_authorship(ctx, s, step))
}
pub(crate) fn strip_authorship_markers(authorship: &str, name: &mut ParsedName) -> String {
let mut s = java_trim(authorship).to_string();
if s.is_empty() {
return s;
}
if STANDALONE_MS.is_match(&s) {
return strip_trailing_manuscript_marker(&format!(" {s}"), name);
}
if let Some(m) = SIC_WITH_COMMENT.find(&s) {
name.original_spelling = Some(true);
s = format!("{}{}", &s[..m.start()], &s[m.end()..]);
}
if let Some(m) = SIC.find(&s) {
name.original_spelling = Some(true);
s = format!("{}{}", &s[..m.start()], &s[m.end()..]);
}
{
let padded = format!(" {s}");
if let Ok(Some(_)) = CORRIG.find(&padded) {
name.original_spelling = Some(false);
let stripped = fancy_replace_all(&CORRIG, &padded, |_| String::new());
s = collapse_whitespace(&stripped);
}
}
s = remove_replacement_characters(name, s);
if s.contains('?') && LETTER_QMARK_LETTER.is_match(&s) {
s = remove_qmarks_between_letters(s);
name.doubtful = true;
name.add_warning(warnings::QUESTION_MARKS_REMOVED);
}
s = repair_win1252_artefacts_name(name, s);
s = fancy_replace_all(&HORT_EX, &s, |_| "hort.".to_string());
s = fancy_replace_all(&HORTUS_EX, &s, |_| "hort.".to_string());
s = java_trim(&normalise_anon_str(&format!(" {s}"))).to_string();
let mut notes: Vec<String> = Vec::new();
let mut tail_notes: Vec<String> = Vec::new();
s = unwrap_keyword_only_bracket(&s);
loop {
let caps = match BRACKETED_TAX_NOTE.captures(&s) {
Some(c) => c,
None => match PAREN_TAX_NOTE.captures(&s) {
Some(c) => c,
None => break,
},
};
let collapsed = WHITESPACE.replace_all(java_trim(caps.get(1).unwrap().as_str()), " ");
tail_notes.push(normalise_leading_auct(&collapsed));
s = java_trim(&s[..caps.get(0).unwrap().start()]).to_string();
while s.ends_with(',') {
s.pop();
s = java_trim(&s).to_string();
}
}
if LEADING_HOMONYM_PAREN.is_match(&s) {
notes.push(collapse_whitespace(&s));
s.clear();
}
if let Some(caps) = PAREN_NOTE.captures(&s) {
let inner = java_trim(caps.get(1).unwrap().as_str());
let norm = WHITESPACE.replace_all(inner, " ").into_owned();
notes.push(normalise_leading_auct(&norm));
let whole = caps.get(0).unwrap();
let (start, end) = (whole.start(), whole.end());
s = java_trim(&format!("{}{}", &s[..start], &s[end..])).to_string();
}
if let Some(caps) = AUTHORSHIP_QUOTED_ATTRIBUTED.captures(&s) {
s = format!("{} MS, {}", &caps[1], &caps[2]);
}
if let Ok(Some(caps)) = AUTHORSHIP_QUOTED_SPELLING.captures(&s) {
name.add_nomenclatural_note(caps.get(2).unwrap().as_str());
s = java_trim(caps.get(1).unwrap().as_str()).to_string();
}
if let Some(caps) = BRACKETED_NOM_NOTE.captures(&s) {
let raw = java_trim(caps.get(1).unwrap().as_str()).to_string();
if MANUSCRIPT_KEYWORD.is_match(&raw) {
name.manuscript = true;
}
let norm = normalise_nom_note(&raw);
name.add_nomenclatural_note(&norm);
let match_start = caps.get(0).unwrap().start();
s = java_trim(&s[..match_start]).to_string();
}
let padded_nom = format!(" {s}");
if let Ok(Some(caps)) = NOM_NOTE.captures(&padded_nom) {
let raw = java_trim(caps.get(1).unwrap().as_str()).to_string();
if !raw.is_empty() {
let norm = normalise_nom_note(&raw);
name.add_nomenclatural_note(&norm);
let whole = caps.get(0).unwrap();
let before = java_trim(&padded_nom[..whole.start()]).to_string();
let after = java_trim(&padded_nom[whole.end()..]).to_string();
s = if after.is_empty() {
before
} else {
format!("{before} {after}")
};
s = java_trim(&s).to_string();
while s.ends_with(',') {
s.pop();
s = java_trim(&s).to_string();
}
if MANUSCRIPT_KEYWORD.is_match(&raw) {
name.manuscript = true;
}
}
}
s = strip_not_validly_published_note(&s, name);
let padded_tax = format!(" {}", lift_bracketed_notes(&s));
if let Some((_, group1_start)) = find_tax_note(&padded_tax, true) {
let raw = java_trim(&padded_tax[group1_start..]).to_string();
if !raw.is_empty() {
let with_dots = INITIAL_DOT_SPACE.replace_all(&raw, "$1.$2");
notes.push(normalise_leading_auct(&with_dots));
s = java_trim(&padded_tax[..group1_start]).to_string();
while s.ends_with(',') {
s.pop();
s = java_trim(&s).to_string();
}
}
}
notes.extend(tail_notes.into_iter().rev());
notes.dedup();
if let Some(note) = notes.into_iter().reduce(|a, b| format!("{a} {b}")) {
name.taxonomic_note = Some(match name.taxonomic_note.take() {
Some(existing) => merge_notes(existing, note),
None => note,
});
}
java_trim(&s).to_string()
}
fn note_keyword_is_epithet(prefix: &str, rank: Option<Rank>) -> bool {
let words: Vec<&str> = prefix
.split_whitespace()
.filter(|w| !w.starts_with('('))
.collect();
match words.as_slice() {
[_genus] => !rank.is_some_and(|r| r.higher_than(Rank::SpeciesAggregate)),
[.., last] => rank_of_marker(last.trim_end_matches('.')).is_some(),
[] => false,
}
}
fn merge_notes(existing: String, note: String) -> String {
if contains_words(&existing, ¬e) {
existing
} else if contains_words(¬e, &existing) {
note
} else {
format!("{existing} {note}")
}
}
fn contains_words(haystack: &str, needle: &str) -> bool {
haystack.match_indices(needle).any(|(i, _)| {
let after = &haystack[i + needle.len()..];
(i == 0 || haystack[..i].ends_with(' '))
&& (after.is_empty() || after.starts_with([' ', ',', ';']))
})
}
#[cfg(test)]
mod tests {
use super::*;
use crate::model::NameType;
fn ctx(s: &str) -> ParseContext {
ParseContext::new(s.to_string(), None, None, None)
}
#[test]
fn run_leaves_a_clean_binomial_untouched() {
let mut c = ParseContext::new("Abies alba Mill.".to_string(), None, None, None);
let before_working = c.working.clone();
let before_name = c.name.clone();
run(&mut c);
assert_eq!(c.working, before_working);
assert_eq!(c.name, before_name);
}
#[test]
fn trailing_qmark_is_stripped_and_flags_doubtful() {
let mut c = ctx("x");
let out = flag_uncertain_authorship(&mut c, "Aus bus Smith ?".to_string());
assert_eq!(out, "Aus bus Smith");
assert!(c.name.doubtful);
assert!(c
.name
.warnings
.contains(&warnings::QUESTION_MARKS_REMOVED.to_string()));
}
#[test]
fn qmark_glued_to_author_word_flags_uncertain_without_stripping() {
let mut c = ctx("x");
let out = flag_uncertain_authorship(&mut c, "Aus bus Sess?".to_string());
assert_eq!(out, "Aus bus Sess?");
assert!(c.name.doubtful);
assert!(c
.name
.warnings
.contains(&warnings::UNCERTAIN_AUTHORSHIP.to_string()));
}
#[test]
fn or_joined_alternative_authors_flag_uncertain_without_stripping() {
let mut c = ctx("x");
let out = flag_uncertain_authorship(&mut c, "Aus bus Jarocki or Schinz, 1900".to_string());
assert_eq!(out, "Aus bus Jarocki or Schinz, 1900");
assert!(c.name.doubtful);
assert!(c
.name
.warnings
.contains(&warnings::UNCERTAIN_AUTHORSHIP.to_string()));
}
#[test]
fn slash_joined_alternative_authors_flag_uncertain_without_stripping() {
let mut c = ctx("x");
let out = flag_uncertain_authorship(&mut c, "Aus bus Smith/Jones, 1900".to_string());
assert_eq!(out, "Aus bus Smith/Jones, 1900");
assert!(c.name.doubtful);
}
#[test]
fn clean_name_is_not_flagged() {
let mut c = ctx("x");
let out = flag_uncertain_authorship(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert!(!c.name.doubtful);
assert!(c.name.warnings.is_empty());
}
#[test]
fn infrageneric_author_before_marker_is_extracted() {
let mut c = ctx("x");
let out =
extract_generic_author(&mut c, "Cordia (Adans.) Kuntze sect. Salimori".to_string());
assert_eq!(out, "Cordia sect. Salimori");
assert_eq!(
c.pending_generic_author,
Some("(Adans.) Kuntze".to_string())
);
}
#[test]
fn no_infrageneric_marker_leaves_string_untouched() {
let mut c = ctx("x");
let out = extract_generic_author(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert_eq!(c.pending_generic_author, None);
}
#[test]
fn single_quoted_leading_monomial_is_unquoted_and_flagged_doubtful() {
let mut c = ctx("x");
let out = strip_quoted_monomial(&mut c, "'Prosthète' Hesse, 1861".to_string());
assert_eq!(out, "Prosthète Hesse, 1861");
assert_eq!(c.quoted_monomial, Some("'".to_string()));
assert!(c.name.doubtful);
}
#[test]
fn double_quoted_monomial_with_no_trailing_text() {
let mut c = ctx("x");
let out = strip_quoted_monomial(&mut c, "\"Foo\"".to_string());
assert_eq!(out, "Foo");
assert_eq!(c.quoted_monomial, Some("\"".to_string()));
}
#[test]
fn unquoted_name_is_untouched() {
let mut c = ctx("x");
let out = strip_quoted_monomial(&mut c, "Abies alba".to_string());
assert_eq!(out, "Abies alba");
assert_eq!(c.quoted_monomial, None);
}
#[test]
fn inferred_missing_genus_gets_placeholder_type_and_warning() {
let mut c = ctx("x");
let out =
apply_missing_genus_placeholder(&mut c, "denheyeri Eghbalian, Path, 2017".to_string());
assert_eq!(out, "? denheyeri Eghbalian, Path, 2017");
assert_eq!(c.name.type_, NameType::Placeholder);
assert!(c
.name
.warnings
.contains(&warnings::MISSING_GENUS.to_string()));
}
#[test]
fn explicit_missing_prefix_gets_placeholder_type_but_no_warning() {
let mut c = ctx("x");
let out = apply_missing_genus_placeholder(
&mut c,
"Missing penchinati Bourguignat, 1870".to_string(),
);
assert_eq!(out, "? penchinati Bourguignat, 1870");
assert_eq!(c.name.type_, NameType::Placeholder);
assert!(c.name.warnings.is_empty());
}
#[test]
fn quoted_question_prefix_gets_placeholder_type_but_no_warning() {
let mut c = ctx("x");
let out = apply_missing_genus_placeholder(&mut c, "\"? gryphoidis".to_string());
assert_eq!(out, "? gryphoidis");
assert_eq!(c.name.type_, NameType::Placeholder);
assert!(c.name.warnings.is_empty());
}
#[test]
fn particle_led_epithet_shape_is_not_treated_as_missing_genus() {
let mut c = ctx("x");
let out = apply_missing_genus_placeholder(&mut c, "van Berg".to_string());
assert_eq!(out, "van Berg");
assert_eq!(c.name.type_, NameType::Scientific);
}
#[test]
fn note_keyword_led_epithet_shape_is_not_treated_as_missing_genus() {
let mut c = ctx("x");
let out = apply_missing_genus_placeholder(&mut c, "sensu Author".to_string());
assert_eq!(out, "sensu Author");
assert_eq!(c.name.type_, NameType::Scientific);
}
#[test]
fn clean_capitalised_name_is_untouched() {
let mut c = ctx("x");
let out = apply_missing_genus_placeholder(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert_eq!(c.name.type_, NameType::Scientific);
}
#[test]
fn greek_letter_marker_between_epithets_is_collapsed_to_a_space() {
let mut c = ctx("x");
let out = strip_infra_rank_letters(&mut c, "Foo bar \u{03B1} baz".to_string());
assert_eq!(out, "Foo bar baz");
}
#[test]
fn apl_alpha_lookalike_marker_is_also_collapsed() {
let mut c = ctx("x");
let out = strip_infra_rank_letters(&mut c, "Foo bar \u{237A} baz".to_string());
assert_eq!(out, "Foo bar baz");
}
#[test]
fn star_marker_between_epithets_is_collapsed_to_a_space() {
let mut c = ctx("x");
let out = strip_infra_rank_letters(&mut c, "Foo bar *** baz".to_string());
assert_eq!(out, "Foo bar baz");
}
#[test]
fn no_infra_rank_letter_marker_is_untouched() {
let mut c = ctx("x");
let out = strip_infra_rank_letters(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
}
#[test]
fn letter_subdivision_marker_is_rewritten_to_the_synthetic_token() {
let mut c = ctx("x");
let out = normalise_letter_subdivision_marker(
&mut c,
"Graphis scripta L. a.b pulverulenta".to_string(),
);
assert_eq!(out, "Graphis scripta L. infrasubdivision pulverulenta");
}
#[test]
fn real_rank_marker_shaped_like_a_single_letter_is_left_alone() {
let mut c = ctx("x");
let out = normalise_letter_subdivision_marker(
&mut c,
"Graphis scripta L. f. pulverulenta".to_string(),
);
assert_eq!(out, "Graphis scripta L. f. pulverulenta");
}
#[test]
fn non_matching_shape_is_untouched() {
let mut c = ctx("x");
let out = normalise_letter_subdivision_marker(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
}
#[test]
fn qmark_inside_a_word_is_removed_and_flags_doubtful() {
let mut c = ctx("x");
let out = repair_question_mark_in_word(&mut c, "Aus bus Istv?nffi".to_string());
assert_eq!(out, "Aus bus Istvnffi");
assert!(c.name.doubtful);
assert!(c
.name
.warnings
.contains(&warnings::QUESTION_MARKS_REMOVED.to_string()));
}
#[test]
fn no_internal_qmark_is_untouched() {
let mut c = ctx("x");
let out = repair_question_mark_in_word(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert!(!c.name.doubtful);
}
#[test]
fn quoted_strain_designation_becomes_a_phrase() {
let mut c = ctx("x");
let out =
strip_strain_designation(&mut c, "Aphanizomenon flos-aquae str .'Aph K2'".to_string());
assert_eq!(out, "Aphanizomenon flos-aquae str.");
assert_eq!(c.name.phrase, Some("Aph K2".to_string()));
assert_eq!(c.name.type_, NameType::Informal);
}
#[test]
fn strain_designation_with_lowercase_prefix_is_untouched() {
let mut c = ctx("x");
let out = strip_strain_designation(&mut c, "foo str .'Aph K2'".to_string());
assert_eq!(out, "foo str .'Aph K2'");
assert_eq!(c.name.phrase, None);
}
#[test]
fn no_strain_marker_is_untouched() {
let mut c = ctx("x");
let out = strip_strain_designation(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
}
#[test]
fn trailing_rna_code_becomes_a_phrase() {
let mut c = ctx("x");
let out = stash_trailing_strain_code(&mut c, "Candida albicans RNA_CTR0-3".to_string());
assert_eq!(out, "Candida albicans");
assert_eq!(c.name.phrase, Some("RNA_CTR0-3".to_string()));
assert_eq!(c.name.type_, NameType::Informal);
}
#[test]
fn trailing_short_rna_code_becomes_a_phrase() {
let mut c = ctx("x");
let out = stash_trailing_strain_code(&mut c, "Armillaria ostoyae RNA1".to_string());
assert_eq!(out, "Armillaria ostoyae");
assert_eq!(c.name.phrase, Some("RNA1".to_string()));
}
#[test]
fn clean_binomial_with_no_trailing_code_is_untouched() {
let mut c = ctx("x");
let out = stash_trailing_strain_code(&mut c, "Abies alba".to_string());
assert_eq!(out, "Abies alba");
assert_eq!(c.name.phrase, None);
}
#[test]
fn trailing_digit_leading_code_becomes_a_phrase() {
for (input, head, code) in [
("Prunus domestica 6", "Prunus domestica", "6"),
("Prunus domestica 5a", "Prunus domestica", "5a"),
("Prunus domestica 6/12", "Prunus domestica", "6/12"),
("Abies alba 12", "Abies alba", "12"),
("Escherichia coli 18-41", "Escherichia coli", "18-41"),
(
"Acinetobacter baumannii 1237893",
"Acinetobacter baumannii",
"1237893",
),
(
"Actinomycetota bacterium 4327",
"Actinomycetota bacterium",
"4327",
),
(
"Lachnospiraceae bacterium 47-T17",
"Lachnospiraceae bacterium",
"47-T17",
),
("Trachelomonas strain T101", "Trachelomonas strain", "T101"),
] {
let mut c = ctx("x");
let out = stash_trailing_strain_code(&mut c, input.to_string());
assert_eq!(out, head, "head for {input:?}");
assert_eq!(
c.name.phrase,
Some(code.to_string()),
"phrase for {input:?}"
);
assert_eq!(c.name.type_, NameType::Informal, "type for {input:?}");
}
}
#[test]
fn trailing_bare_year_is_left_for_the_authorship_parser() {
for input in ["Prunus domestica 1888", "Xanthomonas eucalypti 1974"] {
let mut c = ctx("x");
let out = stash_trailing_strain_code(&mut c, input.to_string());
assert_eq!(out, input);
assert_eq!(c.name.phrase, None);
}
}
#[test]
fn trailing_numeral_epithet_is_not_a_strain_code() {
let mut c = ctx("x");
let out = stash_trailing_strain_code(&mut c, "Episyron rufipes 7-maculatus".to_string());
assert_eq!(out, "Episyron rufipes 7-maculatus");
assert_eq!(c.name.phrase, None);
}
#[test]
fn indet_species_marker_head_is_left_to_name_tokens() {
for input in ["Allium species 1", "Anopheles sp TIP1", "Allium spec 1"] {
let mut c = ctx("x");
let out = stash_trailing_strain_code(&mut c, input.to_string());
assert_eq!(out, input, "for {input:?}");
assert_eq!(c.name.phrase, None, "for {input:?}");
}
}
#[test]
fn a_full_stop_closing_the_string_is_not_part_of_the_code() {
for (input, head, code) in [
("Prunus domestica 6.", "Prunus domestica", "6"),
("Bacteroides caccae CAG21.", "Bacteroides caccae", "CAG21"),
] {
let mut c = ctx("x");
let out = stash_trailing_strain_code(&mut c, input.to_string());
assert_eq!(out, head, "head for {input:?}");
assert_eq!(
c.name.phrase,
Some(code.to_string()),
"phrase for {input:?}"
);
}
}
#[test]
fn a_dotted_bare_year_is_still_left_for_the_authorship_parser() {
let mut c = ctx("x");
let out = stash_trailing_strain_code(&mut c, "Prunus domestica 1888.".to_string());
assert_eq!(out, "Prunus domestica 1888.");
assert_eq!(c.name.phrase, None);
}
#[test]
fn a_rank_marker_in_the_epithet_slot_takes_the_whole_tail_as_the_phrase() {
for (input, genus, phrase) in [
("Allium sect 1", "Allium", "sect 1"),
("Allium sect. 1", "Allium", "sect. 1"),
("Allium subg. 3", "Allium", "subg. 3"),
("Allium var 3", "Allium", "var 3"),
("Trachelomonas strain T101", "Trachelomonas", "strain T101"),
] {
let mut c = ctx("x");
let out = stash_trailing_rank_marker_code(&mut c, input.to_string());
assert_eq!(out, genus, "head for {input:?}");
assert_eq!(
c.name.phrase,
Some(phrase.to_string()),
"phrase for {input:?}"
);
assert_eq!(c.name.type_, NameType::Informal, "type for {input:?}");
}
}
#[test]
fn the_rank_marker_step_sets_only_an_infraspecific_rank() {
let mut c = ctx("x");
stash_trailing_rank_marker_code(&mut c, "Allium var. 3".to_string());
assert_eq!(c.name.rank, Rank::Variety);
let mut c = ctx("x");
let out = stash_trailing_rank_marker_code(&mut c, "Allium sect. 1".to_string());
assert_eq!(out, "Allium");
assert_eq!(c.name.phrase, Some("sect. 1".to_string()));
assert_eq!(c.name.rank, Rank::Unranked);
}
#[test]
fn the_rank_marker_step_leaves_real_epithets_and_indet_markers_alone() {
for input in [
"Bacteroides caccae CAG21",
"Prunus domestica 6",
"Allium species 1",
"Allium sp. 1",
] {
let mut c = ctx("x");
let out = stash_trailing_rank_marker_code(&mut c, input.to_string());
assert_eq!(out, input, "for {input:?}");
assert_eq!(c.name.phrase, None, "for {input:?}");
}
}
#[test]
fn quoted_bracketed_imprint_year_is_stashed() {
let mut c = ctx("x");
let out = strip_imprint_years(&mut c, "Aus bus Storr, 1970 [\"1969\"]".to_string());
assert_eq!(out, "Aus bus Storr, 1970");
assert_eq!(c.pending_imprint_year, Some("1969".to_string()));
}
#[test]
fn keyword_imprint_year_is_stashed() {
let mut c = ctx("x");
let out = strip_imprint_years(&mut c, "Aus bus Storr, 1970 (imprint 1969)".to_string());
assert_eq!(out, "Aus bus Storr, 1970");
assert_eq!(c.pending_imprint_year, Some("1969".to_string()));
}
#[test]
fn alt_ampersand_year_is_stashed_when_an_earlier_year_exists() {
let mut c = ctx("x");
let out = strip_imprint_years(&mut c, "Aus bus Wagener, 1959 & 1961".to_string());
assert_eq!(out, "Aus bus Wagener, 1959");
assert_eq!(c.pending_imprint_year, Some("1961".to_string()));
}
#[test]
fn alt_ampersand_year_is_not_stripped_without_an_earlier_year() {
let mut c = ctx("x");
let out = strip_imprint_years(&mut c, "Aus bus & 1961".to_string());
assert_eq!(out, "Aus bus & 1961");
assert_eq!(c.pending_imprint_year, None);
}
#[test]
fn no_imprint_year_annotation_is_untouched() {
let mut c = ctx("x");
let out = strip_imprint_years(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert_eq!(c.pending_imprint_year, None);
}
#[test]
fn bare_null_between_epithets_is_dropped_and_flags_doubtful() {
let mut c = ctx("x");
let out = strip_null_between_epithets(
&mut c,
"Austrorhynchus pectatus null pectatus".to_string(),
);
assert_eq!(out, "Austrorhynchus pectatus pectatus");
assert!(c.name.doubtful);
assert!(c
.name
.warnings
.contains(&warnings::NULL_EPITHET.to_string()));
}
#[test]
fn no_null_epithet_is_untouched() {
let mut c = ctx("x");
let out = strip_null_between_epithets(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert!(!c.name.doubtful);
}
#[test]
fn en_dash_is_normalised_to_ascii_hyphen_and_flags_homoglyphs() {
let mut c = ctx("x");
let out = normalise_hyphens(&mut c, "Aus bus\u{2013}fer Mill.".to_string());
assert_eq!(out, "Aus bus-fer Mill.");
assert!(c.name.warnings.contains(&warnings::HOMOGLYHPS.to_string()));
}
#[test]
fn all_five_unicode_hyphen_variants_are_normalised() {
let mut c = ctx("x");
let input = "a\u{2010}b\u{2011}c\u{2012}d\u{2013}e\u{2014}f";
let out = normalise_hyphens(&mut c, input.to_string());
assert_eq!(out, "a-b-c-d-e-f");
}
#[test]
fn ascii_hyphen_alone_is_untouched_with_no_warning() {
let mut c = ctx("x");
let out = normalise_hyphens(&mut c, "Aus bus-fer Mill.".to_string());
assert_eq!(out, "Aus bus-fer Mill.");
assert!(c.name.warnings.is_empty());
}
#[test]
fn cyrillic_lookalike_is_folded_to_latin_and_flags_homoglyphs() {
let mut c = ctx("x");
let out = replace_homoglyphs(&mut c, "Aus \u{0430}bus".to_string()); assert_eq!(out, "Aus abus");
assert!(c.name.warnings.contains(&warnings::HOMOGLYHPS.to_string()));
}
#[test]
fn long_s_in_specific_epithet_is_folded_and_flags_homoglyphs() {
let mut c = ctx("x");
let out = replace_homoglyphs(&mut c, "Musca dome\u{017F}tica Linnaeus 1758".to_string());
assert_eq!(out, "Musca domestica Linnaeus 1758");
assert!(c.name.warnings.contains(&warnings::HOMOGLYHPS.to_string()));
}
#[test]
fn hybrid_marker_and_ae_ligature_are_not_homoglyphs_here_either() {
let mut c = ctx("x");
let out = replace_homoglyphs(&mut c, "Abies \u{00D7} Picea".to_string());
assert_eq!(out, "Abies \u{00D7} Picea");
assert!(c.name.warnings.is_empty());
let mut c2 = ctx("x");
let out2 = replace_homoglyphs(&mut c2, "Amphisb\u{00E6}na".to_string());
assert_eq!(out2, "Amphisb\u{00E6}na");
assert!(c2.name.warnings.is_empty());
}
#[test]
fn plain_name_is_untouched_with_no_warning() {
let mut c = ctx("x");
let out = replace_homoglyphs(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert!(c.name.warnings.is_empty());
}
#[test]
fn inverted_exclamation_artefact_is_repaired_and_flags_homoglyphs() {
let mut c = ctx("x");
let out = repair_win1252_artefacts(&mut c, "Aus bus Plesn\u{00A1}k, 1900".to_string());
assert_eq!(out, "Aus bus Plesnik, 1900");
assert!(c.name.warnings.contains(&warnings::HOMOGLYHPS.to_string()));
}
#[test]
fn all_six_win1252_artefacts_are_repaired() {
let mut c = ctx("x");
let input = "\u{00A1}\u{00A2}\u{00A3}\u{201A}\u{201E}\u{2030}";
let out = repair_win1252_artefacts(&mut c, input.to_string());
assert_eq!(out, "icLeae");
}
#[test]
fn no_win1252_artefact_is_untouched_with_no_warning() {
let mut c = ctx("x");
let out = repair_win1252_artefacts(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert!(c.name.warnings.is_empty());
}
#[test]
fn colon_coded_diacritics_are_restored() {
let mut c = ctx("x");
let out = repair_colon_diacritics(&mut c, "A:1ngstro:2m, Vondra:4c:3ek".to_string());
assert_eq!(out, "Ångström, Vondráček");
assert!(c.coded_diacritics);
assert!(c.name.warnings.contains(&warnings::HOMOGLYHPS.to_string()));
}
#[test]
fn a_colon_before_several_digits_or_no_letter_is_no_diacritic() {
let mut c = ctx("x");
let input = "Smith DOI:10.1234, names:864424, Mus:9";
let out = repair_colon_diacritics(&mut c, input.to_string());
assert_eq!(out, input);
assert!(!c.coded_diacritics);
assert!(c.name.warnings.is_empty());
}
#[test]
fn double_underscore_collapses_to_a_single_space() {
let mut c = ctx("x");
let out = normalise_double_underscores(&mut c, "Pseudocercospora__dendrobii".to_string());
assert_eq!(out, "Pseudocercospora dendrobii");
}
#[test]
fn triple_underscore_also_collapses_to_a_single_space() {
let mut c = ctx("x");
let out = normalise_double_underscores(&mut c, "Foo___bar".to_string());
assert_eq!(out, "Foo bar");
}
#[test]
fn single_underscore_is_untouched() {
let mut c = ctx("x");
let out = normalise_double_underscores(&mut c, "Foo_bar".to_string());
assert_eq!(out, "Foo_bar");
}
#[test]
fn trailing_otu_code_is_stashed_as_pending_unparsed() {
let mut c = ctx("x");
let out = stash_trailing_otu_code(&mut c, "Oxalis barrelieri XXZ_21243".to_string());
assert_eq!(out, "Oxalis barrelieri");
assert_eq!(c.pending_unparsed, Some("XXZ_21243".to_string()));
}
#[test]
fn otu_code_extraction_is_skipped_when_pending_unparsed_already_set() {
let mut c = ctx("x");
c.pending_unparsed = Some("existing".to_string());
let out = stash_trailing_otu_code(&mut c, "Oxalis barrelieri XXZ_21243".to_string());
assert_eq!(out, "Oxalis barrelieri XXZ_21243");
assert_eq!(c.pending_unparsed, Some("existing".to_string()));
}
#[test]
fn single_word_input_is_untouched() {
let mut c = ctx("x");
let out = stash_trailing_otu_code(&mut c, "Abies".to_string());
assert_eq!(out, "Abies");
assert_eq!(c.pending_unparsed, None);
}
#[test]
fn bare_serovar_annotation_is_stripped_silently() {
let mut c = ctx("x");
let out =
strip_serovar_serotype(&mut c, "Leptospira interrogans serovar Fugis".to_string());
assert_eq!(out, "Leptospira interrogans");
assert!(c.name.warnings.is_empty());
}
#[test]
fn serotype_with_trailing_strain_suffix_is_stripped() {
let mut c = ctx("x");
let out = strip_serovar_serotype(
&mut c,
"Aggregatibacter actinomycetemcomitans serotype d str. SA508".to_string(),
);
assert_eq!(out, "Aggregatibacter actinomycetemcomitans");
}
#[test]
fn parenthesised_serotype_annotation_is_stripped() {
let mut c = ctx("x");
let out =
strip_serovar_serotype(&mut c, "Streptococcus pyogenes (serotype M18)".to_string());
assert_eq!(out, "Streptococcus pyogenes");
}
#[test]
fn no_serovar_annotation_is_untouched() {
let mut c = ctx("x");
let out = strip_serovar_serotype(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
}
#[test]
fn angle_bracketed_authorship_placeholder_is_stripped() {
let mut c = ctx("x");
let out =
strip_angle_bracket_authorship(&mut c, "Doradidae <Unspecified Agent>".to_string());
assert_eq!(out, "Doradidae");
assert!(c.name.doubtful);
assert!(c
.name
.warnings
.contains(&warnings::AUTHORSHIP_REMOVED.to_string()));
assert!(c
.name
.warnings
.contains(&warnings::UNUSUAL_CHARACTERS.to_string()));
}
#[test]
fn no_angle_bracket_is_untouched() {
let mut c = ctx("x");
let out = strip_angle_bracket_authorship(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert!(!c.name.doubtful);
}
#[test]
fn html_tags_are_stripped_keeping_text_content() {
let mut c = ctx("x");
let out = strip_html(&mut c, "<i>Aus bus</i> Smith".to_string());
assert_eq!(out, "Aus bus Smith");
assert!(c.name.warnings.contains(&warnings::XML_TAGS.to_string()));
}
#[test]
fn html_entities_are_decoded() {
let mut c = ctx("x");
let out = strip_html(&mut c, "Aus & bus".to_string());
assert_eq!(out, "Aus & bus");
assert!(c
.name
.warnings
.contains(&warnings::HTML_ENTITIES.to_string()));
}
#[test]
fn whitespace_left_by_tag_removal_is_collapsed() {
let mut c = ctx("x");
let out = strip_html(&mut c, "Aus <br/> bus".to_string());
assert_eq!(out, "Aus bus");
}
#[test]
fn no_html_markup_is_untouched() {
let mut c = ctx("x");
let out = strip_html(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert!(c.name.warnings.is_empty());
}
#[test]
fn candidatus_prefix_is_stripped_and_flags_bacterial() {
let mut c = ctx("x");
let out = strip_candidatus(&mut c, "Candidatus Amesbacteria bacterium".to_string());
assert_eq!(out, "Amesbacteria bacterium");
assert!(c.name.candidatus);
assert_eq!(c.name.code, Some(NomCode::Bacterial));
}
#[test]
fn ca_abbreviation_prefix_is_stripped() {
let mut c = ctx("x");
let out = strip_candidatus(&mut c, "Ca. Halobonum".to_string());
assert_eq!(out, "Halobonum");
assert!(c.name.candidatus);
assert_eq!(c.name.code, Some(NomCode::Bacterial));
}
#[test]
fn quoted_candidatus_prefix_strips_leading_and_trailing_quote() {
let mut c = ctx("x");
let out = strip_candidatus(&mut c, "\"Candidatus Foo bar\"".to_string());
assert_eq!(out, "Foo bar");
assert!(c.name.candidatus);
}
#[test]
fn no_candidatus_prefix_is_untouched() {
let mut c = ctx("x");
let out = strip_candidatus(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert!(!c.name.candidatus);
assert_eq!(c.name.code, None);
}
#[test]
fn cv_ex_placeholder_is_normalised() {
let mut c = ctx("x");
let out = normalise_hort_ex_placeholder(&mut c, "Rosa foo cv. ex Smith".to_string());
assert_eq!(out, "Rosa foo hort. ex Smith");
}
#[test]
fn hort_ex_placeholder_is_normalised() {
let mut c = ctx("x");
let out = normalise_hort_ex_placeholder(&mut c, "Rosa foo Hort. ex Smith".to_string());
assert_eq!(out, "Rosa foo hort. ex Smith");
}
#[test]
fn hortus_ex_placeholder_is_normalised() {
let mut c = ctx("x");
let out = normalise_hort_ex_placeholder(&mut c, "Rosa foo hortus ex Smith".to_string());
assert_eq!(out, "Rosa foo hort. ex Smith");
}
#[test]
fn ht_marker_is_normalised() {
let mut c = ctx("x");
let out =
normalise_hort_ex_placeholder(&mut c, "Gymnogramma alstoni ht.Birkenh.".to_string());
assert_eq!(out, "Gymnogramma alstoni hort.Birkenh.");
}
#[test]
fn no_hort_ex_placeholder_is_untouched() {
let mut c = ctx("x");
let out = normalise_hort_ex_placeholder(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
}
#[test]
fn trailing_group_marker_sets_cultivar_group_rank() {
let mut c = ctx("x");
let out = strip_cultivar_group_grex(&mut c, "Brassica oleracea Capitata Group".to_string());
assert_eq!(out, "Brassica oleracea");
assert_eq!(c.name.cultivar_epithet, Some("Capitata".to_string()));
assert_eq!(c.name.code, Some(NomCode::Cultivars));
assert_eq!(c.name.rank, Rank::CultivarGroup);
}
#[test]
fn trailing_grex_marker_sets_grex_rank() {
let mut c = ctx("x");
let out = strip_cultivar_group_grex(&mut c, "Paphiopedilum Maudiae grex".to_string());
assert_eq!(out, "Paphiopedilum");
assert_eq!(c.name.cultivar_epithet, Some("Maudiae".to_string()));
assert_eq!(c.name.code, Some(NomCode::Cultivars));
assert_eq!(c.name.rank, Rank::Grex);
}
#[test]
fn trailing_gx_marker_also_sets_grex_rank() {
let mut c = ctx("x");
let out = strip_cultivar_group_grex(&mut c, "Paphiopedilum Maudiae gx".to_string());
assert_eq!(out, "Paphiopedilum");
assert_eq!(c.name.rank, Rank::Grex);
}
#[test]
fn no_group_grex_marker_is_untouched() {
let mut c = ctx("x");
let out = strip_cultivar_group_grex(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert_eq!(c.name.cultivar_epithet, None);
}
#[test]
fn quoted_cultivar_at_end_with_explicit_cv_marker_is_captured() {
let mut c = ctx("x");
let out = strip_quoted_cultivar(&mut c, "Acer campestre L. cv. 'nanum'".to_string());
assert_eq!(out, "Acer campestre L.");
assert_eq!(c.name.cultivar_epithet, Some("nanum".to_string()));
assert_eq!(c.name.code, Some(NomCode::Cultivars));
assert_eq!(c.name.rank, Rank::Cultivar);
assert_eq!(c.pending_specific_author, None);
}
#[test]
fn quoted_cultivar_at_end_without_cv_marker_is_captured() {
let mut c = ctx("x");
let out = strip_quoted_cultivar(&mut c, "Acer pseudoplatanus L. 'Negenia'".to_string());
assert_eq!(out, "Acer pseudoplatanus L.");
assert_eq!(c.name.cultivar_epithet, Some("Negenia".to_string()));
}
#[test]
fn quoted_cultivar_mid_string_splits_off_preceding_specific_author() {
let mut c = ctx("x");
let out = strip_quoted_cultivar(
&mut c,
"Acer campestre L. cv. 'Elsrijk' Broerse".to_string(),
);
assert_eq!(out, "Acer campestre Broerse");
assert_eq!(c.name.cultivar_epithet, Some("Elsrijk".to_string()));
assert_eq!(c.name.code, Some(NomCode::Cultivars));
assert_eq!(c.name.rank, Rank::Cultivar);
assert_eq!(c.pending_specific_author, Some("L.".to_string()));
}
#[test]
fn quoted_cultivar_mid_string_without_cv_marker_and_without_preceding_author() {
let mut c = ctx("x");
let out = strip_quoted_cultivar(&mut c, "Verpericola megasoma \"Dall\" Pils.".to_string());
assert_eq!(out, "Verpericola megasoma Pils.");
assert_eq!(c.name.cultivar_epithet, Some("Dall".to_string()));
assert_eq!(c.pending_specific_author, None);
}
#[test]
fn unclosed_trailing_cultivar_quote_is_captured() {
let mut c = ctx("x");
let out = strip_quoted_cultivar(&mut c, "Genus species 'albino".to_string());
assert_eq!(out, "Genus species");
assert_eq!(c.name.cultivar_epithet, Some("albino".to_string()));
assert_eq!(c.name.code, Some(NomCode::Cultivars));
assert_eq!(c.name.rank, Rank::Cultivar);
}
#[test]
fn quote_preceded_by_bare_rank_marker_is_not_a_cultivar() {
let mut c = ctx("x");
let out = strip_quoted_cultivar(&mut c, "Genus species var. 'foo'".to_string());
assert_eq!(out, "Genus species var. 'foo'");
assert_eq!(c.name.cultivar_epithet, None);
}
#[test]
fn no_quoted_cultivar_is_untouched() {
let mut c = ctx("x");
let out = strip_quoted_cultivar(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert_eq!(c.name.cultivar_epithet, None);
}
#[test]
fn dagger_glued_to_genus_is_stripped_and_flags_extinct() {
let mut c = ctx("x");
let out = strip_extinct_dagger(
&mut c,
"Henriksenopterix\u{2020} paucistriata (Henriksen, 1922)".to_string(),
);
assert_eq!(out, "Henriksenopterix paucistriata (Henriksen, 1922)");
assert!(c.name.extinct);
}
#[test]
fn alternate_dagger_glyph_is_also_stripped() {
let mut c = ctx("x");
let out = strip_extinct_dagger(&mut c, "Foo \u{271D}bar".to_string());
assert_eq!(out, "Foo bar");
assert!(c.name.extinct);
}
#[test]
fn no_dagger_is_untouched() {
let mut c = ctx("x");
let out = strip_extinct_dagger(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert!(!c.name.extinct);
}
#[test]
fn tinfr_marker_between_species_and_infraspecific_epithet_is_stripped() {
let mut c = ctx("x");
let out = strip_tinfr_marker(&mut c, "Hieracium alpinum t.infr. foobarum".to_string());
assert_eq!(out, "Hieracium alpinum foobarum");
}
#[test]
fn tinfr_marker_directly_after_a_bare_genus_is_also_stripped() {
let mut c = ctx("x");
let out = strip_tinfr_marker(&mut c, "Hieracium t.infr. foobarum".to_string());
assert_eq!(out, "Hieracium foobarum");
}
#[test]
fn no_tinfr_marker_is_untouched() {
let mut c = ctx("x");
let out = strip_tinfr_marker(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
}
#[test]
fn bracketed_genus_followed_by_epithet_is_unbracketed_and_flags_doubtful() {
let mut c = ctx("x");
let out = strip_doubtful_genus_brackets(&mut c, "[Acontia] chia".to_string());
assert_eq!(out, "Acontia chia");
assert!(c.name.doubtful);
assert!(c
.name
.warnings
.contains(&warnings::DOUBTFUL_GENUS.to_string()));
}
#[test]
fn bracketed_genus_alone_is_unbracketed() {
let mut c = ctx("x");
let out = strip_doubtful_genus_brackets(&mut c, "[Dexia]".to_string());
assert_eq!(out, "Dexia");
assert!(c.name.doubtful);
}
#[test]
fn no_leading_bracket_is_untouched() {
let mut c = ctx("x");
let out = strip_doubtful_genus_brackets(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert!(!c.name.doubtful);
}
#[test]
fn bracketed_sic_with_comment_flags_true_and_stashes_squished_comment() {
let mut c = ctx("x");
let out = strip_sic_and_corrig(&mut c, "Aus bus Storr [sic, porphyria]".to_string());
assert_eq!(out, "Aus bus Storr");
assert_eq!(c.name.original_spelling, Some(true));
assert_eq!(c.pending_unparsed, Some("(sic,porphyria)".to_string()));
}
#[test]
fn multi_word_sic_comment_has_all_internal_whitespace_removed_not_just_collapsed() {
let mut c = ctx("x");
let out = strip_sic_and_corrig(&mut c, "Foo bar [sic, multiple words here]".to_string());
assert_eq!(out, "Foo bar");
assert_eq!(
c.pending_unparsed,
Some("(sic,multiplewordshere)".to_string())
);
}
#[test]
fn plain_sic_without_comment_flags_true() {
let mut c = ctx("x");
let out = strip_sic_and_corrig(
&mut c,
"Ameiva plei (sic) Duméril & Bibron, 1839".to_string(),
);
assert_eq!(out, "Ameiva plei Duméril & Bibron, 1839");
assert_eq!(c.name.original_spelling, Some(true));
assert_eq!(c.pending_unparsed, None);
}
#[test]
fn bare_corrig_marker_flags_false() {
let mut c = ctx("x");
let out = strip_sic_and_corrig(&mut c, "Aus bus corrig. Peters, 1878".to_string());
assert_eq!(out, "Aus bus Peters, 1878");
assert_eq!(c.name.original_spelling, Some(false));
}
#[test]
fn bracketed_corrig_marker_flags_false() {
let mut c = ctx("x");
let out = strip_sic_and_corrig(&mut c, "Aus bus (corrig.) Smith".to_string());
assert_eq!(out, "Aus bus Smith");
assert_eq!(c.name.original_spelling, Some(false));
}
#[test]
fn leading_standalone_corrig_is_stripped_via_the_pad_harness() {
let mut c = ctx("x");
let out = strip_sic_and_corrig(&mut c, "corrig. Peters, 1878".to_string());
assert_eq!(out, "Peters, 1878");
assert_eq!(c.name.original_spelling, Some(false));
}
#[test]
fn no_sic_or_corrig_marker_is_untouched() {
let mut c = ctx("x");
let out = strip_sic_and_corrig(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert_eq!(c.name.original_spelling, None);
}
#[test]
fn trailing_synonym_bracket_is_stashed_verbatim_with_brackets() {
let mut c = ctx("x");
let out = stash_synonym_bracket(&mut c, "Aus bus [= Grislea L. 1753]".to_string());
assert_eq!(out, "Aus bus");
assert_eq!(c.pending_unparsed, Some("[= Grislea L. 1753]".to_string()));
assert!(c.name.doubtful);
}
#[test]
fn dangling_commas_before_the_bracket_are_all_stripped() {
let mut c = ctx("x");
let out = stash_synonym_bracket(&mut c, "Aus bus,, [= Grislea L. 1753]".to_string());
assert_eq!(out, "Aus bus");
}
#[test]
fn no_synonym_bracket_is_untouched() {
let mut c = ctx("x");
let out = stash_synonym_bracket(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert_eq!(c.pending_unparsed, None);
assert!(!c.name.doubtful);
}
#[test]
fn normalise_nom_note_adds_a_closing_dot_to_an_abbreviated_note() {
assert_eq!(normalise_nom_note("nom nud"), "nom nud.");
}
#[test]
fn normalise_nom_note_leaves_a_full_word_suffix_without_an_added_dot() {
assert_eq!(normalise_nom_note("orth error"), "orth error");
}
#[test]
fn normalise_nom_note_strips_trailing_dots_from_spelled_out_nomen_forms() {
assert_eq!(normalise_nom_note("nomen nudum..."), "nomen nudum");
}
#[test]
fn normalise_nom_note_normalises_et_and_and_to_ampersand() {
assert_eq!(
normalise_nom_note("nom. cons. et typ. cons"),
"nom. cons. & typ. cons."
);
}
#[test]
fn bracketed_nom_nud_note_overwrites_nomenclatural_note() {
let mut c = ctx("x");
let out = strip_bracketed_nom_note(
&mut c,
"Baccharis microphylla var. rhomboidea (nom. nud.)".to_string(),
);
assert_eq!(out, "Baccharis microphylla var. rhomboidea");
assert_eq!(c.name.nomenclatural_note, Some("nom. nud.".to_string()));
}
#[test]
fn bracketed_nom_illeg_note_overwrites_nomenclatural_note() {
let mut c = ctx("x");
let out =
strip_bracketed_nom_note(&mut c, "Barbula obscura Sull. (nom. illeg.)".to_string());
assert_eq!(out, "Barbula obscura Sull.");
assert_eq!(c.name.nomenclatural_note, Some("nom. illeg.".to_string()));
}
#[test]
fn preexisting_note_is_overwritten_not_appended() {
let mut c = ctx("x");
c.name.nomenclatural_note = Some("existing".to_string());
let out = strip_bracketed_nom_note(&mut c, "Foo bar (nom. nud.)".to_string());
assert_eq!(out, "Foo bar");
assert_eq!(c.name.nomenclatural_note, Some("nom. nud.".to_string()));
}
#[test]
fn no_bracketed_nom_note_is_untouched() {
let mut c = ctx("x");
let out = strip_bracketed_nom_note(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert_eq!(c.name.nomenclatural_note, None);
}
#[test]
fn sp_nov_on_a_bare_monomial_appends_note_and_keeps_a_bare_sp_marker() {
let mut c = ctx("x");
let out = strip_nom_note(&mut c, "Abies sp. nov.".to_string());
assert_eq!(out, "Abies sp.");
assert_eq!(c.name.nomenclatural_note, Some("sp. nov.".to_string()));
assert!(!c.name.manuscript);
}
#[test]
fn sp_nov_ined_also_sets_manuscript_true() {
let mut c = ctx("x");
let out = strip_nom_note(&mut c, "Abies sp. nov. ined.".to_string());
assert_eq!(out, "Abies sp.");
assert_eq!(
c.name.nomenclatural_note,
Some("sp. nov. ined.".to_string())
);
assert!(c.name.manuscript);
}
#[test]
fn sp_nov_on_a_full_binomial_does_not_trigger_the_bare_sp_override() {
let mut c = ctx("x");
let out = strip_nom_note(&mut c, "Abies alba Sp. nov.".to_string());
assert_eq!(out, "Abies alba");
assert_eq!(c.name.nomenclatural_note, Some("Sp. nov.".to_string()));
}
#[test]
fn gen_nov_pins_genus_rank_when_unranked() {
let mut c = ctx("x");
let out = strip_nom_note(&mut c, "Fooxus gen. nov.".to_string());
assert_eq!(out, "Fooxus");
assert_eq!(c.name.nomenclatural_note, Some("gen. nov.".to_string()));
assert_eq!(c.name.rank, Rank::Genus);
}
#[test]
fn var_nov_pins_variety_rank() {
let mut c = ctx("x");
let out = strip_nom_note(&mut c, "Foovar var. nov.".to_string());
assert_eq!(out, "Foovar");
assert_eq!(c.name.rank, Rank::Variety);
}
#[test]
fn fam_nov_pins_family_rank() {
let mut c = ctx("x");
let out = strip_nom_note(&mut c, "Foofam fam. nov.".to_string());
assert_eq!(out, "Foofam");
assert_eq!(c.name.rank, Rank::Family);
}
#[test]
fn form_nov_pins_form_rank() {
let mut c = ctx("x");
let out = strip_nom_note(&mut c, "Fooform form. nov.".to_string());
assert_eq!(out, "Fooform");
assert_eq!(c.name.rank, Rank::Form);
}
#[test]
fn rank_hint_does_not_override_an_already_set_rank() {
let mut c = ctx("x");
c.name.rank = Rank::Species;
let out = strip_nom_note(&mut c, "Fooxus gen. nov.".to_string());
assert_eq!(out, "Fooxus");
assert_eq!(
c.name.rank,
Rank::Species,
"an already-set rank must not be clobbered by the hint"
);
}
#[test]
fn nom_note_appends_to_an_existing_nomenclatural_note() {
let mut c = ctx("x");
c.name.nomenclatural_note = Some("existing".to_string());
let out = strip_nom_note(&mut c, "Foo bar comb. nov.".to_string());
assert_eq!(out, "Foo bar");
assert_eq!(
c.name.nomenclatural_note,
Some("existing comb. nov.".to_string())
);
}
#[test]
fn no_nom_note_keyword_is_untouched() {
let mut c = ctx("x");
let out = strip_nom_note(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert_eq!(c.name.nomenclatural_note, None);
assert!(!c.name.manuscript);
}
#[test]
fn nom_note_requires_a_leading_whitespace_and_does_not_fire_at_string_start() {
let mut c = ctx("x");
let out = strip_nom_note(&mut c, "Gen. nov. Foobarus".to_string());
assert_eq!(out, "Gen. nov. Foobarus");
assert_eq!(c.name.nomenclatural_note, None);
assert_eq!(c.name.rank, Rank::Unranked);
}
#[test]
fn nom_note_does_not_redos_on_dotted_abbrev_run() {
let mut c = ctx("x");
let input = "Aus bus nomen ".to_string() + &"a.".repeat(30) + "#";
let start = std::time::Instant::now();
let out = strip_nom_note(&mut c, input.clone());
let elapsed = start.elapsed();
assert!(
elapsed.as_millis() < 200,
"strip_nom_note took {elapsed:?} on a dotted-abbrev run — possessive quantifier regressed"
);
assert_eq!(out, input);
assert_eq!(c.name.nomenclatural_note, None);
}
#[test]
fn trailing_not_given_is_stripped_and_flags_authorship_removed() {
let mut c = ctx("x");
let out = strip_authorship_placeholders(&mut c, "Aus bus Smith Not given".to_string());
assert_eq!(out, "Aus bus Smith");
assert!(c
.name
.warnings
.contains(&warnings::AUTHORSHIP_REMOVED.to_string()));
}
#[test]
fn not_applicable_is_case_insensitive() {
let mut c = ctx("x");
let out = strip_authorship_placeholders(&mut c, "Aus bus not applicable".to_string());
assert_eq!(out, "Aus bus");
assert!(c
.name
.warnings
.contains(&warnings::AUTHORSHIP_REMOVED.to_string()));
}
#[test]
fn no_placeholder_keyword_is_untouched() {
let mut c = ctx("x");
let out = strip_authorship_placeholders(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert!(c.name.warnings.is_empty());
}
#[test]
fn trailing_species_word_is_dropped() {
let mut c = ctx("x");
let out = strip_trailing_species_word(&mut c, "Abies species".to_string());
assert_eq!(out, "Abies");
}
#[test]
fn trailing_species_word_with_dot_is_dropped() {
let mut c = ctx("x");
let out = strip_trailing_species_word(&mut c, "Abies species.".to_string());
assert_eq!(out, "Abies");
}
#[test]
fn real_binomial_ending_in_an_epithet_is_not_mistaken_for_the_placeholder() {
let mut c = ctx("x");
let out = strip_trailing_species_word(&mut c, "Genus species alba".to_string());
assert_eq!(out, "Genus species alba");
}
#[test]
fn no_trailing_species_word_is_untouched() {
let mut c = ctx("x");
let out = strip_trailing_species_word(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
}
#[test]
fn trailing_pro_parte_is_stripped_and_flags_doubtful() {
let mut c = ctx("x");
let out = strip_pro_parte(&mut c, "Aus bus Smith, pro parte".to_string());
assert_eq!(out, "Aus bus Smith");
assert!(c.name.doubtful);
}
#[test]
fn abbreviated_p_p_form_is_also_stripped() {
let mut c = ctx("x");
let out = strip_pro_parte(&mut c, "Aus bus Smith, p.p.".to_string());
assert_eq!(out, "Aus bus Smith");
assert!(c.name.doubtful);
}
#[test]
fn no_pro_parte_marker_is_untouched() {
let mut c = ctx("x");
let out = strip_pro_parte(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert!(!c.name.doubtful);
}
#[test]
fn pro_sp_annotation_is_stripped_silently() {
let mut c = ctx("x");
let out = strip_pro_sp_annotation(&mut c, "Aus bus (pro sp.)".to_string());
assert_eq!(out, "Aus bus");
assert!(!c.name.doubtful);
assert!(c.name.warnings.is_empty());
}
#[test]
fn pro_hyb_variant_without_a_dot_is_also_stripped() {
let mut c = ctx("x");
let out = strip_pro_sp_annotation(&mut c, "Aus bus (pro hyb)".to_string());
assert_eq!(out, "Aus bus");
}
#[test]
fn no_pro_sp_annotation_is_untouched() {
let mut c = ctx("x");
let out = strip_pro_sp_annotation(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
}
#[test]
fn approved_lists_annotation_is_stripped_silently() {
let mut c = ctx("x");
let out = strip_approved_lists(&mut c, "Aus bus Smith (Approved Lists 1980)".to_string());
assert_eq!(out, "Aus bus Smith");
}
#[test]
fn no_approved_lists_annotation_is_untouched() {
let mut c = ctx("x");
let out = strip_approved_lists(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
}
#[test]
fn trailing_mihi_is_stripped_and_flags_authorship_removed() {
let mut c = ctx("x");
let out = strip_mihi(&mut c, "Aus bus mihi".to_string());
assert_eq!(out, "Aus bus");
assert!(c
.name
.warnings
.contains(&warnings::AUTHORSHIP_REMOVED.to_string()));
}
#[test]
fn mid_string_mihi_is_stripped_and_the_surrounding_text_splices_together() {
let mut c = ctx("x");
let out = strip_mihi(&mut c, "Aus bus mihi. Smith".to_string());
assert_eq!(out, "Aus bus Smith");
assert!(c
.name
.warnings
.contains(&warnings::AUTHORSHIP_REMOVED.to_string()));
}
#[test]
fn both_occurrences_of_mihi_are_stripped() {
let mut c = ctx("x");
let out = strip_mihi(&mut c, "Genus species mihi var. epithet mihi".to_string());
assert_eq!(out, "Genus species var. epithet");
}
#[test]
fn mihi_glued_to_a_preceding_word_is_not_a_false_positive() {
let mut c = ctx("x");
let out = strip_mihi(&mut c, "Aus mihilaris bus".to_string());
assert_eq!(out, "Aus mihilaris bus");
assert!(c.name.warnings.is_empty());
}
#[test]
fn leading_mihi_with_no_preceding_whitespace_is_not_stripped_by_this_step_in_isolation() {
let mut c = ctx("x");
let out = strip_mihi(&mut c, "mihi Aus bus".to_string());
assert_eq!(out, "mihi Aus bus");
assert!(c.name.warnings.is_empty());
}
#[test]
fn no_mihi_is_untouched() {
let mut c = ctx("x");
let out = strip_mihi(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert!(c.name.warnings.is_empty());
}
#[test]
fn title_case_anon_is_normalised_to_lower_case_with_a_dot() {
let mut c = ctx("x");
let out = normalise_anon(&mut c, "Aus bus Anon.".to_string());
assert_eq!(out, "Aus bus anon.");
}
#[test]
fn bare_lower_case_anon_is_also_normalised() {
let mut c = ctx("x");
let out = normalise_anon(&mut c, "Aus bus anon".to_string());
assert_eq!(out, "Aus bus anon.");
}
#[test]
fn already_normalised_anon_is_left_alone() {
let mut c = ctx("x");
let out = normalise_anon(&mut c, "Aus bus anon.".to_string());
assert_eq!(out, "Aus bus anon.");
}
#[test]
fn no_anon_keyword_is_untouched() {
let mut c = ctx("x");
let out = normalise_anon(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
}
#[test]
fn colon_concept_reference_appends_to_taxonomic_note() {
let mut c = ctx("x");
let out = strip_colon_concept_reference(
&mut c,
"Vespa emarginata Linnaeus, 1758: Fabricius, 1793".to_string(),
);
assert_eq!(out, "Vespa emarginata Linnaeus, 1758");
assert_eq!(c.name.taxonomic_note, Some("Fabricius, 1793".to_string()));
}
#[test]
fn colon_concept_reference_appends_to_an_existing_note() {
let mut c = ctx("x");
c.name.taxonomic_note = Some("existing".to_string());
let out = strip_colon_concept_reference(&mut c, "Aus bus: Fabricius, 1793".to_string());
assert_eq!(out, "Aus bus");
assert_eq!(
c.name.taxonomic_note,
Some("existing Fabricius, 1793".to_string())
);
}
#[test]
fn sanctioning_author_colon_form_without_a_year_is_not_a_concept_reference() {
let mut c = ctx("x");
let out = strip_colon_concept_reference(
&mut c,
"Vespa emarginata Linnaeus, 1758 : Fr.".to_string(),
);
assert_eq!(out, "Vespa emarginata Linnaeus, 1758 : Fr.");
assert_eq!(c.name.taxonomic_note, None);
}
#[test]
fn no_colon_is_untouched() {
let mut c = ctx("x");
let out = strip_colon_concept_reference(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert_eq!(c.name.taxonomic_note, None);
}
#[test]
fn normalise_leading_auct_lowercases_single_t_form() {
assert_eq!(normalise_leading_auct("Auct. europ."), "auct. europ.");
}
#[test]
fn normalise_leading_auct_lowercases_double_t_form() {
assert_eq!(normalise_leading_auct("Auctt. europ."), "auctt. europ.");
}
#[test]
fn normalise_leading_auct_leaves_all_caps_form_untouched() {
assert_eq!(normalise_leading_auct("AUCTT. europ."), "AUCTT. europ.");
}
#[test]
fn normalise_leading_auct_leaves_already_lower_case_form_untouched() {
assert_eq!(normalise_leading_auct("auctt. europ."), "auctt. europ.");
}
#[test]
fn bracketed_auctt_note_appends_to_taxonomic_note() {
let mut c = ctx("x");
let out = strip_bracketed_tax_note(
&mut c,
"Eunoa bus Smith [auctt. misspelling for Eunoe]".to_string(),
);
assert_eq!(out, "Eunoa bus Smith");
assert_eq!(
c.name.taxonomic_note,
Some("auctt. misspelling for Eunoe".to_string())
);
}
#[test]
fn bracketed_tax_note_lowercases_a_leading_title_case_auct() {
let mut c = ctx("x");
let out = strip_bracketed_tax_note(&mut c, "Aus bus [Auct. europ.]".to_string());
assert_eq!(out, "Aus bus");
assert_eq!(c.name.taxonomic_note, Some("auct. europ.".to_string()));
}
#[test]
fn bracketed_tax_note_collapses_internal_whitespace_runs() {
let mut c = ctx("x");
let out = strip_bracketed_tax_note(&mut c, "Aus bus [sensu Miller 1990]".to_string());
assert_eq!(out, "Aus bus");
assert_eq!(c.name.taxonomic_note, Some("sensu Miller 1990".to_string()));
}
#[test]
fn bracketed_tax_note_appends_to_an_existing_note() {
let mut c = ctx("x");
c.name.taxonomic_note = Some("existing".to_string());
let out = strip_bracketed_tax_note(&mut c, "Aus bus [non Foo]".to_string());
assert_eq!(out, "Aus bus");
assert_eq!(c.name.taxonomic_note, Some("existing non Foo".to_string()));
}
#[test]
fn no_bracketed_tax_note_is_untouched() {
let mut c = ctx("x");
let out = strip_bracketed_tax_note(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert_eq!(c.name.taxonomic_note, None);
}
#[test]
fn paren_non_homonym_citation_appends_to_taxonomic_note() {
let mut c = ctx("x");
let out = strip_paren_tax_note(&mut c, "Aus bus Smith (non Foo, 1850)".to_string());
assert_eq!(out, "Aus bus Smith");
assert_eq!(c.name.taxonomic_note, Some("non Foo, 1850".to_string()));
}
#[test]
fn paren_nec_and_not_variants_are_also_captured() {
let mut c = ctx("x");
let out = strip_paren_tax_note(&mut c, "Aus bus (nec Jones, 1900)".to_string());
assert_eq!(out, "Aus bus");
assert_eq!(c.name.taxonomic_note, Some("nec Jones, 1900".to_string()));
}
#[test]
fn paren_tax_note_appends_to_an_existing_note() {
let mut c = ctx("x");
c.name.taxonomic_note = Some("existing".to_string());
let out = strip_paren_tax_note(&mut c, "Aus bus (non Foo, 1850)".to_string());
assert_eq!(out, "Aus bus");
assert_eq!(
c.name.taxonomic_note,
Some("existing non Foo, 1850".to_string())
);
}
#[test]
fn no_paren_tax_note_is_untouched() {
let mut c = ctx("x");
let out = strip_paren_tax_note(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert_eq!(c.name.taxonomic_note, None);
}
#[test]
fn sensu_lato_marker_with_trailing_junk_appends_note_and_stashes_unparsed() {
let mut c = ctx("x");
let out = strip_sensu_lato_remainder(
&mut c,
"Asplenium trichomanes L. s.lat. - Asplen trich".to_string(),
);
assert_eq!(out, "Asplenium trichomanes L.");
assert_eq!(c.name.taxonomic_note, Some("s.lat.".to_string()));
assert_eq!(c.pending_unparsed, Some("- Asplen trich".to_string()));
}
#[test]
fn sensu_lato_remainder_appends_to_an_existing_note() {
let mut c = ctx("x");
c.name.taxonomic_note = Some("existing".to_string());
let out = strip_sensu_lato_remainder(&mut c, "Aus bus s.str. junk here".to_string());
assert_eq!(out, "Aus bus");
assert_eq!(c.name.taxonomic_note, Some("existing s.str.".to_string()));
}
#[test]
fn uppercase_author_initials_are_not_mistaken_for_a_sensu_lato_marker() {
let mut c = ctx("x");
let out = strip_sensu_lato_remainder(&mut c, "Aus bus Mill. S.L. Schultes".to_string());
assert_eq!(out, "Aus bus Mill. S.L. Schultes");
assert_eq!(c.name.taxonomic_note, None);
}
#[test]
fn bare_trailing_sensu_lato_with_no_junk_is_not_matched_here() {
let mut c = ctx("x");
let out = strip_sensu_lato_remainder(&mut c, "Aus bus s.l.".to_string());
assert_eq!(out, "Aus bus s.l.");
assert_eq!(c.name.taxonomic_note, None);
}
#[test]
fn trailing_ss_with_no_junk_appends_literal_note_and_stashes_nothing() {
let mut c = ctx("x");
let out = strip_sensu_stricto_ss(&mut c, "Aus bus s.s.".to_string());
assert_eq!(out, "Aus bus");
assert_eq!(c.name.taxonomic_note, Some("s.s.".to_string()));
assert_eq!(c.pending_unparsed, None);
}
#[test]
fn trailing_ss_with_junk_appends_note_and_stashes_the_trimmed_junk() {
let mut c = ctx("x");
let out = strip_sensu_stricto_ss(&mut c, "Aus bus s.s. extra text here".to_string());
assert_eq!(out, "Aus bus");
assert_eq!(c.name.taxonomic_note, Some("s.s.".to_string()));
assert_eq!(c.pending_unparsed, Some("extra text here".to_string()));
}
#[test]
fn sensu_stricto_ss_appends_to_an_existing_note() {
let mut c = ctx("x");
c.name.taxonomic_note = Some("existing".to_string());
let out = strip_sensu_stricto_ss(&mut c, "Aus bus s.s.".to_string());
assert_eq!(out, "Aus bus");
assert_eq!(c.name.taxonomic_note, Some("existing s.s.".to_string()));
}
#[test]
fn no_sensu_stricto_marker_is_untouched() {
let mut c = ctx("x");
let out = strip_sensu_stricto_ss(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert_eq!(c.name.taxonomic_note, None);
assert_eq!(c.pending_unparsed, None);
}
#[test]
fn emend_with_a_dot_overwrites_taxonomic_note() {
let mut c = ctx("x");
let out = strip_tax_note(
&mut c,
"Chlorobium phaeobacteroides Pfennig, 1968 emend. Imhoff, 2003".to_string(),
);
assert_eq!(out, "Chlorobium phaeobacteroides Pfennig, 1968");
assert_eq!(
c.name.taxonomic_note,
Some("emend. Imhoff, 2003".to_string())
);
}
#[test]
fn emend_without_a_dot_is_also_matched() {
let mut c = ctx("x");
let out = strip_tax_note(
&mut c,
"Chlorobium phaeobacteroides Pfennig, 1968 emend Imhoff, 2003".to_string(),
);
assert_eq!(out, "Chlorobium phaeobacteroides Pfennig, 1968");
assert_eq!(
c.name.taxonomic_note,
Some("emend Imhoff, 2003".to_string())
);
}
#[test]
fn fide_keyword_is_captured() {
let mut c = ctx("x");
let out = strip_tax_note(
&mut c,
"Eulima excellens Verkrüzen fide Paetel, 1887".to_string(),
);
assert_eq!(out, "Eulima excellens Verkrüzen");
assert_eq!(c.name.taxonomic_note, Some("fide Paetel, 1887".to_string()));
}
#[test]
fn nec_keyword_captures_a_trailing_parenthesised_citation() {
let mut c = ctx("x");
let out = strip_tax_note(
&mut c,
"Procamallanus (Spirocamallanus) soodi Lakshmi & Kumari, 2001 nec (Gupta & Masood, 1988)"
.to_string(),
);
assert_eq!(
out,
"Procamallanus (Spirocamallanus) soodi Lakshmi & Kumari, 2001"
);
assert_eq!(
c.name.taxonomic_note,
Some("nec (Gupta & Masood, 1988)".to_string())
);
}
#[test]
fn non_keyword_is_captured() {
let mut c = ctx("x");
let out = strip_tax_note(
&mut c,
"Membranipora minuscula Canu, 1911 non Hincks, 1882".to_string(),
);
assert_eq!(out, "Membranipora minuscula Canu, 1911");
assert_eq!(c.name.taxonomic_note, Some("non Hincks, 1882".to_string()));
}
#[test]
fn bare_trailing_auct_is_captured_and_lower_cased() {
let mut c = ctx("x");
let out = strip_tax_note(&mut c, "Aus bus auct.".to_string());
assert_eq!(out, "Aus bus");
assert_eq!(c.name.taxonomic_note, Some("auct.".to_string()));
}
#[test]
fn title_case_auct_and_auctt_are_lower_cased() {
let mut c = ctx("x");
let out = strip_tax_note(&mut c, "Aus bus Auct.".to_string());
assert_eq!(out, "Aus bus");
assert_eq!(c.name.taxonomic_note, Some("auct.".to_string()));
let mut c2 = ctx("x");
let out2 = strip_tax_note(&mut c2, "Aus bus Auctt.".to_string());
assert_eq!(out2, "Aus bus");
assert_eq!(c2.name.taxonomic_note, Some("auctt.".to_string()));
}
#[test]
fn lower_case_sensu_lato_marker_is_matched_case_sensitively() {
let mut c = ctx("x");
let out = strip_tax_note(&mut c, "Aus bus s.l.".to_string());
assert_eq!(out, "Aus bus");
assert_eq!(c.name.taxonomic_note, Some("s.l.".to_string()));
}
#[test]
fn uppercase_author_initials_do_not_match_the_sensu_lato_branch() {
let mut c = ctx("x");
let out = strip_tax_note(&mut c, "Aus bus Mill. S.L.".to_string());
assert_eq!(out, "Aus bus Mill. S.L.");
assert_eq!(c.name.taxonomic_note, None);
}
#[test]
fn initial_dot_space_collapses_a_bare_initial_before_a_lowercase_word() {
let mut c = ctx("x");
let out = strip_tax_note(&mut c, "Aus bus non F. europaeus".to_string());
assert_eq!(out, "Aus bus");
assert_eq!(c.name.taxonomic_note, Some("non F.europaeus".to_string()));
}
#[test]
fn initial_dot_space_does_not_collapse_before_a_capitalised_surname() {
let mut c = ctx("x");
let out = strip_tax_note(&mut c, "Aus bus sensu F. Schmidt".to_string());
assert_eq!(out, "Aus bus");
assert_eq!(c.name.taxonomic_note, Some("sensu F. Schmidt".to_string()));
}
#[test]
fn multi_letter_abbreviations_keep_their_space() {
let mut c = ctx("x");
let out = strip_tax_note(&mut c, "Aus bus ss. auct. europ.".to_string());
assert_eq!(out, "Aus bus");
assert_eq!(c.name.taxonomic_note, Some("ss. auct. europ.".to_string()));
}
#[test]
fn sec_according_to_and_excl_alternatives_are_all_matched() {
let mut c1 = ctx("x");
assert_eq!(
strip_tax_note(&mut c1, "Aus bus sec. Smith 1990".to_string()),
"Aus bus"
);
assert_eq!(c1.name.taxonomic_note, Some("sec. Smith 1990".to_string()));
let mut c2 = ctx("x");
assert_eq!(
strip_tax_note(&mut c2, "Aus bus according to Smith".to_string()),
"Aus bus"
);
assert_eq!(
c2.name.taxonomic_note,
Some("according to Smith".to_string())
);
let mut c3 = ctx("x");
assert_eq!(
strip_tax_note(&mut c3, "Aus bus excl. var. minor".to_string()),
"Aus bus"
);
assert_eq!(c3.name.taxonomic_note, Some("excl. var. minor".to_string()));
}
#[test]
fn prepends_to_an_existing_note() {
let mut c = ctx("x");
c.name.taxonomic_note = Some("existing".to_string());
let out = strip_tax_note(&mut c, "Aus bus sensu Miller".to_string());
assert_eq!(out, "Aus bus");
assert_eq!(
c.name.taxonomic_note,
Some("sensu Miller existing".to_string())
);
}
#[test]
fn multiple_dangling_commas_before_the_match_are_all_stripped() {
let mut c = ctx("x");
let out = strip_tax_note(&mut c, "Aus bus,, sensu Miller".to_string());
assert_eq!(out, "Aus bus");
assert_eq!(c.name.taxonomic_note, Some("sensu Miller".to_string()));
}
#[test]
fn captured_text_case_is_preserved_verbatim_except_for_the_auct_normalisation() {
let mut c = ctx("x");
let out = strip_tax_note(&mut c, "Aus bus SENSU Smith".to_string());
assert_eq!(out, "Aus bus");
assert_eq!(c.name.taxonomic_note, Some("SENSU Smith".to_string()));
}
#[test]
fn no_tax_note_keyword_is_untouched() {
let mut c = ctx("x");
let out = strip_tax_note(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert_eq!(c.name.taxonomic_note, None);
}
#[test]
fn agg_suffix_sets_aggregate_and_strips_the_marker() {
let mut c = ctx("x");
let out = strip_aggregate_suffix(&mut c, "Achillea millefolium agg.".to_string());
assert_eq!(out, "Achillea millefolium");
assert!(c.aggregate);
}
#[test]
fn species_group_suffix_is_also_recognised() {
let mut c = ctx("x");
let out = strip_aggregate_suffix(&mut c, "Achillea millefolium species group".to_string());
assert_eq!(out, "Achillea millefolium");
assert!(c.aggregate);
}
#[test]
fn hyphenated_group_suffix_is_also_recognised() {
let mut c = ctx("x");
let out = strip_aggregate_suffix(&mut c, "Achillea millefolium-group".to_string());
assert_eq!(out, "Achillea millefolium");
assert!(c.aggregate);
}
#[test]
fn no_aggregate_suffix_is_untouched() {
let mut c = ctx("x");
let out = strip_aggregate_suffix(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert!(!c.aggregate);
}
#[test]
fn published_page_colon_space_digits_is_stashed() {
let mut c = ctx("x");
let out = strip_published_page(
&mut c,
"Anolis marmoratus girafus LAZELL 1964: 377".to_string(),
);
assert_eq!(out, "Anolis marmoratus girafus LAZELL 1964");
assert_eq!(c.name.published_in_page, Some("377".to_string()));
}
#[test]
fn published_page_glued_colon_is_also_recognised() {
let mut c = ctx("x");
let out = strip_published_page(
&mut c,
"Recilia truncatus Dash & Viraktamath, 1998a:29".to_string(),
);
assert_eq!(out, "Recilia truncatus Dash & Viraktamath, 1998a");
assert_eq!(c.name.published_in_page, Some("29".to_string()));
}
#[test]
fn published_page_extra_spaced_colon_is_also_recognised() {
let mut c = ctx("x");
let out = strip_published_page(
&mut c,
"Recilia truncatus Dash & Viraktamath, 1998a : 29".to_string(),
);
assert_eq!(out, "Recilia truncatus Dash & Viraktamath, 1998a");
assert_eq!(c.name.published_in_page, Some("29".to_string()));
}
#[test]
fn published_page_range_with_en_dash_is_kept_verbatim() {
let mut c = ctx("x");
let out = strip_published_page(&mut c, "Foo bar Author, 1900: 12\u{2013}18".to_string());
assert_eq!(out, "Foo bar Author, 1900");
assert_eq!(c.name.published_in_page, Some("12\u{2013}18".to_string()));
}
#[test]
fn no_published_page_is_untouched() {
let mut c = ctx("x");
let out = strip_published_page(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert_eq!(c.name.published_in_page, None);
}
#[test]
fn documented_example_in_press_sets_manuscript_and_appends_nomenclatural_note() {
let mut c = ctx("x");
let out = strip_in_press(&mut c, "Abies alba Mill. in press".to_string());
assert_eq!(out, "Abies alba Mill.");
assert!(c.name.manuscript);
assert_eq!(c.name.nomenclatural_note, Some("in press".to_string()));
}
#[test]
fn in_press_is_case_insensitive_and_always_stashes_the_lowercase_literal() {
let mut c = ctx("x");
let out = strip_in_press(&mut c, "Abies alba Mill. In Press.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert!(c.name.manuscript);
assert_eq!(c.name.nomenclatural_note, Some("in press".to_string()));
}
#[test]
fn in_press_appends_to_an_existing_nomenclatural_note() {
let mut c = ctx("x");
c.name.nomenclatural_note = Some("nom. illeg.".to_string());
let out = strip_in_press(&mut c, "Abies alba Mill. in press".to_string());
assert_eq!(out, "Abies alba Mill.");
assert_eq!(
c.name.nomenclatural_note,
Some("nom. illeg. in press".to_string())
);
}
#[test]
fn no_in_press_marker_is_untouched() {
let mut c = ctx("x");
let out = strip_in_press(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert!(!c.name.manuscript);
assert_eq!(c.name.nomenclatural_note, None);
}
#[test]
fn in_author_in_parens_moves_the_publication_year_onto_a_yearless_basionym() {
let mut c = ctx("x");
let out = strip_in_author_in_parens(
&mut c,
"Hypsicera femoralis (Geoffroy in Fourcroy, 1785)".to_string(),
);
assert_eq!(out, "Hypsicera femoralis (Geoffroy, 1785)");
assert_eq!(c.name.published_in, Some("Fourcroy, 1785".to_string()));
assert_eq!(c.name.published_in_year, Some(1785));
}
#[test]
fn in_author_in_parens_apud_variant_is_also_recognised() {
let mut c = ctx("x");
let out =
strip_in_author_in_parens(&mut c, "Foo bar (Smith apud Jones, 1900) Mill.".to_string());
assert_eq!(out, "Foo bar (Smith, 1900) Mill.");
assert_eq!(c.name.published_in, Some("Jones, 1900".to_string()));
}
#[test]
fn in_author_in_parens_does_not_double_up_a_year_the_basionym_already_has() {
let mut c = ctx("x");
let out =
strip_in_author_in_parens(&mut c, "Foo bar (Smith, 1780 in Jones, 1900)".to_string());
assert_eq!(out, "Foo bar (Smith, 1780)");
assert_eq!(c.name.published_in, Some("Jones, 1900".to_string()));
}
#[test]
fn in_author_in_parens_appends_to_an_existing_published_in() {
let mut c = ctx("x");
c.name.set_published_in("Earlier ref, 1700");
let out = strip_in_author_in_parens(
&mut c,
"Hypsicera femoralis (Geoffroy in Fourcroy, 1785)".to_string(),
);
assert_eq!(out, "Hypsicera femoralis (Geoffroy, 1785)");
assert_eq!(
c.name.published_in,
Some("Earlier ref, 1700 Fourcroy, 1785".to_string())
);
assert_eq!(
c.name.published_in_year,
Some(1785),
"the year must be re-derived from the full COMBINED publishedIn string"
);
}
#[test]
fn plain_parenthesised_basionym_without_in_author_is_untouched() {
let mut c = ctx("x");
let out =
strip_in_author_in_parens(&mut c, "Hypsicera femoralis (Geoffroy, 1785)".to_string());
assert_eq!(out, "Hypsicera femoralis (Geoffroy, 1785)");
assert_eq!(c.name.published_in, None);
}
#[test]
fn documented_example_busk_in_chimonides_sets_published_in_and_year() {
let mut c = ctx("x");
let out = strip_in_author_citation(&mut c, "Busk in Chimonides, 1987".to_string());
assert_eq!(out, "Busk");
assert_eq!(c.name.published_in, Some("Chimonides, 1987".to_string()));
assert_eq!(c.name.published_in_year, Some(1987));
assert_eq!(c.pending_year, Some("1987".to_string()));
assert!(c.pending_year_from_publication);
}
#[test]
fn apud_variant_is_also_recognised() {
let mut c = ctx("x");
let out = strip_in_author_citation(&mut c, "Small apud Britton & Wilson".to_string());
assert_eq!(out, "Small");
assert_eq!(c.name.published_in, Some("Britton & Wilson".to_string()));
}
#[test]
fn trailing_sentence_period_after_closing_paren_is_dropped() {
let mut c = ctx("x");
let out =
strip_in_author_citation(&mut c, "Foo bar Author in Kirchner (1988).".to_string());
assert_eq!(out, "Foo bar Author");
assert_eq!(c.name.published_in, Some("Kirchner (1988)".to_string()));
}
#[test]
fn period_after_an_author_abbreviation_is_kept_not_dropped() {
let mut c = ctx("x");
let out = strip_in_author_citation(
&mut c,
"Papillaria fuscescens (Hook.) Jaeg. fo. gracilis Card. in Fleisch.".to_string(),
);
assert_eq!(
out,
"Papillaria fuscescens (Hook.) Jaeg. fo. gracilis Card."
);
assert_eq!(c.name.published_in, Some("Fleisch.".to_string()));
}
#[test]
fn paren_year_takes_precedence_for_pending_year_while_published_in_year_takes_the_last_match() {
let mut c = ctx("x");
let out = strip_in_author_citation(
&mut c,
"Foo bar Author in Kirchner (1988), 1990".to_string(),
);
assert_eq!(out, "Foo bar Author");
assert_eq!(
c.name.published_in,
Some("Kirchner (1988), 1990".to_string())
);
assert_eq!(c.name.published_in_year, Some(1990));
assert_eq!(
c.pending_year,
Some("1988".to_string()),
"the parenthesised year must win over the trailing bare year for pending_year"
);
}
#[test]
fn no_in_author_tail_is_untouched() {
let mut c = ctx("x");
let out = strip_in_author_citation(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert_eq!(c.name.published_in, None);
assert_eq!(c.pending_year, None);
}
#[test]
fn lowercase_word_after_in_is_not_mistaken_for_an_author() {
let mut c = ctx("x");
let out = strip_in_author_citation(&mut c, "Foo bar Smith in obscurity".to_string());
assert_eq!(out, "Foo bar Smith in obscurity");
assert_eq!(c.name.published_in, None);
}
#[test]
fn documented_ipni_example_sets_published_in_and_year() {
let mut c = ctx("x");
let out = strip_ipni_citation(
&mut c,
"Foo bar Kirchn., Annals and Magazine of Natural History (1988).".to_string(),
);
assert_eq!(out, "Foo bar Kirchn.");
assert_eq!(
c.name.published_in,
Some("Annals and Magazine of Natural History (1988)".to_string())
);
assert_eq!(c.name.published_in_year, Some(1988));
assert_eq!(c.pending_year, Some("1988".to_string()));
}
#[test]
fn embedded_nom_illeg_note_is_extracted_and_the_reference_is_resquished() {
let mut c = ctx("x");
let out = strip_ipni_citation(
&mut c,
"Foo bar Kirchn., Taxon nom. illeg. (1988).".to_string(),
);
assert_eq!(out, "Foo bar Kirchn.");
assert_eq!(c.name.nomenclatural_note, Some("nom. illeg.".to_string()));
assert_eq!(c.name.published_in, Some("Taxon (1988)".to_string()));
}
#[test]
fn embedded_pro_syn_note_with_in_obs_prefix_is_extracted() {
let mut c = ctx("x");
let out = strip_ipni_citation(
&mut c,
"Foo bar Kirchn., Taxon in obs., pro syn. (1988).".to_string(),
);
assert_eq!(out, "Foo bar Kirchn.");
assert_eq!(
c.name.nomenclatural_note,
Some("in obs., pro syn.".to_string())
);
assert_eq!(c.name.published_in, Some("Taxon (1988)".to_string()));
}
#[test]
fn embedded_comb_nov_note_is_extracted() {
let mut c = ctx("x");
let out = strip_ipni_citation(
&mut c,
"Foo bar Kirchn., Taxon comb. nov. (1988).".to_string(),
);
assert_eq!(out, "Foo bar Kirchn.");
assert_eq!(c.name.nomenclatural_note, Some("comb. nov.".to_string()));
assert_eq!(c.name.published_in, Some("Taxon (1988)".to_string()));
}
#[test]
fn ipni_appends_the_embedded_note_to_an_existing_nomenclatural_note() {
let mut c = ctx("x");
c.name.nomenclatural_note = Some("earlier note".to_string());
let out = strip_ipni_citation(
&mut c,
"Foo bar Kirchn., Taxon nom. illeg. (1988).".to_string(),
);
assert_eq!(out, "Foo bar Kirchn.");
assert_eq!(
c.name.nomenclatural_note,
Some("earlier note nom. illeg.".to_string())
);
}
#[test]
fn ipni_overwrites_rather_than_appends_an_existing_published_in() {
let mut c = ctx("x");
c.name.set_published_in("Stale ref, 1700");
let out = strip_ipni_citation(
&mut c,
"Foo bar Kirchn., Annals and Magazine of Natural History (1988).".to_string(),
);
assert_eq!(out, "Foo bar Kirchn.");
assert_eq!(
c.name.published_in,
Some("Annals and Magazine of Natural History (1988)".to_string()),
"stripIpniCitation calls the plain setPublishedIn — it must OVERWRITE, not append"
);
}
#[test]
fn no_ipni_citation_is_untouched() {
let mut c = ctx("x");
let out = strip_ipni_citation(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert_eq!(c.name.published_in, None);
}
#[test]
fn clean_year_reference_overwrites_published_in_and_propagates_the_year() {
let mut c = ctx("x");
let out = strip_period_separated_reference(
&mut c,
"Foo bar Smith. Annals of Botany 1988".to_string(),
);
assert_eq!(out, "Foo bar Smith");
assert_eq!(
c.name.published_in,
Some("Annals of Botany 1988".to_string())
);
assert_eq!(c.name.published_in_year, Some(1988));
assert_eq!(c.pending_year, Some("1988".to_string()));
assert!(!c
.name
.warnings
.contains(&warnings::NOMENCLATURAL_REFERENCE.to_string()));
}
#[test]
fn page_range_reference_flags_nomenclatural_reference_and_does_not_propagate_the_year() {
let mut c = ctx("x");
let out = strip_period_separated_reference(
&mut c,
"Foo bar Smith. Annals of Zootaxa 1658-1662, 1988".to_string(),
);
assert_eq!(out, "Foo bar Smith");
assert_eq!(
c.name.published_in,
Some("Annals of Zootaxa 1658-1662, 1988".to_string())
);
assert_eq!(c.name.published_in_year, Some(1988));
assert!(c
.name
.warnings
.contains(&warnings::NOMENCLATURAL_REFERENCE.to_string()));
assert_eq!(
c.pending_year, None,
"a page-range reference must NOT propagate a pending year"
);
}
#[test]
fn author_particle_list_is_not_mistaken_for_a_reference() {
let mut c = ctx("x");
let out = strip_period_separated_reference(
&mut c,
"Foo bar Yin, Z.W. de Beer & Wingf. Mycologia 2004".to_string(),
);
assert_eq!(out, "Foo bar Yin, Z.W. de Beer & Wingf. Mycologia 2004");
assert_eq!(c.name.published_in, None);
}
#[test]
fn no_period_separated_reference_is_untouched() {
let mut c = ctx("x");
let out = strip_period_separated_reference(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert_eq!(c.name.published_in, None);
}
#[test]
fn period_separated_reference_stays_linear_on_a_long_connector_free_run() {
let mut c = ctx("x");
let mut input = "Foo bar Smith.".to_string();
for i in 0..60 {
input.push_str(&format!(" Wordxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx{i}"));
}
let start = std::time::Instant::now();
let out = strip_period_separated_reference(&mut c, input.clone());
let elapsed = start.elapsed();
assert!(
elapsed.as_millis() < 500,
"strip_period_separated_reference took {elapsed:?} on a connector-free run"
);
assert_eq!(out, input);
assert_eq!(c.name.published_in, None);
}
#[test]
fn documented_comma_prefixed_reference_overwrites_published_in_and_flags_the_warning() {
let mut c = ctx("x");
let out = strip_comma_prefixed_reference(
&mut c,
"Foo bar Smith, Journal of Botany 1988".to_string(),
);
assert_eq!(out, "Foo bar Smith");
assert_eq!(
c.name.published_in,
Some("Journal of Botany 1988".to_string())
);
assert!(c
.name
.warnings
.contains(&warnings::NOMENCLATURAL_REFERENCE.to_string()));
}
#[test]
fn comma_prefixed_reference_does_not_propagate_a_pending_year() {
let mut c = ctx("x");
strip_comma_prefixed_reference(&mut c, "Foo bar Smith, Journal of Botany 1988".to_string());
assert_eq!(
c.pending_year, None,
"a comma-prefixed reference's year must never be propagated onto the authorship"
);
}
#[test]
fn comma_prefixed_reference_overwrites_rather_than_appends_an_existing_published_in() {
let mut c = ctx("x");
c.name.set_published_in("Stale ref, 1700");
let out = strip_comma_prefixed_reference(
&mut c,
"Foo bar Miller & Jones, Annals and Magazine of Natural History (1988)".to_string(),
);
assert_eq!(out, "Foo bar Miller & Jones");
assert_eq!(
c.name.published_in,
Some("Annals and Magazine of Natural History (1988)".to_string())
);
}
#[test]
fn author_particle_list_is_not_mistaken_for_a_comma_prefixed_reference_either() {
let mut c = ctx("x");
let out = strip_comma_prefixed_reference(
&mut c,
"Foo bar Yin, Z.W. de Beer & Wingf. Mycologia 2004".to_string(),
);
assert_eq!(out, "Foo bar Yin, Z.W. de Beer & Wingf. Mycologia 2004");
assert_eq!(c.name.published_in, None);
}
#[test]
fn no_comma_prefixed_reference_is_untouched() {
let mut c = ctx("x");
let out = strip_comma_prefixed_reference(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert_eq!(c.name.published_in, None);
assert!(c.name.warnings.is_empty());
}
#[test]
fn comma_prefixed_reference_does_not_redos_on_a_long_connector_free_run() {
let mut c = ctx("x");
let mut input = "Foo bar Smith,".to_string();
for i in 0..300 {
input.push_str(&format!(" Wordxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx{i}"));
}
let start = std::time::Instant::now();
let out = strip_comma_prefixed_reference(&mut c, input.clone());
let elapsed = start.elapsed();
assert!(
elapsed.as_millis() < 200,
"strip_comma_prefixed_reference took {elapsed:?} on a connector-free run"
);
assert_eq!(out, input);
}
#[test]
fn trailing_ms_marker_sets_manuscript_and_appends_the_lowercased_tag() {
let mut c = ctx("x");
let out = strip_manuscript_marker(&mut c, "Acacia bicolor Bojer ms.".to_string());
assert_eq!(out, "Acacia bicolor Bojer");
assert!(c.name.manuscript);
assert_eq!(c.name.nomenclatural_note, Some("ms.".to_string()));
}
#[test]
fn ined_marker_with_leading_comma_is_also_recognised() {
let mut c = ctx("x");
let out = strip_manuscript_marker(&mut c, "Foo bar Author, ined.".to_string());
assert_eq!(out, "Foo bar Author");
assert!(c.name.manuscript);
assert_eq!(c.name.nomenclatural_note, Some("ined.".to_string()));
}
#[test]
fn unpublished_and_msc_markers_are_also_recognised() {
let mut c1 = ctx("x");
let out1 = strip_manuscript_marker(&mut c1, "Foo bar Author unpublished".to_string());
assert_eq!(out1, "Foo bar Author");
assert_eq!(c1.name.nomenclatural_note, Some("unpublished".to_string()));
let mut c2 = ctx("x");
let out2 = strip_manuscript_marker(&mut c2, "Foo bar Author msc".to_string());
assert_eq!(out2, "Foo bar Author");
assert_eq!(c2.name.nomenclatural_note, Some("msc".to_string()));
}
#[test]
fn marker_case_is_lowercased_in_the_stashed_tag() {
let mut c = ctx("x");
let out = strip_manuscript_marker(&mut c, "Foo bar Author MS.".to_string());
assert_eq!(out, "Foo bar Author");
assert_eq!(c.name.nomenclatural_note, Some("ms.".to_string()));
}
#[test]
fn manuscript_marker_appends_to_an_existing_nomenclatural_note() {
let mut c = ctx("x");
c.name.nomenclatural_note = Some("earlier note".to_string());
let out = strip_manuscript_marker(&mut c, "Foo bar Author ms.".to_string());
assert_eq!(out, "Foo bar Author");
assert_eq!(
c.name.nomenclatural_note,
Some("earlier note ms.".to_string())
);
}
#[test]
fn manuscript_marker_after_in_author_strip_still_matches() {
let mut c = ctx("x");
let out = strip_manuscript_marker(&mut c, "Busk ms".to_string());
assert_eq!(out, "Busk");
assert!(c.name.manuscript);
assert_eq!(c.name.nomenclatural_note, Some("ms".to_string()));
}
#[test]
fn no_manuscript_marker_is_untouched() {
let mut c = ctx("x");
let out = strip_manuscript_marker(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert!(!c.name.manuscript);
assert_eq!(c.name.nomenclatural_note, None);
}
#[test]
fn full_run_strips_both_in_author_citation_and_manuscript_marker_in_order() {
let mut c = ctx("Aus bus Busk ms in Chimonides, 1987");
run(&mut c);
assert_eq!(c.working, "Aus bus Busk");
assert!(c.name.manuscript);
assert_eq!(c.name.nomenclatural_note, Some("ms".to_string()));
assert_eq!(c.name.published_in, Some("Chimonides, 1987".to_string()));
assert_eq!(c.name.published_in_year, Some(1987));
}
#[test]
fn bare_suprageneric_marker_pins_rank_and_strips_the_marker() {
let mut c = ctx("x");
let out = strip_supra_rank_prefix(&mut c, "subtrib. Scolochloinae Soreng".to_string());
assert_eq!(out, "Scolochloinae Soreng");
assert_eq!(c.name.rank, Rank::Subtribe);
}
#[test]
fn family_prefixed_suprageneric_marker_strips_both_family_and_marker() {
let mut c = ctx("x");
let out =
strip_supra_rank_prefix(&mut c, "Poaceae subtrib. Scolochloinae Soreng".to_string());
assert_eq!(out, "Scolochloinae Soreng");
assert_eq!(c.name.rank, Rank::Subtribe);
}
#[test]
fn tribe_and_subfamily_markers_are_also_recognised() {
let mut c1 = ctx("x");
let out1 = strip_supra_rank_prefix(&mut c1, "trib. Triticeae Dumort.".to_string());
assert_eq!(out1, "Triticeae Dumort.");
assert_eq!(c1.name.rank, Rank::Tribe);
let mut c2 = ctx("x");
let out2 = strip_supra_rank_prefix(&mut c2, "subfam. Pooideae".to_string());
assert_eq!(out2, "Pooideae");
assert_eq!(c2.name.rank, Rank::Subfamily);
}
#[test]
fn no_supra_rank_prefix_is_untouched() {
let mut c = ctx("x");
let out = strip_supra_rank_prefix(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert_eq!(c.name.rank, Rank::Unranked);
}
#[test]
fn leading_infragen_marker_pins_rank_and_strips_the_marker() {
let mut c = ctx("x");
let out =
strip_leading_infrageneric_marker(&mut c, "subgen. Trematostoma Sacc.".to_string());
assert_eq!(out, "Trematostoma Sacc.");
assert_eq!(c.name.rank, Rank::Subgenus);
assert_eq!(c.name.code, None);
}
#[test]
fn leading_infragen_marker_backfills_unset_code_from_the_ranks_own_code() {
let mut c = ctx("x");
let out = strip_leading_infrageneric_marker(&mut c, "sect. Foo Bar".to_string());
assert_eq!(out, "Foo Bar");
assert_eq!(c.name.rank, Rank::SectionBotany);
assert_eq!(c.name.code, Some(NomCode::Botanical));
}
#[test]
fn leading_infragen_marker_no_trailing_dot_form_is_also_recognised() {
let mut c = ctx("x");
let out = strip_leading_infrageneric_marker(&mut c, "series Foo Bar".to_string());
assert_eq!(out, "Foo Bar");
assert_eq!(c.name.rank, Rank::SeriesBotany);
assert_eq!(c.name.code, Some(NomCode::Botanical));
}
#[test]
fn leading_infragen_marker_remaps_to_zoological_counterpart_under_zoological_code() {
let mut c = ParseContext::new("x".to_string(), None, None, Some(NomCode::Zoological));
let out = strip_leading_infrageneric_marker(&mut c, "sect. Taeda".to_string());
assert_eq!(out, "Taeda");
assert_eq!(c.name.rank, Rank::SectionZoology);
assert_eq!(c.name.code, Some(NomCode::Zoological));
}
#[test]
fn leading_infragen_marker_subgenus_has_no_zoological_counterpart_to_remap_to() {
let mut c = ParseContext::new("x".to_string(), None, None, Some(NomCode::Zoological));
let out =
strip_leading_infrageneric_marker(&mut c, "subgen. Trematostoma Sacc.".to_string());
assert_eq!(out, "Trematostoma Sacc.");
assert_eq!(c.name.rank, Rank::Subgenus);
}
#[test]
fn leading_infragen_marker_does_not_overwrite_an_already_set_code() {
let mut c = ctx("x");
c.name.code = Some(NomCode::Bacterial);
let out = strip_leading_infrageneric_marker(&mut c, "sect. Foo Bar".to_string());
assert_eq!(out, "Foo Bar");
assert_eq!(c.name.rank, Rank::SectionBotany, "rank is still pinned");
assert_eq!(
c.name.code,
Some(NomCode::Bacterial),
"a pre-existing code must not be overwritten"
);
}
#[test]
fn no_leading_infragen_marker_is_untouched() {
let mut c = ctx("x");
let out = strip_leading_infrageneric_marker(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert_eq!(c.name.rank, Rank::Unranked);
assert_eq!(c.name.code, None);
}
#[test]
fn phrase_name_bare_genus_with_species_marker_sets_phrase_but_leaves_rank_untouched() {
let mut c = ctx("x");
let out = stash_phrase_name(
&mut c,
"Prostanthera sp. Somersbey (B.J.Conn 4024)".to_string(),
);
assert_eq!(out, "Prostanthera sp.");
assert_eq!(
c.name.phrase,
Some("sp. Somersbey (B.J.Conn 4024)".to_string())
);
assert_eq!(
c.name.rank,
Rank::Unranked,
"bare genus + \"sp.\" marker must NOT pin rank directly in this step"
);
}
#[test]
fn phrase_name_bare_genus_with_non_species_marker_pins_rank_and_drops_the_marker() {
let mut c = ctx("x");
let out = stash_phrase_name(&mut c, "Grevillea subsp. 'Short Leaf'".to_string());
assert_eq!(out, "Grevillea");
assert_eq!(c.name.rank, Rank::Subspecies);
assert_eq!(c.name.phrase, Some("'Short Leaf'".to_string()));
}
#[test]
fn phrase_name_digit_leading_quoted_phrase_is_also_recognised() {
let mut c = ctx("x");
let out = stash_phrase_name(&mut c, "Baeckea ssp. 2 (LJM 2019)".to_string());
assert_eq!(out, "Baeckea");
assert_eq!(c.name.rank, Rank::Subspecies);
assert_eq!(c.name.phrase, Some("2 (LJM 2019)".to_string()));
}
#[test]
fn phrase_name_genus_plus_subgenus_extracts_infrageneric_epithet() {
let mut c = ctx("x");
let out = stash_phrase_name(
&mut c,
"Acacia (Botrycephalae) sp. Bygalorie (P.G.Wilson 2585)".to_string(),
);
assert_eq!(out, "Acacia");
assert_eq!(c.name.rank, Rank::Species);
assert_eq!(
c.name.infrageneric_epithet,
Some("Botrycephalae".to_string())
);
assert_eq!(
c.name.phrase,
Some("Bygalorie (P.G.Wilson 2585)".to_string())
);
}
#[test]
fn phrase_name_trailing_author_splices_the_marker_before_the_author() {
let mut c = ctx("x");
let out = stash_phrase_name(&mut c, "Baeckea Benth. sp. Bygalorie (ABC 123)".to_string());
assert_eq!(out, "Baeckea sp. Benth.");
assert_eq!(c.name.phrase, Some("Bygalorie (ABC 123)".to_string()));
assert_eq!(c.name.rank, Rank::Unranked);
}
#[test]
fn phrase_name_double_quoted_phrase_without_parens_is_also_recognised() {
let mut c = ctx("x");
let out = stash_phrase_name(&mut c, "Prostanthera sp. \"Big Leaf\"".to_string());
assert_eq!(out, "Prostanthera sp.");
assert_eq!(c.name.phrase, Some("sp. \"Big Leaf\"".to_string()));
}
#[test]
fn phrase_without_parens_or_quotes_is_not_recognised_as_a_phrase_name() {
let mut c = ctx("x");
let out = stash_phrase_name(&mut c, "Baeckea sp. P.G.Wilson 2585 F.Muell.".to_string());
assert_eq!(out, "Baeckea sp. P.G.Wilson 2585 F.Muell.");
assert_eq!(c.name.phrase, None);
}
#[test]
fn no_phrase_name_shape_is_untouched() {
let mut c = ctx("x");
let out = stash_phrase_name(&mut c, "Abies alba Mill.".to_string());
assert_eq!(out, "Abies alba Mill.");
assert_eq!(c.name.phrase, None);
assert_eq!(c.name.rank, Rank::Unranked);
}
#[test]
fn full_run_strips_a_leading_infrageneric_marker_and_backfills_the_code() {
let mut c = ctx("sect. Taeda");
run(&mut c);
assert_eq!(c.working, "Taeda");
assert_eq!(c.name.rank, Rank::SectionBotany);
assert_eq!(c.name.code, Some(NomCode::Botanical));
}
#[test]
fn full_run_stashes_a_phrase_name() {
let mut c = ctx("Prostanthera sp. Somersbey (B.J.Conn 4024)");
run(&mut c);
assert_eq!(c.working, "Prostanthera sp.");
assert_eq!(
c.name.phrase,
Some("sp. Somersbey (B.J.Conn 4024)".to_string())
);
}
fn name() -> ParsedName {
ParsedName::default()
}
#[test]
fn standalone_manuscript_marker_sets_manuscript_and_returns_empty() {
let mut n = name();
let out = strip_authorship_markers("ined.", &mut n);
assert_eq!(out, "");
assert!(n.manuscript);
}
#[test]
fn standalone_manuscript_marker_matches_case_insensitively_without_the_dot() {
let mut n = name();
let out = strip_authorship_markers("MS", &mut n);
assert_eq!(out, "");
assert!(n.manuscript);
}
#[test]
fn blank_authorship_returns_empty_without_touching_name() {
let mut n = name();
let out = strip_authorship_markers(" ", &mut n);
assert_eq!(out, "");
assert_eq!(n, ParsedName::default());
}
#[test]
fn sic_with_comment_strips_and_flags_original_spelling_true() {
let mut n = name();
let out = strip_authorship_markers("L. (sic, misspelling)", &mut n);
assert_eq!(out, "L.");
assert_eq!(n.original_spelling, Some(true));
}
#[test]
fn plain_sic_flags_original_spelling_true() {
let mut n = name();
let out = strip_authorship_markers("L. (sic)", &mut n);
assert_eq!(out, "L.");
assert_eq!(n.original_spelling, Some(true));
}
#[test]
fn corrig_flags_original_spelling_false() {
let mut n = name();
let out = strip_authorship_markers("L. corrig.", &mut n);
assert_eq!(out, "L.");
assert_eq!(n.original_spelling, Some(false));
}
#[test]
fn question_mark_transcription_artefact_glues_and_flags_doubtful() {
let mut n = name();
let out = strip_authorship_markers("Istv?nffi", &mut n);
assert_eq!(out, "Istvnffi");
assert!(n.doubtful);
assert!(n
.warnings
.contains(&warnings::QUESTION_MARKS_REMOVED.to_string()));
}
#[test]
fn win1252_artefact_is_repaired_with_a_homoglyphs_warning() {
let mut n = name();
let out = strip_authorship_markers("Plesn\u{00A1}k", &mut n);
assert_eq!(out, "Plesnik");
assert!(n.warnings.contains(&warnings::HOMOGLYHPS.to_string()));
}
#[test]
fn hort_ex_placeholder_is_lowercased() {
let mut n = name();
let out = strip_authorship_markers("Hort. ex Voss", &mut n);
assert_eq!(out, "hort. ex Voss");
}
#[test]
fn hortus_ex_placeholder_is_lowercased() {
let mut n = name();
let out = strip_authorship_markers("hortus ex Someone", &mut n);
assert_eq!(out, "hort. ex Someone");
}
#[test]
fn cv_ex_is_deliberately_left_untouched() {
let mut n = name();
let out = strip_authorship_markers("cv. ex Someone", &mut n);
assert_eq!(out, "cv. ex Someone");
}
#[test]
fn a_parenthesised_homonym_citation_is_the_whole_note() {
let mut n = name();
let out = strip_authorship_markers("(non Smith, 1900)", &mut n);
assert_eq!(out, "");
assert_eq!(n.taxonomic_note, Some("non Smith, 1900".to_string()));
}
#[test]
fn paren_note_splits_off_a_leading_note_and_keeps_the_trailing_author() {
let mut n = name();
let out = strip_authorship_markers("(auct.) Rolfe", &mut n);
assert_eq!(out, "Rolfe");
assert_eq!(n.taxonomic_note, Some("auct.".to_string()));
}
#[test]
fn paren_note_keeps_a_leading_author_case_intact() {
let mut n = name();
let out = strip_authorship_markers("(sensu X, 1878) Y, 1992", &mut n);
assert_eq!(out, "Y, 1992");
assert_eq!(n.taxonomic_note, Some("sensu X, 1878".to_string()));
}
#[test]
fn bracketed_nom_note_is_extracted_and_stripped() {
let mut n = name();
let out = strip_authorship_markers("L. (nom. cons.)", &mut n);
assert_eq!(out, "L.");
assert_eq!(n.nomenclatural_note, Some("nom. cons.".to_string()));
}
#[test]
fn bare_nom_note_is_extracted_and_stripped() {
let mut n = name();
let out = strip_authorship_markers("L. nom. illeg.", &mut n);
assert_eq!(out, "L.");
assert_eq!(n.nomenclatural_note, Some("nom. illeg.".to_string()));
}
#[test]
fn bare_nom_note_anchored_at_the_very_start_is_still_caught() {
let mut n = name();
let out = strip_authorship_markers("nom. illeg.", &mut n);
assert_eq!(out, "");
assert_eq!(n.nomenclatural_note, Some("nom. illeg.".to_string()));
}
#[test]
fn bare_nom_note_with_ined_keyword_flags_manuscript() {
let mut n = name();
let out = strip_authorship_markers("L. sp. nov. ined.", &mut n);
assert_eq!(out, "L.");
assert!(n.manuscript);
}
#[test]
fn tax_note_sensu_is_extracted_and_stripped() {
let mut n = name();
let out = strip_authorship_markers("L. sensu Smith", &mut n);
assert_eq!(out, "L.");
assert_eq!(n.taxonomic_note, Some("sensu Smith".to_string()));
}
#[test]
fn tax_note_initial_dot_space_is_collapsed() {
let mut n = name();
let out = strip_authorship_markers("L. non F. europaeus", &mut n);
assert_eq!(out, "L.");
assert_eq!(n.taxonomic_note, Some("non F.europaeus".to_string()));
}
#[test]
fn tax_note_leading_auct_title_case_is_lowercased() {
let mut n = name();
let out = strip_authorship_markers("L. Auct.", &mut n);
assert_eq!(out, "L.");
assert_eq!(n.taxonomic_note, Some("auct.".to_string()));
}
#[test]
fn tax_note_dedups_against_an_identical_existing_note() {
let mut n = name();
n.taxonomic_note = Some("sensu Smith".to_string());
let out = strip_authorship_markers("L. sensu Smith", &mut n);
assert_eq!(out, "L.");
assert_eq!(n.taxonomic_note, Some("sensu Smith".to_string()));
}
#[test]
fn tax_note_appends_a_distinct_existing_note() {
let mut n = name();
n.taxonomic_note = Some("auct.".to_string());
let out = strip_authorship_markers("L. sensu Smith", &mut n);
assert_eq!(out, "L.");
assert_eq!(n.taxonomic_note, Some("auct. sensu Smith".to_string()));
}
#[test]
fn plain_authorship_with_no_markers_is_returned_verbatim() {
let mut n = name();
let out = strip_authorship_markers("Mill.", &mut n);
assert_eq!(out, "Mill.");
assert_eq!(n, ParsedName::default());
}
}