use crate::pipeline::rank_markers;
use crate::pipeline::ParseContext;
use crate::token::{self, Token, TokenKind};
pub fn find_boundary(tokens: &[Token], ctx: &ParseContext) -> usize {
let n = tokens.len();
if n == 0 {
return 0;
}
let mut i = 0usize;
let mut name_words = 0u32;
let mut after_genus = false;
let mut after_subgenus = false;
let mut have_epithet = false;
let mut genus_all_caps = false;
let mut genus_family_shape = false;
let mut genus_text: Option<&str> = None;
while i < n {
let t = &tokens[i];
if t.kind == TokenKind::HybridMark {
i += 1;
continue;
}
if name_words == 0 && t.kind == TokenKind::Other && t.text == "?" {
name_words += 1;
after_genus = true;
i += 1;
continue;
}
if after_genus && t.kind == TokenKind::Other && t.text == "?" {
i += 1;
continue;
}
if t.kind == TokenKind::Word {
if name_words == 0 {
if starts_upper(t) {
name_words += 1;
after_genus = true;
let len = t.text.chars().count();
genus_all_caps = len > 1 && is_all_upper(&t.text);
genus_family_shape = is_family_shape(&t.text);
genus_text = Some(t.text.as_str());
i += 1;
if (1..=4).contains(&len) && i < n && tokens[i].kind == TokenKind::Dot {
let short_enough_for_abbrev = len == 1
|| (i + 1 < n
&& tokens[i + 1].kind == TokenKind::Word
&& starts_lower(&tokens[i + 1]));
if short_enough_for_abbrev {
i += 1;
}
}
continue;
}
if t.text.chars().count() >= 2 {
name_words += 1;
after_genus = true;
i += 1;
continue;
}
return i;
}
if starts_lower(t) {
let w = strip_dot(&t.text);
if w.eq_ignore_ascii_case("anon") {
return i;
}
if w.eq_ignore_ascii_case("cf")
|| w.eq_ignore_ascii_case("aff")
|| w.eq_ignore_ascii_case("sp")
|| w.eq_ignore_ascii_case("spec")
|| w.eq_ignore_ascii_case("species")
|| w.eq_ignore_ascii_case("indet")
{
let is_sp = w.eq_ignore_ascii_case("sp") || w.eq_ignore_ascii_case("spec");
let is_cf_or_aff =
w.eq_ignore_ascii_case("cf") || w.eq_ignore_ascii_case("aff");
let is_published_spec_epithet = w.eq_ignore_ascii_case("spec")
&& !have_epithet
&& i + 1 < n
&& (tokens[i + 1].kind == TokenKind::OpenParen
|| (tokens[i + 1].kind == TokenKind::Word
&& starts_upper(&tokens[i + 1])));
i += 1;
if i < n && tokens[i].kind == TokenKind::Dot {
i += 1;
}
if is_cf_or_aff && !have_epithet {
if let Some(after_repeat) = skip_repeated_genus(tokens, i, genus_text) {
i = after_repeat;
continue;
}
}
if i < n && tokens[i].kind == TokenKind::Number {
i += 1;
} else if is_sp
&& !is_published_spec_epithet
&& i < n
&& tokens[i].kind == TokenKind::Word
&& (tokens[i].text.chars().count() >= 2
|| (tokens[i].text.chars().count() == 1 && starts_upper(&tokens[i])))
&& (i + 1 == n
|| (i + 1 < n && tokens[i + 1].kind == TokenKind::Number && i + 2 == n))
{
i += 1;
if i < n && tokens[i].kind == TokenKind::Number {
i += 1;
}
}
if !is_cf_or_aff && !have_epithet && !is_published_spec_epithet && i < n {
return n;
}
continue;
}
if w.eq_ignore_ascii_case("agg")
|| w.eq_ignore_ascii_case("aggregate")
|| w.eq_ignore_ascii_case("group")
|| w.eq_ignore_ascii_case("complex")
{
i += 1;
if i < n && tokens[i].kind == TokenKind::Dot {
i += 1;
}
continue;
}
if rank_markers::match_infraspecific_allow_notho(w).is_some() {
i += 1;
if i < n && tokens[i].kind == TokenKind::Dot {
i += 1;
}
if i + 1 < n
&& tokens[i].kind == TokenKind::Word
&& tokens[i].text.eq_ignore_ascii_case("sp")
{
i += 1;
if i < n && tokens[i].kind == TokenKind::Dot {
i += 1;
}
}
if i < n
&& tokens[i].kind == TokenKind::Word
&& tokens[i].text.chars().count() == 1
&& starts_upper(&tokens[i])
{
i += 1;
have_epithet = true;
}
continue;
}
if after_genus
&& !have_epithet
&& !after_subgenus
&& rank_markers::match_infrageneric_allow_notho(w).is_some()
{
i += 1;
if i < n && tokens[i].kind == TokenKind::Dot {
i += 1;
}
if i < n && tokens[i].kind == TokenKind::Word && starts_upper(&tokens[i]) {
i += 1;
after_subgenus = true;
}
continue;
}
if token::is_particle(&t.text) || looks_like_apostrophe_particle(&t.text) {
if let Some(after_author) = consume_mid_name_author(tokens, i) {
i = after_author;
continue;
}
if particle_is_epithet_by_rank(tokens, i, ctx, after_genus, have_epithet) {
name_words += 1;
have_epithet = true;
after_subgenus = false;
i += 1;
continue;
}
return i;
}
if w.eq_ignore_ascii_case("hort") {
return i;
}
name_words += 1;
have_epithet = true;
after_subgenus = false;
i += 1;
continue;
}
if after_genus && starts_digit_epithet(t) {
name_words += 1;
have_epithet = true;
after_subgenus = false;
i += 1;
continue;
}
if let Some(after_author) = consume_mid_name_author(tokens, i) {
i = after_author;
continue;
}
if genus_all_caps && after_genus && t.text.chars().count() > 1 && is_all_upper(&t.text)
{
let is_abbrev = i + 1 < n && tokens[i + 1].kind == TokenKind::Dot;
if !is_abbrev {
name_words += 1;
have_epithet = true;
after_subgenus = false;
i += 1;
continue;
}
}
return i;
}
if t.kind == TokenKind::OpenParen {
if after_genus && !have_epithet && !after_subgenus && !genus_family_shape {
let j = i + 1;
if j < n
&& tokens[j].kind == TokenKind::Word
&& (starts_upper(&tokens[j]) || starts_lower(&tokens[j]))
{
let k = j + 1;
let mut after_paren: Option<usize> = None;
let mut abbreviated = false;
if k < n && tokens[k].kind == TokenKind::CloseParen {
after_paren = Some(k + 1);
} else if starts_upper(&tokens[j])
&& k + 1 < n
&& tokens[k].kind == TokenKind::Dot
&& tokens[k + 1].kind == TokenKind::CloseParen
{
after_paren = Some(k + 2);
abbreviated = true;
}
if let Some(after_paren) = after_paren {
let has_trailing = after_paren < n;
let next = if has_trailing {
Some(&tokens[after_paren])
} else {
None
};
let trailing_is_epithet = next.is_some_and(|nx| {
nx.kind == TokenKind::Word
&& starts_lower(nx)
&& !token::is_particle(&nx.text)
});
let nominotypical =
genus_text.is_some_and(|g| eq_ignore_case(g, &tokens[j].text));
let rank_requests_infragen = ctx
.requested_rank
.is_some_and(|r| r.is_infrageneric_strictly());
let subgenus = if trailing_is_epithet {
true
} else if abbreviated {
false
} else {
!has_trailing
|| nominotypical
|| rank_requests_infragen
|| has_year_token(tokens, after_paren, n)
};
if subgenus {
i = after_paren;
after_subgenus = true;
continue;
}
return i;
}
}
}
if have_epithet && !after_subgenus {
if let Some(after_span) = skip_paren_author_block(tokens, i) {
i = after_span;
continue;
}
}
return i;
}
return i;
}
n
}
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 eq_ignore_case(a: &str, b: &str) -> bool {
a.to_lowercase() == b.to_lowercase()
}
fn strip_dot(s: &str) -> &str {
s.strip_suffix('.').unwrap_or(s)
}
pub fn mid_name_author_end(tokens: &[Token], from: usize) -> Option<usize> {
consume_mid_name_author(tokens, from)
}
fn skip_repeated_genus(tokens: &[Token], i: usize, genus_text: Option<&str>) -> Option<usize> {
let genus = genus_text?;
let t = tokens.get(i)?;
if t.kind != TokenKind::Word || !starts_upper(t) {
return None;
}
if !genus.to_lowercase().starts_with(&t.text.to_lowercase()) {
return None;
}
let mut j = i + 1;
if j < tokens.len() && tokens[j].kind == TokenKind::Dot {
j += 1;
}
let next = tokens.get(j)?;
if next.kind == TokenKind::Word && starts_lower(next) && !token::is_particle(&next.text) {
Some(j)
} else {
None
}
}
fn particle_is_epithet_by_rank(
tokens: &[Token],
i: usize,
ctx: &ParseContext,
after_genus: bool,
have_epithet: bool,
) -> bool {
if !after_genus || have_epithet {
return false;
}
if !ctx.requested_rank.is_some_and(|r| r.is_species_or_below()) {
return false;
}
if !token::is_particle(&tokens[i].text) {
return false;
}
let mut j = i + 1;
while j < tokens.len() && tokens[j].kind == TokenKind::Dot {
j += 1;
}
match tokens.get(j) {
Some(next) if next.kind == TokenKind::Word => !starts_lower(next),
_ => true,
}
}
fn consume_mid_name_author(tokens: &[Token], from: usize) -> Option<usize> {
let n = tokens.len();
if from >= n {
return None;
}
let first = &tokens[from];
if first.kind != TokenKind::Word {
return None;
}
if !starts_upper(first)
&& !token::is_particle(&first.text)
&& !looks_like_apostrophe_particle(&first.text)
{
return None;
}
let mut j = from;
while j < n {
let t = &tokens[j];
if t.kind == TokenKind::Word {
if starts_upper(t) {
j += 1;
continue;
}
if token::is_particle(&t.text) {
j += 1;
continue;
}
if looks_like_apostrophe_particle(&t.text) {
j += 1;
continue;
}
if t.text.eq_ignore_ascii_case("al") {
j += 1;
continue;
}
let w = strip_dot(&t.text);
let is_infra_marker = rank_markers::match_infraspecific(w).is_some()
|| rank_markers::match_infraspecific_allow_notho(w).is_some();
let is_infra_gen_marker = rank_markers::match_infrageneric(w).is_some();
if (is_infra_marker || is_infra_gen_marker)
&& j > from
&& has_epithet_after_marker(tokens, j, is_infra_gen_marker)
{
return Some(j);
}
return None;
}
if t.kind == TokenKind::Dot || t.kind == TokenKind::Ampersand || t.kind == TokenKind::Comma
{
j += 1;
continue;
}
if t.kind == TokenKind::Other && t.text == "'" {
j += 1;
continue;
}
return None;
}
None
}
fn has_epithet_after_marker(tokens: &[Token], marker_idx: usize, infrageneric: bool) -> bool {
let n = tokens.len();
let mut k = marker_idx + 1;
if k < n && tokens[k].kind == TokenKind::Dot {
k += 1;
}
if k >= n {
let mw = tokens[marker_idx].text.to_lowercase();
return mw != "f";
}
let t = &tokens[k];
if t.kind != TokenKind::Word {
return false;
}
if infrageneric {
return starts_upper(t);
}
if !starts_lower(t) {
return false;
}
if t.text.eq_ignore_ascii_case("ex")
|| t.text.eq_ignore_ascii_case("and")
|| t.text.eq_ignore_ascii_case("et")
|| t.text == "y"
{
return false;
}
if token::is_particle(&t.text) {
return false;
}
true
}
fn has_year_token(tokens: &[Token], from: usize, to: usize) -> bool {
let mut i = from;
while i < to {
let t = &tokens[i];
if t.kind == TokenKind::Number
&& t.text.chars().count() == 4
&& matches!(t.text.chars().next(), Some('1') | Some('2'))
{
return true;
}
i += 1;
}
false
}
fn skip_paren_author_block(tokens: &[Token], open_idx: usize) -> Option<usize> {
let n = tokens.len();
let mut depth = 1i32;
let mut j = open_idx + 1;
while j < n && depth > 0 {
let k = tokens[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 = &tokens[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);
let is_infra_marker = rank_markers::match_infraspecific_allow_notho(w).is_some();
if is_infra_marker && has_epithet_after_marker(tokens, j, false) {
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 is_family_shape(s: &str) -> bool {
let lower = s.to_lowercase();
lower.ends_with("aceae") || lower.ends_with("oideae")
}
pub fn is_apostrophe_particle(s: &str) -> bool {
looks_like_apostrophe_particle(s)
}
fn looks_like_apostrophe_particle(s: &str) -> bool {
let Some(apo) = s.find('\'') else {
return false;
};
if apo < 1 {
return false;
}
match s[apo + 1..].chars().next() {
Some(c) => c.is_uppercase(),
None => false,
}
}
fn is_all_upper(s: &str) -> bool {
let mut any = false;
for c in s.chars() {
if c.is_alphabetic() {
any = true;
if !c.is_uppercase() {
return false;
}
}
}
any
}
#[cfg(test)]
mod tests {
use super::*;
use crate::model::Rank;
use crate::token::tokenize;
fn ctx(requested_rank: Option<Rank>) -> ParseContext {
ParseContext::new("test".to_string(), None, requested_rank, None)
}
fn boundary(input: &str, requested_rank: Option<Rank>) -> usize {
let tokens = tokenize(input);
find_boundary(&tokens, &ctx(requested_rank))
}
#[test]
fn simple_binomial_with_no_author_returns_full_length() {
assert_eq!(boundary("Abies alba", None), 2);
}
#[test]
fn trinomial_with_zoological_author_and_year_returns_boundary_before_author() {
assert_eq!(boundary("Vulpes vulpes silaceus Miller, 1907", None), 3);
}
#[test]
fn subgenus_with_trailing_epithet_is_kept_in_name_rule1() {
assert_eq!(boundary("Amnicola (Amnicola) dubrueilliana", None), 5);
}
#[test]
fn subgenus_with_trailing_epithet_and_trailing_author_rule1() {
assert_eq!(boundary("Amnicola (Amnicola) dubrueilliana Smith", None), 5);
}
#[test]
fn trailing_epithet_overrides_abbreviated_paren_rule1_over_rule2() {
assert_eq!(boundary("Phalaena (Tin.) guttella Fab.", None), 6);
}
#[test]
fn abbreviated_parenthesised_word_is_basionym_author_rule2() {
assert_eq!(boundary("Thliphthisa (Griseb.) Caputo", None), 1);
}
#[test]
fn nothing_follows_parens_is_subgenus_rule3() {
assert_eq!(boundary("Arrhoges (Antarctohoges)", None), 4);
}
#[test]
fn nominotypical_repeat_is_subgenus_rule4() {
assert_eq!(boundary("Morea (Morea) Link", None), 4);
}
#[test]
fn requested_infrageneric_rank_makes_paren_a_subgenus_rule5() {
assert_eq!(boundary("Genus (Section) Author", Some(Rank::Subgenus)), 4);
}
#[test]
fn without_requested_infrageneric_rank_same_input_is_basionym_author() {
assert_eq!(boundary("Genus (Section) Author", None), 1);
}
#[test]
fn year_outside_parens_is_subgenus_zoological_form_rule6() {
assert_eq!(boundary("Dicromita (Pterodicromita) Fowler, 1925", None), 4);
}
#[test]
fn no_year_no_nominotypical_makes_paren_a_basionym_author_rule7() {
assert_eq!(boundary("Kyphocarpa (Fenzl) Lopr.", None), 1);
}
#[test]
fn trinomial_with_infraspecific_rank_marker_is_kept_in_name() {
assert_eq!(boundary("Abies alba subsp. alba", None), 5);
}
#[test]
fn trinomial_with_infraspecific_rank_marker_and_trailing_author() {
assert_eq!(boundary("Abies alba subsp. alba Mill.", None), 5);
}
#[test]
fn single_letter_abbreviated_genus_is_kept_in_name() {
assert_eq!(boundary("B. alba", None), 3);
}
#[test]
fn two_to_four_letter_abbreviated_genus_followed_by_lowercase_epithet() {
assert_eq!(boundary("Mo. bella", None), 3);
}
#[test]
fn two_to_four_letter_genus_not_abbreviated_when_next_word_is_uppercase() {
assert_eq!(boundary("Mo. Bing", None), 1);
}
#[test]
fn mid_name_author_before_infrageneric_marker_is_consumed() {
assert_eq!(boundary("Centaurea L. subg. Jacea", None), 6);
}
#[test]
fn missing_genus_placeholder_question_mark_is_kept_in_name() {
assert_eq!(boundary("? gryphoides", None), 2);
}
#[test]
fn empty_token_list_returns_zero() {
assert_eq!(find_boundary(&[], &ctx(None)), 0);
}
#[test]
fn is_apostrophe_particle_recognises_apostrophe_followed_by_uppercase() {
assert!(is_apostrophe_particle("d'Urv"));
assert!(!is_apostrophe_particle("d'urville"));
assert!(!is_apostrophe_particle("'Urv"));
assert!(!is_apostrophe_particle("Durv"));
assert!(!is_apostrophe_particle("Urv'"));
}
#[test]
fn mid_name_author_end_matches_the_centaurea_case() {
let tokens = tokenize("Centaurea L. subg. Jacea");
assert_eq!(mid_name_author_end(&tokens, 1), Some(3));
}
#[test]
fn particle_triggered_mid_name_author() {
assert_eq!(boundary("Cirsium creticum d'Urv. subsp. creticum", None), 7);
}
#[test]
fn sp_with_strain_code_stays_in_name() {
assert_eq!(boundary("Lepidoptera sp. JGP0404", None), 4);
}
#[test]
fn genus_all_caps_shouted_binomial() {
assert_eq!(boundary("CHIONE ELEVATA", None), 2);
}
}