use std::sync::LazyLock;
use fancy_regex::Regex as FancyRegex;
use regex::Regex;
use crate::model::{warnings, NameType, NomCode, ParsedName, Rank};
use crate::pipeline::ParseContext;
use crate::token;
use crate::unicode::java_trim;
pub(crate) fn run(ctx: &mut ParseContext) {
let mut s = ctx.working.clone();
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_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_trailing_strain_code(ctx, s);
s = stash_trailing_culture_accession(ctx, s);
s = strip_imprint_years(ctx, s);
s = strip_null_between_epithets(ctx, s);
s = normalise_hyphens(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 = 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_bracketed_nom_note(ctx, s);
s = strip_nom_note(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_in_parens(ctx, s);
s = strip_in_author_citation(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) -> 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"^(\p{Lu}[\p{Ll}]+)\s+((?:\(\s*[^()]*\)\s*)?\p{Lu}[\p{L}.'\-]*(?:\s+\p{Lu}[\p{L}.'\-]*)*)\s+((?:subg|subgen|subgenus|sect|subsect|supersect|ser|subser|superser|divisio|div)\.?\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 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 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());
fn repair_question_mark_in_word(ctx: &mut ParseContext, s: String) -> String {
if s.contains('?') && LETTER_QMARK_LETTER.is_match(&s) {
let s = QMARK_BETWEEN_LETTERS.replace_all(&s, "$1$2").into_owned();
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) {
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+[\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());
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("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()
}
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);
}
s
}
fn replace_homoglyphs(ctx: &mut ParseContext, s: String) -> String {
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
}
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 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());
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 = s
.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(r#"\s+(?:cv\.?\s+)?(['"])([^'"]+)\1(\s+[\p{Lu}].*)$"#).unwrap()
});
static AUTHOR_START: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"^([\p{Lu}][\p{Ll}]+(?:\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());
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 epithet = java_trim(caps.get(2).unwrap().as_str()).to_string();
let tail = caps.get(3).unwrap().as_str().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 BRACKETED_NOM_NOTE: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(
r"(?i)(?-u:\s*)[\[\(](?-u:\s*)((?:nom|comb|orth|typ)(?-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();
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: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"|(?: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 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();
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) && 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(r"(?i)(?-u:\s+Not\s+(?:applicable|given|known|recorded|found)\s*)$").unwrap()
});
fn strip_authorship_placeholders(ctx: &mut ParseContext, s: String) -> String {
if let Some(m) = AUTHORSHIP_PLACEHOLDER.find(&s) {
ctx.name.add_warning(warnings::AUTHORSHIP_REMOVED);
return java_trim(&s[..m.start()]).to_string();
}
s
}
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*(?:pro\s+parte|p\.\s*p\.[A-Z]?)\s*)$").unwrap());
fn strip_pro_parte(ctx: &mut ParseContext, s: String) -> String {
if let Some(m) = PRO_PARTE.find(&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*)$").unwrap()
});
fn strip_approved_lists(_ctx: &mut ParseContext, s: String) -> String {
if let Some(m) = APPROVED_LISTS.find(&s) {
return java_trim(&s[..m.start()]).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 {
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());
fn strip_colon_concept_reference(ctx: &mut ParseContext, s: String) -> String {
if let Some(caps) = COLON_CONCEPT_REFERENCE.captures(&s) {
let note = java_trim(caps.get(1).unwrap().as_str()).to_string();
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?|sensu|sec|non|nec|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_TAX_NOTE: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"(?i)(?-u:\s*)\((?-u:\s*)((?:nec|non|not)(?-u:\s+)[^)]+)\)(?-u:\s*)\.?(?-u:\s*)$")
.unwrap()
});
fn strip_paren_tax_note(ctx: &mut ParseContext, s: String) -> String {
if let Some(caps) = PAREN_TAX_NOTE.captures(&s) {
let note = java_trim(caps.get(1).unwrap().as_str()).to_string();
ctx.name.add_taxonomic_note(¬e);
let whole = caps.get(0).unwrap();
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);
ctx.set_pending_unparsed(&remainder);
let whole = caps.get(0).unwrap();
return java_trim(&s[..whole.start()]).to_string();
}
s
}
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"|sensu(?:(?-u:\s).*)?",
r"|sec\.?(?:(?-u:\s).*)?",
r"|nec(?-u:\b)(?:(?-u:\s).*)?",
r"|nonn?\.?(?-u:\s+)\(?\p{Lu}.*",
r"|emend(?-u:\b)\.?(?-u:\s+)\(?\p{Lu}.*",
r"|fide(?-u:\b)\.?(?-u:\s+)\(?\p{Lu}.*",
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")$",
))
.unwrap()
});
static INITIAL_DOT_SPACE: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?-u:\b)(\p{Lu})\.(?-u:\s+)([\p{Ll}][\p{Ll}]{3,})").unwrap());
fn strip_tax_note(ctx: &mut ParseContext, s: String) -> String {
let caps = match TAX_NOTE.captures(&s) {
Some(c) => c,
None => return s,
};
let raw = java_trim(caps.get(1).unwrap().as_str()).to_string();
if raw.is_empty() {
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(norm);
let match_start = caps.get(0).unwrap().start();
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
}
static IN_AUTHOR_IN_PARENS: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"\(([^()]*?)\s+(?:in|apud)\s+(\p{Lu}[^()]*?)\)").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|apud)(?-u:\s+)(\p{Lu}[^\t\n\x0B\f\r ].*)$").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 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 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()
});
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();
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(r"(?i)(?-u:\s*,?\s+(ined\.?|ms\.?|msc\.?|unpublished)\s*)$").unwrap()
});
fn strip_manuscript_marker(ctx: &mut ParseContext, s: String) -> String {
if let Some(caps) = MANUSCRIPT_MARKER.captures(&s) {
let whole = caps.get(0).unwrap();
let tag = caps[1].to_lowercase();
ctx.name.manuscript = true;
ctx.name.add_nomenclatural_note(&tag);
return java_trim(&s[..whole.start()]).to_string();
}
s
}
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(r"(?i)^(?:ined|ms|msc|unpublished)\.?$").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?|sensu|sec)(?-u:\b)[^)]*)\)(?-u:\s*)").unwrap()
});
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) {
name.manuscript = true;
return String::new();
}
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);
}
}
if s.contains('?') && LETTER_QMARK_LETTER.is_match(&s) {
s = QMARK_BETWEEN_LETTERS.replace_all(&s, "$1$2").into_owned();
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());
if LEADING_HOMONYM_PAREN.is_match(&s) {
let norm = collapse_whitespace(&s);
name.add_taxonomic_note(&norm);
return String::new();
}
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();
let norm = normalise_leading_auct(&norm);
name.add_taxonomic_note(&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) = BRACKETED_NOM_NOTE.captures(&s) {
let raw = java_trim(caps.get(1).unwrap().as_str()).to_string();
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;
}
}
}
let padded_tax = format!(" {s}");
if let Some(caps) = TAX_NOTE.captures(&padded_tax) {
let raw = java_trim(caps.get(1).unwrap().as_str()).to_string();
if !raw.is_empty() {
let with_dots = INITIAL_DOT_SPACE.replace_all(&raw, "$1.$2");
let norm = normalise_leading_auct(&with_dots);
name.taxonomic_note = Some(match name.taxonomic_note.take() {
None => norm.clone(),
Some(existing) if existing == norm => existing,
Some(existing) => format!("{existing} {norm}"),
});
let group1_start = caps.get(1).unwrap().start();
s = java_trim(&padded_tax[..group1_start]).to_string();
while s.ends_with(',') {
s.pop();
s = java_trim(&s).to_string();
}
}
}
java_trim(&s).to_string()
}
#[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 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 overwrites_rather_than_appends_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".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 leading_homonym_paren_captures_the_whole_string_as_taxonomic_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());
}
}