use std::sync::LazyLock;
use regex::Regex;
use crate::model::{rank_utils, warnings, Authorship, NameType, NomCode, ParsedName, Rank, State};
use crate::pipeline::authorship_parser::AuthState;
use crate::pipeline::blacklisted_epithets;
use crate::pipeline::code_inference;
use crate::pipeline::ParseContext;
pub(crate) fn finish(ctx: &mut ParseContext, auth_state: Option<&AuthState>) {
if ctx.aggregate
&& ctx.name.specific_epithet.is_some()
&& ctx.name.infraspecific_epithet.is_none()
{
ctx.name.rank = Rank::SpeciesAggregate;
}
let requested = ctx.requested_rank;
let mut authorship_dropped = false;
if let Some(req) = requested {
if req != Rank::Unranked
&& req != ctx.name.rank
&& req == Rank::SpeciesAggregate
&& ctx.name.specific_epithet.is_some()
{
ctx.name.rank = Rank::SpeciesAggregate;
}
}
if let Some(req) = requested {
if req != Rank::Unranked
&& (req == Rank::Species
|| req.is_infraspecific()
|| req == Rank::Cultivar
|| req == Rank::CultivarGroup
|| req == Rank::Grex)
&& ctx.name.uninomial.is_some()
&& ctx.name.specific_epithet.is_none()
&& ctx.name.type_ != NameType::Informal
{
ctx.name.genus = ctx.name.uninomial.take();
ctx.name.rank = req;
ctx.name.type_ = NameType::Informal;
ctx.name.add_warning(warnings::INDETERMINED);
if ctx.name.phrase.is_none() {
ctx.name.phrase = ctx.name.authorship_complete();
}
authorship_dropped = true;
ctx.name.combination_authorship = Authorship::default();
ctx.name.basionym_authorship = Authorship::default();
}
}
{
let r = match requested {
Some(req) if req.is_infrageneric_strictly() => req,
_ => ctx.name.rank,
};
if r.is_infrageneric_strictly()
&& ctx.name.uninomial.is_some()
&& ctx.name.genus.is_none()
&& ctx.name.infrageneric_epithet.is_none()
{
ctx.name.infrageneric_epithet = ctx.name.uninomial.take();
ctx.name.rank = r;
}
}
if let Some(req) = requested {
if req != Rank::Unranked
&& ctx.name.specific_epithet.is_some()
&& req.higher_than(Rank::Species)
&& req != ctx.name.rank
{
ctx.name.rank = req;
ctx.name.type_ = NameType::Informal;
ctx.name.doubtful = true;
ctx.name.add_warning(warnings::RANK_MISMATCH);
}
}
if ctx.name.type_ == NameType::Scientific {
if let Some(idx) = ctx.name.uninomial.as_ref().and_then(|u| u.find('_')) {
let uni = ctx.name.uninomial.clone().expect("just matched Some above");
let before = uni[..idx].to_string();
let after = uni[idx + 1..].to_string();
if after.chars().next().is_some_and(|c| c.is_lowercase()) {
ctx.name.uninomial = None;
ctx.name.genus = Some(before);
ctx.name.specific_epithet = Some(after);
ctx.name.rank = Rank::Species;
} else {
ctx.name.uninomial = Some(before);
ctx.name.phrase = Some(after);
ctx.name.type_ = NameType::Informal;
ctx.name.rank = Rank::Unranked;
}
}
}
let fold_tag_into_phrase = ctx.pending_unparsed_trailing_tag
&& ctx.name.type_ == NameType::Informal
&& ctx.name.specific_epithet.is_none()
&& ctx.name.phrase.is_some();
if fold_tag_into_phrase {
let tag = ctx
.pending_unparsed
.take()
.expect("flag implies a pending tag");
let phrase = ctx.name.phrase.as_mut().expect("checked is_some above");
phrase.push(' ');
phrase.push_str(&tag);
} else if ctx.pending_unparsed.is_some() && ctx.name.unparsed.is_none() {
ctx.name.state = State::Partial;
ctx.name.unparsed = ctx.pending_unparsed.clone();
}
let restore_page_to_phrase = ctx.page_strip_verbatim.is_some()
&& ctx.name.published_in_page.is_some()
&& ctx.name.type_ == NameType::Informal
&& ctx.name.specific_epithet.is_none()
&& ctx.name.phrase.is_some();
if restore_page_to_phrase {
let tail = ctx
.page_strip_verbatim
.take()
.expect("checked is_some above");
ctx.name.published_in_page = None;
let phrase = ctx.name.phrase.as_mut().expect("checked is_some above");
phrase.push_str(&tail);
}
if auth_state.is_some_and(|s| s.year_range) {
ctx.name.add_warning(warnings::YEAR_INTERPRETED);
}
if ctx.name.code.is_none() {
code_inference::infer(ctx, auth_state.filter(|_| !authorship_dropped));
}
if ctx.viral_shape && ctx.name.code.is_none() {
ctx.name.code = Some(NomCode::Virus);
}
code_inference::apply_rank_code_mismatch(ctx);
if ctx.name.rank == Rank::InfraspecificName
&& ctx.name.code == Some(NomCode::Zoological)
&& ctx.name.infraspecific_epithet.is_some()
{
ctx.name.rank = Rank::Subspecies;
}
if ctx.name.rank == Rank::InfragenericName
&& ctx.name.code == Some(NomCode::Zoological)
&& ctx.name.infrageneric_epithet.is_some()
&& ctx.name.specific_epithet.is_none()
{
ctx.name.rank = Rank::Subgenus;
}
if ctx.name.rank == Rank::Unranked {
if let Some(uninomial) = ctx.name.uninomial.clone() {
let code_for_inference =
ctx.requested_code
.or(if ctx.viral_shape { ctx.name.code } else { None });
let r = match code_for_inference {
Some(code) => rank_from_suffix(&uninomial, code),
None => rank_from_global_suffix(&uninomial),
};
if let Some(r) = r {
ctx.name.rank = r;
}
}
}
flag_blacklisted_epithets(&mut ctx.name);
flag_unlikely_years(&mut ctx.name);
if ctx.name.cultivar_epithet.is_some() {
if ctx.name.type_ == NameType::Informal {
ctx.name.type_ = NameType::Scientific;
}
ctx.name.warnings.retain(|w| w != warnings::INDETERMINED);
}
if ctx.name.phrase.as_ref().is_some_and(|p| !p.is_empty())
&& ctx.name.cultivar_epithet.is_none()
{
let r = ctx.name.rank;
let below_genus = r.is_infrageneric() || r == Rank::Species || r.is_infraspecific();
if below_genus && ctx.name.uninomial.is_some() && ctx.name.genus.is_none() {
ctx.name.genus = ctx.name.uninomial.take();
}
ctx.name.type_ = NameType::Informal;
}
if let Some(q) = ctx.quoted_monomial.clone() {
if let Some(uninomial) = ctx.name.uninomial.take() {
ctx.name.uninomial = Some(format!("{q}{uninomial}{q}"));
} else if let Some(genus) = ctx.name.genus.take() {
ctx.name.genus = Some(format!("{q}{genus}{q}"));
}
}
}
fn rank_from_suffix(name: &str, code: NomCode) -> Option<Rank> {
let suffixes = rank_utils::suffices_rank_map(code)?;
let s = name.to_lowercase();
suffixes
.iter()
.find(|(suffix, _)| s.ends_with(suffix))
.map(|(_, rank)| *rank)
}
fn rank_from_global_suffix(name: &str) -> Option<Rank> {
let s = name.to_lowercase();
if s.ends_with("aceae") {
Some(Rank::Family)
} else if s.ends_with("oideae") {
Some(Rank::Subfamily)
} else {
None
}
}
const MIN_YEAR: i32 = 1500;
const MAX_YEAR: i32 = 2100;
static YEAR_4DIGIT: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"^(?-u:\d{4})$").unwrap());
pub(crate) fn is_unlikely_year(year: Option<&str>) -> bool {
let Some(year) = year else { return false };
if year.ends_with('?') {
return false;
}
if !YEAR_4DIGIT.is_match(year) {
return true;
}
let v: i32 = year
.parse()
.expect("YEAR_4DIGIT just matched exactly 4 ASCII digits, always parseable as i32");
!(MIN_YEAR..=MAX_YEAR).contains(&v)
}
fn flag_unlikely_years(n: &mut ParsedName) {
if is_unlikely_year(n.combination_authorship.year.as_deref())
|| is_unlikely_year(n.basionym_authorship.year.as_deref())
{
n.doubtful = true;
n.add_warning(warnings::UNLIKELY_YEAR);
}
}
fn flag_blacklisted_epithets(n: &mut ParsedName) {
let name_parts = [
n.uninomial.clone(),
n.genus.clone(),
n.specific_epithet.clone(),
n.infraspecific_epithet.clone(),
];
for part in name_parts.into_iter().flatten() {
if part.eq_ignore_ascii_case("null") {
n.doubtful = true;
n.add_warning(warnings::NULL_EPITHET);
}
}
let epithets = [n.specific_epithet.clone(), n.infraspecific_epithet.clone()];
for ep in epithets.into_iter().flatten() {
if blacklisted_epithets::contains(&ep) {
n.doubtful = true;
n.add_warning(warnings::BLACKLISTED_EPITHET);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
fn base_ctx() -> ParseContext {
ParseContext::new("x".to_string(), None, None, None)
}
#[test]
fn aggregate_with_specific_epithet_becomes_species_aggregate() {
let mut ctx = base_ctx();
ctx.aggregate = true;
ctx.name.specific_epithet = Some("alba".to_string());
finish(&mut ctx, None);
assert_eq!(ctx.name.rank, Rank::SpeciesAggregate);
}
#[test]
fn requested_species_aggregate_preempts_the_later_rank_mismatch_step() {
let mut ctx = base_ctx();
ctx.requested_rank = Some(Rank::SpeciesAggregate);
ctx.name.rank = Rank::Species;
ctx.name.specific_epithet = Some("alba".to_string());
finish(&mut ctx, None);
assert_eq!(ctx.name.rank, Rank::SpeciesAggregate);
assert_eq!(
ctx.name.type_,
NameType::Scientific,
"step 6 must NOT also have fired"
);
assert!(!ctx.name.doubtful);
assert!(ctx.name.warnings.is_empty());
}
#[test]
fn indetermined_placeholder_promotes_uninomial_and_nulls_authorship() {
let mut ctx = base_ctx();
ctx.requested_rank = Some(Rank::Species);
ctx.name.uninomial = Some("Lepidoptera".to_string());
ctx.name.combination_authorship = Authorship {
authors: vec!["Hooker".to_string()],
..Default::default()
};
ctx.name.basionym_authorship = Authorship {
authors: vec!["Someone".to_string()],
..Default::default()
};
finish(&mut ctx, None);
assert_eq!(ctx.name.genus, Some("Lepidoptera".to_string()));
assert_eq!(ctx.name.uninomial, None);
assert_eq!(ctx.name.rank, Rank::Species);
assert_eq!(ctx.name.type_, NameType::Informal);
assert!(ctx
.name
.warnings
.contains(&warnings::INDETERMINED.to_string()));
assert_eq!(ctx.name.combination_authorship, Authorship::default());
assert_eq!(ctx.name.basionym_authorship, Authorship::default());
}
#[test]
fn indetermined_placeholder_does_not_fire_when_specific_epithet_already_present() {
let mut ctx = base_ctx();
ctx.requested_rank = Some(Rank::Species);
ctx.name.uninomial = Some("Polygonum".to_string());
ctx.name.specific_epithet = Some("alba".to_string());
finish(&mut ctx, None);
assert_eq!(ctx.name.uninomial, Some("Polygonum".to_string()));
assert!(!ctx
.name
.warnings
.contains(&warnings::INDETERMINED.to_string()));
}
#[test]
fn infrageneric_strict_uninomial_moves_to_infrageneric_epithet() {
let mut ctx = base_ctx();
ctx.requested_rank = Some(Rank::Subgenus);
ctx.name.uninomial = Some("Trematostoma".to_string());
finish(&mut ctx, None);
assert_eq!(
ctx.name.infrageneric_epithet,
Some("Trematostoma".to_string())
);
assert_eq!(ctx.name.uninomial, None);
assert_eq!(ctx.name.rank, Rank::Subgenus);
}
#[test]
fn binomial_with_higher_caller_rank_is_demoted_and_flagged() {
let mut ctx = base_ctx();
ctx.requested_rank = Some(Rank::Genus);
ctx.name.genus = Some("Polygonum".to_string());
ctx.name.specific_epithet = Some("alba".to_string());
ctx.name.rank = Rank::Species;
finish(&mut ctx, None);
assert_eq!(ctx.name.rank, Rank::Genus);
assert_eq!(ctx.name.type_, NameType::Informal);
assert!(ctx.name.doubtful);
assert!(ctx
.name
.warnings
.contains(&warnings::RANK_MISMATCH.to_string()));
}
#[test]
fn underscore_split_lowercase_after_becomes_genus_species() {
let mut ctx = base_ctx();
ctx.name.uninomial = Some("Oxalis_barrelieri".to_string());
finish(&mut ctx, None);
assert_eq!(ctx.name.uninomial, None);
assert_eq!(ctx.name.genus, Some("Oxalis".to_string()));
assert_eq!(ctx.name.specific_epithet, Some("barrelieri".to_string()));
assert_eq!(ctx.name.rank, Rank::Species);
}
#[test]
fn underscore_split_uppercase_after_becomes_gtdb_phrase_name() {
let mut ctx = base_ctx();
ctx.name.uninomial = Some("Desulfobacterota_B".to_string());
finish(&mut ctx, None);
assert_eq!(ctx.name.uninomial, Some("Desulfobacterota".to_string()));
assert_eq!(ctx.name.phrase, Some("B".to_string()));
assert_eq!(ctx.name.type_, NameType::Informal);
assert_eq!(ctx.name.rank, Rank::Unranked);
assert_eq!(
ctx.name.genus, None,
"step 18 must not promote a suprageneric GTDB phrase name to genus"
);
}
#[test]
fn underscore_split_is_skipped_for_a_non_scientific_type() {
let mut ctx = base_ctx();
ctx.name.uninomial = Some("Oxalis_barrelieri".to_string());
ctx.name.type_ = NameType::Informal;
finish(&mut ctx, None);
assert_eq!(ctx.name.uninomial, Some("Oxalis_barrelieri".to_string()));
}
#[test]
fn pending_unparsed_demotes_to_partial_state() {
let mut ctx = base_ctx();
ctx.pending_unparsed = Some("extra junk".to_string());
finish(&mut ctx, None);
assert_eq!(ctx.name.state, State::Partial);
assert_eq!(ctx.name.unparsed, Some("extra junk".to_string()));
}
#[test]
fn year_range_authorship_flags_year_interpreted() {
let mut ctx = base_ctx();
let auth = AuthState {
year_range: true,
..AuthState::default()
};
finish(&mut ctx, Some(&auth));
assert!(ctx
.name
.warnings
.contains(&warnings::YEAR_INTERPRETED.to_string()));
}
#[test]
fn candidatus_name_gets_bacterial_code_via_code_inference_wiring() {
let mut ctx = base_ctx();
ctx.name.candidatus = true;
finish(&mut ctx, None);
assert_eq!(ctx.name.code, Some(NomCode::Bacterial));
}
#[test]
fn viral_shape_with_no_other_signal_defaults_to_virus_code() {
let mut ctx = base_ctx();
ctx.viral_shape = true;
finish(&mut ctx, None);
assert_eq!(ctx.name.code, Some(NomCode::Virus));
}
#[test]
fn rank_code_mismatch_wired_through_finish_overrides_and_warns() {
let mut ctx = base_ctx();
ctx.name.rank = Rank::SupersectionBotany; ctx.name.code = Some(NomCode::Zoological); ctx.requested_code = Some(NomCode::Zoological);
finish(&mut ctx, None);
assert_eq!(ctx.name.code, Some(NomCode::Botanical));
assert!(ctx
.name
.warnings
.contains(&warnings::CODE_MISMATCH.to_string()));
}
#[test]
fn infraspecific_name_with_zoological_code_becomes_subspecies() {
let mut ctx = base_ctx();
ctx.name.genus = Some("Vulpes".to_string());
ctx.name.specific_epithet = Some("vulpes".to_string());
ctx.name.infraspecific_epithet = Some("silaceus".to_string());
ctx.name.rank = Rank::InfraspecificName;
ctx.name.code = Some(NomCode::Zoological);
finish(&mut ctx, None);
assert_eq!(ctx.name.rank, Rank::Subspecies);
}
#[test]
fn infraspecific_name_without_zoological_code_stays_unchanged() {
let mut ctx = base_ctx();
ctx.name.infraspecific_epithet = Some("silaceus".to_string());
ctx.name.rank = Rank::InfraspecificName;
ctx.name.code = Some(NomCode::Botanical);
finish(&mut ctx, None);
assert_eq!(ctx.name.rank, Rank::InfraspecificName);
}
#[test]
fn suffix_based_rank_via_requested_code() {
let mut ctx = base_ctx();
ctx.requested_code = Some(NomCode::Bacterial);
ctx.name.uninomial = Some("Enterobacteriaceae".to_string());
finish(&mut ctx, None);
assert_eq!(ctx.name.rank, Rank::Family);
}
#[test]
fn suffix_based_rank_global_fallback_when_no_code_known() {
let mut ctx = base_ctx();
ctx.name.uninomial = Some("Rosaceae".to_string());
finish(&mut ctx, None);
assert_eq!(ctx.name.rank, Rank::Family);
}
#[test]
fn blacklisted_epithet_flags_doubtful() {
let mut ctx = base_ctx();
ctx.name.genus = Some("Abies".to_string());
ctx.name.specific_epithet = Some("about".to_string()); finish(&mut ctx, None);
assert!(ctx.name.doubtful);
assert!(ctx
.name
.warnings
.contains(&warnings::BLACKLISTED_EPITHET.to_string()));
}
#[test]
fn literal_null_epithet_flags_doubtful() {
let mut ctx = base_ctx();
ctx.name.genus = Some("Null".to_string());
finish(&mut ctx, None);
assert!(ctx.name.doubtful);
assert!(ctx
.name
.warnings
.contains(&warnings::NULL_EPITHET.to_string()));
}
#[test]
fn unlikely_year_flags_doubtful() {
let mut ctx = base_ctx();
ctx.name.combination_authorship = Authorship {
authors: vec!["Wilcox".to_string()],
year: Some("137".to_string()),
..Default::default()
};
finish(&mut ctx, None);
assert!(ctx.name.doubtful);
assert!(ctx
.name
.warnings
.contains(&warnings::UNLIKELY_YEAR.to_string()));
}
#[test]
fn plausible_year_does_not_flag_unlikely_year() {
let mut ctx = base_ctx();
ctx.name.combination_authorship = Authorship {
authors: vec!["Mill.".to_string()],
year: Some("1987".to_string()),
..Default::default()
};
finish(&mut ctx, None);
assert!(!ctx
.name
.warnings
.contains(&warnings::UNLIKELY_YEAR.to_string()));
}
#[test]
fn cultivar_epithet_clears_informal_type_and_indetermined_warning() {
let mut ctx = base_ctx();
ctx.name.cultivar_epithet = Some("mother of pearl".to_string());
ctx.name.type_ = NameType::Informal;
ctx.name.add_warning(warnings::INDETERMINED);
finish(&mut ctx, None);
assert_eq!(ctx.name.type_, NameType::Scientific);
assert!(!ctx
.name
.warnings
.contains(&warnings::INDETERMINED.to_string()));
}
#[test]
fn phrase_without_cultivar_promotes_uninomial_to_genus_below_genus_rank() {
let mut ctx = base_ctx();
ctx.name.rank = Rank::Species;
ctx.name.uninomial = Some("Baeckea".to_string());
ctx.name.phrase = Some("sp1".to_string());
finish(&mut ctx, None);
assert_eq!(ctx.name.genus, Some("Baeckea".to_string()));
assert_eq!(ctx.name.uninomial, None);
assert_eq!(ctx.name.type_, NameType::Informal);
}
#[test]
fn quoted_monomial_is_rewrapped_around_the_uninomial() {
let mut ctx = base_ctx();
ctx.quoted_monomial = Some("'".to_string());
ctx.name.uninomial = Some("Prosthete".to_string());
finish(&mut ctx, None);
assert_eq!(ctx.name.uninomial, Some("'Prosthete'".to_string()));
}
#[test]
fn quoted_monomial_is_rewrapped_around_the_genus_when_no_uninomial() {
let mut ctx = base_ctx();
ctx.quoted_monomial = Some("\"".to_string());
ctx.name.genus = Some("Prosthete".to_string());
ctx.name.specific_epithet = Some("alba".to_string());
finish(&mut ctx, None);
assert_eq!(ctx.name.genus, Some("\"Prosthete\"".to_string()));
}
#[test]
fn is_unlikely_year_boundaries() {
assert!(!is_unlikely_year(Some("1500")));
assert!(!is_unlikely_year(Some("2100")));
assert!(is_unlikely_year(Some("1499")));
assert!(is_unlikely_year(Some("2101")));
assert!(is_unlikely_year(Some("137")));
assert!(is_unlikely_year(Some("0000")));
assert!(!is_unlikely_year(Some("198?")));
assert!(!is_unlikely_year(None));
}
#[test]
fn is_unlikely_year_rejects_a_5_digit_run() {
assert!(is_unlikely_year(Some("12345")));
}
#[test]
fn rank_from_suffix_direct() {
assert_eq!(
rank_from_suffix("Enterobacteriaceae", NomCode::Bacterial),
Some(Rank::Family)
);
assert_eq!(rank_from_suffix("Xyz", NomCode::Bacterial), None);
assert_eq!(rank_from_suffix("Xyz", NomCode::Cultivars), None);
}
#[test]
fn rank_from_global_suffix_direct() {
assert_eq!(rank_from_global_suffix("Rosaceae"), Some(Rank::Family));
assert_eq!(
rank_from_global_suffix("Bacilloideae"),
Some(Rank::Subfamily)
);
assert_eq!(rank_from_global_suffix("Xyz"), None);
}
#[test]
fn flag_blacklisted_epithets_flags_literal_null_on_a_non_epithet_field() {
let mut n = ParsedName {
genus: Some("Null".to_string()),
..Default::default()
};
flag_blacklisted_epithets(&mut n);
assert!(n.doubtful);
assert!(n.warnings.contains(&warnings::NULL_EPITHET.to_string()));
}
}