use crate::model::{warnings, NamePart, NameType, Rank, State};
use crate::pipeline::authorship_split;
use crate::pipeline::rank_markers;
use crate::pipeline::ParseContext;
use crate::token::{self, Token, TokenKind};
const AGG_HYPHEN_SUFFIXES: [&str; 3] = ["-group", "-complex", "-aggregate"];
pub(crate) fn classify(ctx: &mut ParseContext, boundary: usize) {
if boundary == 0 {
ctx.name.state = State::Partial;
ctx.name.unparsed = Some(ctx.original.clone());
return;
}
let ts: &[Token] = &ctx.tokens[..boundary];
let name_section_covers_all = boundary == ctx.tokens.len();
let mut genus: Option<String> = None;
let mut subgenus: Option<String> = None;
let mut infrageneric: Option<Rank> = None;
let mut infragen_epithet: Option<String> = None;
let mut lower_epithets: Vec<String> = Vec::with_capacity(4);
let mut marker_idx_in_epithets: i32 = -1;
let mut inline_rank: Option<Rank> = None;
let mut inline_rank_notho = false;
let mut indet = false;
let mut indet_bare = false;
let mut cf_aff_qualifier: Option<String> = None;
let mut pending_mid_name_author: Option<String> = None;
let mut i = 0usize;
while i < ts.len() {
let t = &ts[i];
if t.kind == TokenKind::HybridMark {
if genus.is_some() && lower_epithets.is_empty() {
ctx.name.add_notho(NamePart::Specific);
} else if genus.is_none() {
ctx.name.add_notho(NamePart::Generic);
} else {
ctx.name.add_notho(NamePart::Infraspecific);
}
i += 1;
continue;
}
if t.kind == TokenKind::OpenParen
&& lower_epithets.is_empty()
&& subgenus.is_none()
&& i + 2 < ts.len()
&& ts[i + 1].kind == TokenKind::Word
&& (starts_upper(&ts[i + 1]) || starts_lower(&ts[i + 1]))
&& ts[i + 2].kind == TokenKind::CloseParen
{
let raw = ts[i + 1].text.clone();
let sub = if starts_lower(&ts[i + 1]) {
ctx.name.doubtful = true;
let mut chars = raw.chars();
match chars.next() {
Some(c) => {
let mut s: String = c.to_uppercase().collect();
s.push_str(chars.as_str());
s
}
None => raw,
}
} else {
raw
};
subgenus = Some(sub);
i += 3;
continue;
}
if t.kind == TokenKind::OpenParen
&& lower_epithets.is_empty()
&& subgenus.is_none()
&& i + 3 < ts.len()
&& ts[i + 1].kind == TokenKind::Word
&& starts_upper(&ts[i + 1])
&& ts[i + 2].kind == TokenKind::Dot
&& ts[i + 3].kind == TokenKind::CloseParen
{
subgenus = Some(format!("{}.", ts[i + 1].text));
ctx.name.add_warning(warnings::ABBREVIATED_SUBGENUS);
i += 4;
continue;
}
if t.kind == TokenKind::OpenParen && genus.is_some() && !lower_epithets.is_empty() {
if let Some(after) = skip_paren_author_block(ts, i) {
if ctx.mid_author_from < 0
&& lower_epithets.len() == 1
&& marker_idx_in_epithets < 0
{
ctx.mid_author_from = i as i32;
ctx.mid_author_to = after as i32;
}
i = after;
continue;
}
}
if genus.is_none()
&& t.kind == TokenKind::Word
&& (1..=4).contains(&t.text.chars().count())
&& starts_upper(t)
&& i + 1 < ts.len()
&& ts[i + 1].kind == TokenKind::Dot
{
let next_is_lower_epithet =
i + 2 < ts.len() && ts[i + 2].kind == TokenKind::Word && starts_lower(&ts[i + 2]);
if t.text.chars().count() == 1 || next_is_lower_epithet {
genus = Some(format!("{}.", t.text));
ctx.name.type_ = NameType::Informal;
ctx.name.add_warning(warnings::ABBREVIATED_GENUS);
i += 2;
continue;
}
}
if genus.is_none() && t.kind == TokenKind::Other && t.text == "?" {
genus = Some("?".to_string());
i += 1;
continue;
}
if genus.is_some()
&& cf_aff_qualifier.is_none()
&& t.kind == TokenKind::Other
&& t.text == "?"
&& lower_epithets.len() < 2
{
cf_aff_qualifier = Some("?".to_string());
ctx.name.type_ = NameType::Informal;
ctx.name.doubtful = true;
ctx.name.add_warning(warnings::QUESTION_MARKS_REMOVED);
i += 1;
continue;
}
if t.kind == TokenKind::Word {
let can_start_author = starts_upper(t)
|| (starts_lower(t)
&& (token::is_particle(&t.text)
|| authorship_split::is_apostrophe_particle(&t.text)));
if genus.is_some() && can_start_author {
if let Some(after) = authorship_split::mid_name_author_end(ts, i) {
if ctx.mid_author_from < 0
&& lower_epithets.len() == 1
&& marker_idx_in_epithets < 0
{
ctx.mid_author_from = i as i32;
ctx.mid_author_to = after as i32;
}
pending_mid_name_author = Some(render_author_span(ts, i, after));
i = after;
continue;
}
}
if genus.is_none() {
let mut g = recover_case(&t.text, true);
i += 1;
if g.chars().count() == 2 && g.ends_with('.') {
} else if g.chars().count() == 1 && i < ts.len() && ts[i].kind == TokenKind::Dot {
g.push('.');
ctx.name.type_ = NameType::Informal;
i += 1;
}
genus = Some(g);
continue;
}
if starts_upper(t)
&& genus.is_some()
&& t.text.chars().count() > 1
&& is_all_upper_letters(&t.text)
{
let is_abbrev = i + 1 < ts.len() && ts[i + 1].kind == TokenKind::Dot;
if !is_abbrev {
lower_epithets.push(t.text.to_lowercase());
i += 1;
continue;
}
}
if genus.is_some() && starts_digit_epithet(t) {
lower_epithets.push(t.text.to_lowercase());
i += 1;
continue;
}
if starts_lower(t) {
let w = strip_dot(&t.text);
if w.chars().count() == 1 && !lower_epithets.is_empty() {
let cp = w.chars().next().unwrap() as u32;
let is_greek = (0x03B1..=0x03C9).contains(&cp);
let is_fungi_ascii =
cp == 0x237A || (u32::from(b'a')..=u32::from(b'g')).contains(&cp);
if is_greek || is_fungi_ascii {
let peek = i + 1;
if peek < ts.len()
&& ts[peek].kind == TokenKind::Word
&& starts_lower(&ts[peek])
{
i += 1;
continue;
}
}
}
if (w.eq_ignore_ascii_case("cf")
|| w.eq_ignore_ascii_case("aff")
|| w.eq_ignore_ascii_case("near"))
&& lower_epithets.len() < 2
{
cf_aff_qualifier = Some(if w.eq_ignore_ascii_case("near") {
w.to_string()
} else {
format!("{w}.")
});
ctx.name.type_ = NameType::Informal;
i += 1;
if i < ts.len() && ts[i].kind == TokenKind::Dot {
i += 1;
}
continue;
}
let number_follows_marker = {
let mut j = i + 1;
if j < ts.len() && ts[j].kind == TokenKind::Dot {
j += 1;
}
j < ts.len() && ts[j].kind == TokenKind::Number
};
let is_published_spec_epithet = w.eq_ignore_ascii_case("spec")
&& genus.is_some()
&& lower_epithets.is_empty()
&& !name_section_covers_all
&& i + 1 == ts.len();
if (w.eq_ignore_ascii_case("sp")
|| w.eq_ignore_ascii_case("spec")
|| w.eq_ignore_ascii_case("species")
|| w.eq_ignore_ascii_case("indet"))
&& !is_published_spec_epithet
&& (lower_epithets.is_empty()
|| marker_idx_in_epithets >= 0
|| number_follows_marker)
{
let marker_start = ts[i].start;
indet = true;
ctx.name.type_ = NameType::Informal;
i += 1;
if i < ts.len() && ts[i].kind == TokenKind::Dot {
i += 1;
}
let is_species_marker = w.eq_ignore_ascii_case("sp")
|| w.eq_ignore_ascii_case("spec")
|| w.eq_ignore_ascii_case("species");
if lower_epithets.is_empty()
&& ctx.name.cultivar_epithet.is_none()
&& ctx.name.phrase.is_none()
&& is_species_marker
{
indet_bare = i >= ts.len();
ctx.name.phrase =
Some(ctx.working[marker_start..ts[ts.len() - 1].end].to_string());
i = ts.len();
continue;
}
if i < ts.len() && ts[i].kind == TokenKind::Number {
let number = ts[i].text.clone();
i += 1;
if i < ts.len() {
ctx.name.phrase =
Some(ctx.working[marker_start..ts[ts.len() - 1].end].to_string());
i = ts.len();
} else if w.eq_ignore_ascii_case("species") {
ctx.name.phrase = Some(format!("species {number}"));
} else {
ctx.name.phrase = Some(number);
}
} else if i < ts.len()
&& ts[i].kind == TokenKind::Word
&& ts[i].text.chars().count() == 1
&& starts_upper(&ts[i])
&& i + 1 == ts.len()
{
ctx.name.phrase = Some(ts[i].text.clone());
i += 1;
} else if i < ts.len()
&& ts[i].kind == TokenKind::Word
&& ts[i].text.chars().count() >= 2
&& (i + 1 == ts.len()
|| (i + 1 < ts.len()
&& ts[i + 1].kind == TokenKind::Number
&& i + 2 == ts.len()))
{
let mut code = ts[i].text.clone();
i += 1;
if i < ts.len() && ts[i].kind == TokenKind::Number {
code.push_str(&ts[i].text);
i += 1;
}
if is_strain_code(&code) {
ctx.name.phrase = Some(code);
}
}
if name_section_covers_all
&& ctx.name.phrase.is_none()
&& lower_epithets.is_empty()
&& i < ts.len()
{
let start = ts[i].start;
let end = ts[ts.len() - 1].end;
ctx.name.phrase = Some(ctx.working[start..end].to_string());
i = ts.len();
}
continue;
}
if w.eq_ignore_ascii_case("sp")
&& lower_epithets.len() == 1
&& marker_idx_in_epithets < 0
&& has_infraspecific_epithet_after(ts, i)
{
inline_rank = Some(Rank::Subspecies);
marker_idx_in_epithets = lower_epithets.len() as i32;
i += 1;
if i < ts.len() && ts[i].kind == TokenKind::Dot {
i += 1;
}
continue;
}
if (w.eq_ignore_ascii_case("sp")
|| w.eq_ignore_ascii_case("spec")
|| w.eq_ignore_ascii_case("species"))
&& !lower_epithets.is_empty()
&& marker_idx_in_epithets < 0
{
let mut j = i + 1;
if j < ts.len() && ts[j].kind == TokenKind::Dot {
j += 1;
}
if j >= ts.len() {
i = j;
continue;
}
}
if let Some((rm_infra, notho_flag)) =
rank_markers::match_infraspecific_allow_notho(w)
{
if has_infraspecific_epithet_after(ts, i) {
if let Some(old_rank) = inline_rank.filter(|_| {
marker_idx_in_epithets >= 0
&& (marker_idx_in_epithets as usize) < lower_epithets.len()
}) {
let old_marker = old_rank.marker();
let old_epithet = &lower_epithets[marker_idx_in_epithets as usize];
let mut sb = String::from(warnings::REMOVED_PREFIX);
if let Some(m) = old_marker {
sb.push_str(m);
sb.push(' ');
}
sb.push_str(old_epithet);
if let Some(pma) = &pending_mid_name_author {
if !pma.is_empty() {
sb.push(' ');
sb.push_str(pma);
}
}
ctx.name.add_warning(&sb);
ctx.name.add_warning(warnings::QUADRINOMIAL);
}
inline_rank = Some(rm_infra);
inline_rank_notho = notho_flag;
marker_idx_in_epithets = lower_epithets.len() as i32;
pending_mid_name_author = None;
i += 1;
if i < ts.len() && ts[i].kind == TokenKind::Dot {
i += 1;
}
if i + 1 < ts.len()
&& ts[i].kind == TokenKind::Word
&& ts[i].text.eq_ignore_ascii_case("sp")
{
inline_rank = Some(Rank::FormaSpecialis);
i += 1;
if i < ts.len() && ts[i].kind == TokenKind::Dot {
i += 1;
}
}
if i < ts.len()
&& ts[i].kind == TokenKind::Word
&& ts[i].text.chars().count() == 1
&& starts_upper(&ts[i])
{
lower_epithets.push(ts[i].text.clone());
indet = true; i += 1;
}
} else if !lower_epithets.is_empty() {
indet = true;
inline_rank = Some(rm_infra);
inline_rank_notho = notho_flag;
marker_idx_in_epithets = lower_epithets.len() as i32;
i += 1;
if i < ts.len() && ts[i].kind == TokenKind::Dot {
i += 1;
}
} else {
lower_epithets.push(w.to_string());
i += 1;
if i < ts.len() && ts[i].kind == TokenKind::Dot {
i += 1;
}
}
continue;
}
if let Some((rm_infragen, gnotho)) = rank_markers::match_infrageneric_allow_notho(w)
{
if lower_epithets.is_empty() && subgenus.is_none() && infragen_epithet.is_none()
{
i += 1;
if i < ts.len() && ts[i].kind == TokenKind::Dot {
i += 1;
}
if i < ts.len() && ts[i].kind == TokenKind::Word && starts_upper(&ts[i]) {
infragen_epithet = Some(ts[i].text.clone());
infrageneric = Some(rm_infragen);
if gnotho {
ctx.name.add_notho(NamePart::Infrageneric);
}
i += 1;
}
continue;
}
}
{
let low = t.text.to_lowercase();
let mut stripped: Option<String> = None;
for suf in AGG_HYPHEN_SUFFIXES {
let char_count = t.text.chars().count();
let suf_chars = suf.chars().count();
if low.ends_with(suf) && char_count > suf_chars {
stripped = Some(t.text.chars().take(char_count - suf_chars).collect());
break;
}
}
if let Some(s) = stripped {
ctx.aggregate = true;
lower_epithets.push(s);
i += 1;
continue;
}
}
if !lower_epithets.is_empty()
&& (w.eq_ignore_ascii_case("agg")
|| w.eq_ignore_ascii_case("aggregate")
|| w.eq_ignore_ascii_case("group")
|| w.eq_ignore_ascii_case("complex"))
{
ctx.aggregate = true;
i += 1;
if i < ts.len() && ts[i].kind == TokenKind::Dot {
i += 1;
}
continue;
}
if !lower_epithets.is_empty()
&& w.eq_ignore_ascii_case("species")
&& i + 1 < ts.len()
&& ts[i + 1].kind == TokenKind::Word
&& ts[i + 1].text.eq_ignore_ascii_case("group")
{
ctx.aggregate = true;
i += 2;
continue;
}
lower_epithets.push(t.text.clone());
i += 1;
continue;
}
i += 1;
continue;
}
i += 1;
}
let mut specific: Option<String> = None;
let mut infraspecific: Option<String> = None;
let mut rank: Option<Rank> = None;
if marker_idx_in_epithets >= 0 {
let midx = marker_idx_in_epithets as usize;
if marker_idx_in_epithets >= 1 {
specific = Some(lower_epithets[0].clone());
}
if midx < lower_epithets.len() {
infraspecific = Some(lower_epithets[midx].clone());
}
rank = inline_rank;
if lower_epithets.len() as i32 > marker_idx_in_epithets + 1 {
let mut rem = String::new();
for epithet in &lower_epithets[(midx + 1)..] {
if !rem.is_empty() {
rem.push(' ');
}
rem.push_str(epithet);
}
ctx.name.state = State::Partial;
ctx.name.unparsed = Some(rem);
}
} else if !lower_epithets.is_empty() {
specific = Some(lower_epithets[0].clone());
if lower_epithets.len() >= 2 {
infraspecific = Some(lower_epithets[lower_epithets.len() - 1].clone());
rank = Some(if lower_epithets.len() == 2 {
Rank::InfraspecificName
} else {
Rank::InfrasubspecificName
});
} else {
rank = Some(Rank::Species);
}
}
let treat_as_genus = ctx.name.cultivar_epithet.is_some()
|| (indet && lower_epithets.is_empty() && genus.is_some());
if !treat_as_genus
&& genus.is_some()
&& specific.is_none()
&& subgenus.is_none()
&& infragen_epithet.is_none()
{
ctx.name.uninomial = genus.clone();
} else {
ctx.name.genus = genus.clone();
if let Some(sg) = &subgenus {
ctx.name.infrageneric_epithet = Some(sg.clone());
}
if let Some(ie) = &infragen_epithet {
ctx.name.infrageneric_epithet = Some(ie.clone());
}
if let Some(sp) = &specific {
ctx.name.specific_epithet = Some(sp.clone());
}
if let Some(isp) = &infraspecific {
ctx.name.infraspecific_epithet = Some(isp.clone());
}
}
let requested = ctx.requested_rank;
let cultivar_set = ctx.name.cultivar_epithet.is_some();
if let Some(r) = rank.filter(|_| !cultivar_set) {
ctx.name.rank = r;
} else if let Some(ig) = infrageneric.filter(|_| !cultivar_set) {
ctx.name.rank = ig;
} else if subgenus.is_some()
&& !cultivar_set
&& specific.is_none()
&& infraspecific.is_none()
&& ctx.name.rank == Rank::Unranked
{
ctx.name.rank = Rank::InfragenericName;
}
if inline_rank_notho {
ctx.name.set_notho(NamePart::Infraspecific);
}
if let Some(q) = &cf_aff_qualifier {
let part = if infraspecific.is_some() {
NamePart::Infraspecific
} else {
NamePart::Specific
};
ctx.name.set_epithet_qualifier(part, q);
}
if indet {
ctx.name.type_ = NameType::Informal;
if infraspecific.is_none() {
if lower_epithets.is_empty() && ctx.name.rank == Rank::Unranked {
ctx.name.rank = Rank::Species;
}
if ctx.name.phrase.is_none() || indet_bare {
ctx.name.add_warning(warnings::INDETERMINED);
}
}
}
if !indet
&& requested.is_some_and(|r| r != Rank::Unranked && r.is_infraspecific())
&& specific.is_some()
&& infraspecific.is_none()
{
ctx.name.type_ = NameType::Informal;
ctx.name.rank = requested.unwrap();
ctx.name.add_warning(warnings::INDETERMINED);
}
if requested == Some(Rank::Species) && infraspecific.is_some() {
ctx.name.add_warning(warnings::SUBSPECIES_ASSIGNED);
}
}
fn starts_upper(t: &Token) -> bool {
t.text.chars().next().is_some_and(|c| c.is_uppercase())
}
fn starts_lower(t: &Token) -> bool {
t.text.chars().next().is_some_and(|c| c.is_lowercase())
}
fn starts_digit_epithet(t: &Token) -> bool {
t.kind == TokenKind::Word
&& t.text.chars().next().is_some_and(|c| c.is_ascii_digit())
&& t.text.chars().any(|c| c.is_alphabetic())
}
fn render_author_span(ts: &[Token], from: usize, to: usize) -> String {
let mut sb = String::new();
for t in &ts[from..to] {
match t.kind {
TokenKind::Word => {
if !sb.is_empty() && !sb.ends_with('.') {
sb.push(' ');
}
sb.push_str(&t.text);
}
TokenKind::Dot if !sb.is_empty() && !sb.ends_with('.') => {
sb.push('.');
}
_ => {}
}
}
sb
}
fn skip_paren_author_block(ts: &[Token], open_idx: usize) -> Option<usize> {
let n = ts.len();
let mut depth = 1i32;
let mut j = open_idx + 1;
while j < n && depth > 0 {
let k = ts[j].kind;
if k == TokenKind::OpenParen {
depth += 1;
} else if k == TokenKind::CloseParen {
depth -= 1;
}
if depth == 0 {
break;
}
j += 1;
}
if j >= n || depth != 0 {
return None;
}
j += 1; while j < n {
let t = &ts[j];
if t.kind == TokenKind::Word {
if starts_upper(t) {
j += 1;
continue;
}
if token::is_particle(&t.text) {
j += 1;
continue;
}
let w = strip_dot(&t.text);
if rank_markers::match_infraspecific_allow_notho(w).is_some() {
return Some(j);
}
return None;
}
if t.kind == TokenKind::Dot || t.kind == TokenKind::Ampersand || t.kind == TokenKind::Comma
{
j += 1;
continue;
}
return None;
}
None
}
fn recover_case(text: &str, is_genus: bool) -> String {
if text.chars().count() < 2 {
return text.to_string();
}
if is_genus && text.contains('-') {
let parts: Vec<&str> = text.split('-').collect();
if parts.len() >= 2 {
let needs_norm = parts[1..]
.iter()
.any(|p| p.chars().next().is_some_and(|c| c.is_uppercase()));
if needs_norm && (parts[0].chars().count() <= 3 || parts.len() >= 3) {
let mut sb = String::from(parts[0]);
for p in &parts[1..] {
sb.push('-');
let mut chars = p.chars();
match chars.next() {
Some(c) if c.is_uppercase() => {
let lc: String = c.to_lowercase().collect();
sb.push_str(&lc);
sb.push_str(chars.as_str());
}
_ => sb.push_str(p),
}
}
return sb;
}
}
}
let upper = is_all_letter_case(text, true);
let lower = !upper && is_all_letter_case(text, false);
if !upper && !lower {
return text.to_string();
}
let mut b = String::with_capacity(text.len());
let mut first = true;
for c in text.chars() {
if c.is_alphabetic() {
if first {
let uc: String = c.to_uppercase().collect();
b.push_str(&uc);
first = false;
} else {
let lc: String = c.to_lowercase().collect();
b.push_str(&lc);
}
} else {
b.push(c);
first = true;
}
}
b
}
fn is_all_upper_letters(s: &str) -> bool {
is_all_letter_case(s, true)
}
fn has_infraspecific_epithet_after(ts: &[Token], marker_idx: usize) -> bool {
let n = ts.len();
let mut k = marker_idx + 1;
if k < n && ts[k].kind == TokenKind::Dot {
k += 1;
}
if k < n && ts[k].kind == TokenKind::HybridMark {
k += 1;
}
if k >= n {
return false;
}
let nx = &ts[k];
if nx.kind == TokenKind::Word && starts_lower(nx) {
return true;
}
if nx.kind == TokenKind::Word && nx.text.chars().count() == 1 && starts_upper(nx) {
return true;
}
false
}
fn is_strain_code(s: &str) -> bool {
if s.chars().count() < 3 {
return false;
}
let mut has_letter = false;
let mut has_digit = false;
for c in s.chars() {
if c.is_alphabetic() {
has_letter = true;
} else if c.is_ascii_digit() {
has_digit = true;
}
}
has_letter && has_digit
}
fn is_all_letter_case(s: &str, upper: bool) -> bool {
let mut have_letter = false;
for c in s.chars() {
if c.is_alphabetic() {
have_letter = true;
if upper && !c.is_uppercase() {
return false;
}
if !upper && !c.is_lowercase() {
return false;
}
}
}
have_letter
}
fn strip_dot(s: &str) -> &str {
s.strip_suffix('.').unwrap_or(s)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::model::NomCode;
use crate::token::tokenize;
fn run(input: &str, requested_rank: Option<Rank>) -> ParseContext {
let mut ctx = ParseContext::new(input.to_string(), None, requested_rank, None);
ctx.tokens = tokenize(input);
let boundary = authorship_split::find_boundary(&ctx.tokens, &ctx);
classify(&mut ctx, boundary);
ctx
}
#[test]
fn boundary_zero_short_circuits_to_partial_unparsed_and_touches_nothing_else() {
let mut ctx = ParseContext::new("a".to_string(), None, None, None);
ctx.tokens = tokenize("a");
classify(&mut ctx, 0);
assert_eq!(ctx.name.state, State::Partial);
assert_eq!(ctx.name.unparsed, Some("a".to_string()));
assert_eq!(ctx.name.genus, None);
assert_eq!(ctx.name.uninomial, None);
assert!(ctx.name.warnings.is_empty());
}
#[test]
fn bare_uninomial_routes_to_uninomial_not_genus() {
let ctx = run("Abies", None);
assert_eq!(ctx.name.uninomial, Some("Abies".to_string()));
assert_eq!(ctx.name.genus, None);
assert_eq!(ctx.name.rank, Rank::Unranked);
}
#[test]
fn binomial_routes_genus_and_specific_epithet_not_uninomial() {
let ctx = run("Abies alba", None);
assert_eq!(ctx.name.genus, Some("Abies".to_string()));
assert_eq!(ctx.name.uninomial, None);
assert_eq!(ctx.name.specific_epithet, Some("alba".to_string()));
assert_eq!(ctx.name.rank, Rank::Species);
}
#[test]
fn cultivar_epithet_present_forces_genus_routing_even_for_a_bare_uninomial() {
let mut ctx = ParseContext::new("Acer".to_string(), None, None, None);
ctx.name.cultivar_epithet = Some("Elsrijk".to_string());
ctx.tokens = tokenize("Acer");
let boundary = authorship_split::find_boundary(&ctx.tokens, &ctx);
classify(&mut ctx, boundary);
assert_eq!(ctx.name.genus, Some("Acer".to_string()));
assert_eq!(
ctx.name.uninomial, None,
"treatAsGenus (cultivarEpithet != null) must route through setGenus, not setUninomial"
);
}
#[test]
fn paren_subgenus_with_trailing_species_sets_infrageneric_epithet_and_rank_from_species() {
let ctx = run("Amnicola (Amnicola) dubrueilliana", None);
assert_eq!(ctx.name.genus, Some("Amnicola".to_string()));
assert_eq!(ctx.name.infrageneric_epithet, Some("Amnicola".to_string()));
assert_eq!(ctx.name.specific_epithet, Some("dubrueilliana".to_string()));
assert_eq!(ctx.name.rank, Rank::Species);
}
#[test]
fn paren_subgenus_alone_with_no_species_defaults_rank_to_infrageneric_name() {
let ctx = run("Arrhoges (Antarctohoges)", None);
assert_eq!(ctx.name.genus, Some("Arrhoges".to_string()));
assert_eq!(
ctx.name.infrageneric_epithet,
Some("Antarctohoges".to_string())
);
assert_eq!(ctx.name.specific_epithet, None);
assert_eq!(
ctx.name.rank,
Rank::InfragenericName,
"a bare paren-subgenus with no explicit rank marker defaults to INFRAGENERIC_NAME"
);
assert_eq!(
ctx.name.uninomial, None,
"subgenus != null routes to genus even though there's no species epithet"
);
}
#[test]
fn abbreviated_subgenus_sets_infrageneric_epithet_with_dot_and_warns() {
let ctx = run("Phalaena (Tin.) guttella", None);
assert_eq!(ctx.name.genus, Some("Phalaena".to_string()));
assert_eq!(ctx.name.infrageneric_epithet, Some("Tin.".to_string()));
assert_eq!(ctx.name.specific_epithet, Some("guttella".to_string()));
assert!(ctx
.name
.warnings
.contains(&warnings::ABBREVIATED_SUBGENUS.to_string()));
}
#[test]
fn infrageneric_marker_then_paren_subgenus_the_marker_form_wins_the_overwrite() {
let input = "Genus sect. Foo (Bar)";
let mut ctx = ParseContext::new(input.to_string(), None, None, None);
ctx.tokens = tokenize(input);
let boundary = ctx.tokens.len();
classify(&mut ctx, boundary);
assert_eq!(ctx.name.genus, Some("Genus".to_string()));
assert_eq!(
ctx.name.infrageneric_epithet,
Some("Foo".to_string()),
"the infrageneric-MARKER form must win over the paren-subgenus form"
);
assert_eq!(ctx.name.rank, Rank::SectionBotany);
}
#[test]
fn subsp_rank_marker_sets_infraspecific_epithet_and_rank_with_no_warnings() {
let ctx = run("Abies alba subsp. alba", None);
assert_eq!(ctx.name.genus, Some("Abies".to_string()));
assert_eq!(ctx.name.specific_epithet, Some("alba".to_string()));
assert_eq!(ctx.name.infraspecific_epithet, Some("alba".to_string()));
assert_eq!(ctx.name.rank, Rank::Subspecies);
assert!(ctx.name.warnings.is_empty());
}
#[test]
fn apostrophe_particle_mid_name_author_is_skipped_and_records_mid_author_span() {
let ctx = run("Cirsium creticum d'Urv. subsp. creticum", None);
assert_eq!(ctx.name.genus, Some("Cirsium".to_string()));
assert_eq!(ctx.name.specific_epithet, Some("creticum".to_string()));
assert_eq!(ctx.name.infraspecific_epithet, Some("creticum".to_string()));
assert_eq!(ctx.name.rank, Rank::Subspecies);
assert_eq!(ctx.mid_author_from, 2);
assert_eq!(ctx.mid_author_to, 4);
assert!(ctx.name.warnings.is_empty());
}
#[test]
fn hybrid_mark_before_genus_adds_generic_notho() {
let ctx = run("x Abies alba", None);
assert_eq!(ctx.name.genus, Some("Abies".to_string()));
assert_eq!(ctx.name.specific_epithet, Some("alba".to_string()));
assert_eq!(ctx.name.notho, Some(vec![NamePart::Generic]));
}
#[test]
fn hybrid_mark_after_genus_before_any_epithet_adds_specific_notho() {
let ctx = run("Abies \u{00D7} alba", None);
assert_eq!(ctx.name.genus, Some("Abies".to_string()));
assert_eq!(ctx.name.specific_epithet, Some("alba".to_string()));
assert_eq!(ctx.name.notho, Some(vec![NamePart::Specific]));
}
#[test]
fn set_notho_overwrite_asymmetry_erases_earlier_generic_notho() {
let ctx = run("x Abies alba nothovar. rubra", None);
assert_eq!(ctx.name.genus, Some("Abies".to_string()));
assert_eq!(ctx.name.specific_epithet, Some("alba".to_string()));
assert_eq!(ctx.name.infraspecific_epithet, Some("rubra".to_string()));
assert_eq!(ctx.name.rank, Rank::Variety);
assert_eq!(
ctx.name.notho,
Some(vec![NamePart::Infraspecific]),
"setNotho(INFRASPECIFIC) must REPLACE the set, not add to the earlier GENERIC entry"
);
}
#[test]
fn cf_qualifier_sets_epithet_qualifier_on_specific_and_marks_informal() {
let ctx = run("Abies cf. alba", None);
assert_eq!(ctx.name.genus, Some("Abies".to_string()));
assert_eq!(ctx.name.specific_epithet, Some("alba".to_string()));
assert_eq!(ctx.name.type_, NameType::Informal);
let mut expected = std::collections::BTreeMap::new();
expected.insert(NamePart::Specific, "cf.".to_string());
assert_eq!(ctx.name.epithet_qualifier, Some(expected));
}
#[test]
fn open_nomenclature_question_mark_between_epithets_sets_qualifier_on_infraspecific() {
let ctx = run("Buteo borealis ? ventralis", None);
assert_eq!(ctx.name.genus, Some("Buteo".to_string()));
assert_eq!(ctx.name.specific_epithet, Some("borealis".to_string()));
assert_eq!(
ctx.name.infraspecific_epithet,
Some("ventralis".to_string())
);
assert_eq!(ctx.name.rank, Rank::InfraspecificName);
assert!(ctx.name.doubtful);
assert_eq!(ctx.name.type_, NameType::Informal);
assert!(ctx
.name
.warnings
.contains(&warnings::QUESTION_MARKS_REMOVED.to_string()));
let mut expected = std::collections::BTreeMap::new();
expected.insert(NamePart::Infraspecific, "?".to_string());
assert_eq!(ctx.name.epithet_qualifier, Some(expected));
}
#[test]
fn indet_species_marker_with_single_letter_phrase_suppresses_the_indetermined_warning() {
let ctx = run("Bryozoan sp. E", None);
assert_eq!(ctx.name.genus, Some("Bryozoan".to_string()));
assert_eq!(
ctx.name.uninomial, None,
"indet routes through genus, not uninomial"
);
assert_eq!(ctx.name.specific_epithet, None);
assert_eq!(ctx.name.phrase, Some("sp. E".to_string()));
assert_eq!(ctx.name.type_, NameType::Informal);
assert_eq!(ctx.name.rank, Rank::Species);
assert!(
ctx.name.warnings.is_empty(),
"a phrase identifier suppresses the generic INDETERMINED warning"
);
}
#[test]
fn bare_indet_species_marker_captures_the_marker_and_keeps_the_indetermined_warning() {
let ctx = run("Bryozoan sp.", None);
assert_eq!(ctx.name.genus, Some("Bryozoan".to_string()));
assert_eq!(ctx.name.phrase, Some("sp.".to_string()));
assert_eq!(ctx.name.type_, NameType::Informal);
assert_eq!(ctx.name.rank, Rank::Species);
assert!(ctx
.name
.warnings
.contains(&warnings::INDETERMINED.to_string()));
}
#[test]
fn informal_single_uppercase_letter_after_rank_marker_is_captured_as_infraspecific() {
let ctx = run("Foo bar var. A", None);
assert_eq!(ctx.name.genus, Some("Foo".to_string()));
assert_eq!(ctx.name.specific_epithet, Some("bar".to_string()));
assert_eq!(ctx.name.infraspecific_epithet, Some("A".to_string()));
assert_eq!(ctx.name.rank, Rank::Variety);
assert_eq!(ctx.name.type_, NameType::Informal);
assert!(
ctx.name.warnings.is_empty(),
"infraspecific is set, so the indet-with-no-infraspecific INDETERMINED path must not fire"
);
}
#[test]
fn quadrinomial_overflow_drops_the_first_marker_and_flags_partial_unparsed() {
let ctx = run("Abies alba subsp. nigra var. rubra pallens", None);
assert_eq!(ctx.name.genus, Some("Abies".to_string()));
assert_eq!(ctx.name.specific_epithet, Some("alba".to_string()));
assert_eq!(
ctx.name.infraspecific_epithet,
Some("rubra".to_string()),
"the SECOND marker (var.) wins; the first (subsp. nigra) is dropped"
);
assert_eq!(ctx.name.rank, Rank::Variety);
assert_eq!(ctx.name.state, State::Partial);
assert_eq!(ctx.name.unparsed, Some("pallens".to_string()));
assert!(ctx
.name
.warnings
.contains(&"Removed: subsp. nigra".to_string()));
assert!(ctx
.name
.warnings
.contains(&warnings::QUADRINOMIAL.to_string()));
}
#[test]
fn abbreviated_genus_sets_informal_type_and_warns() {
let ctx = run("M. alpium", None);
assert_eq!(ctx.name.genus, Some("M.".to_string()));
assert_eq!(ctx.name.specific_epithet, Some("alpium".to_string()));
assert_eq!(ctx.name.type_, NameType::Informal);
assert!(ctx
.name
.warnings
.contains(&warnings::ABBREVIATED_GENUS.to_string()));
}
#[test]
fn digit_leading_epithet_is_lowercased_into_specific_epithet() {
let ctx = run("Adalia 11-punctata", None);
assert_eq!(ctx.name.genus, Some("Adalia".to_string()));
assert_eq!(ctx.name.specific_epithet, Some("11-punctata".to_string()));
assert_eq!(ctx.name.rank, Rank::Species);
}
#[test]
fn standalone_aggregate_marker_sets_ctx_aggregate() {
let ctx = run("Poecilia sphenops agg.", None);
assert_eq!(ctx.name.genus, Some("Poecilia".to_string()));
assert_eq!(ctx.name.specific_epithet, Some("sphenops".to_string()));
assert!(ctx.aggregate);
}
#[test]
fn hyphenated_aggregate_suffix_strips_the_suffix_and_sets_ctx_aggregate() {
let ctx = run("Poecilia sphenops-group", None);
assert_eq!(ctx.name.genus, Some("Poecilia".to_string()));
assert_eq!(ctx.name.specific_epithet, Some("sphenops".to_string()));
assert!(ctx.aggregate);
}
#[test]
fn requested_species_rank_with_an_infraspecific_epithet_warns_subspecies_assigned() {
let ctx = run("Abies alba subsp. alba", Some(Rank::Species));
assert_eq!(ctx.name.infraspecific_epithet, Some("alba".to_string()));
assert!(ctx
.name
.warnings
.contains(&warnings::SUBSPECIES_ASSIGNED.to_string()));
}
#[test]
fn requested_infraspecific_rank_on_a_bare_binomial_is_marked_informal_indetermined() {
let ctx = run("Abies alba", Some(Rank::Subspecies));
assert_eq!(ctx.name.genus, Some("Abies".to_string()));
assert_eq!(ctx.name.specific_epithet, Some("alba".to_string()));
assert_eq!(ctx.name.infraspecific_epithet, None);
assert_eq!(
ctx.name.rank,
Rank::Subspecies,
"the caller-requested rank overwrites the post-loop SPECIES default"
);
assert_eq!(ctx.name.type_, NameType::Informal);
assert!(ctx
.name
.warnings
.contains(&warnings::INDETERMINED.to_string()));
}
#[test]
fn missing_genus_placeholder_question_mark_is_kept_as_genus() {
let ctx = run("? gryphoides", None);
assert_eq!(ctx.name.genus, Some("?".to_string()));
assert_eq!(ctx.name.specific_epithet, Some("gryphoides".to_string()));
}
#[test]
fn caller_supplied_code_is_unaffected_by_classify() {
let mut ctx = ParseContext::new(
"Abies alba".to_string(),
None,
None,
Some(NomCode::Botanical),
);
ctx.tokens = tokenize(&ctx.original.clone());
let boundary = authorship_split::find_boundary(&ctx.tokens, &ctx);
classify(&mut ctx, boundary);
assert_eq!(ctx.name.code, Some(NomCode::Botanical));
}
}