use crate::model::{NomCode, Rank};
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 t.text == "ex"
&& tokens
.get(i + 1)
.is_some_and(|next| next.kind == TokenKind::Word && starts_upper(next))
{
return i;
}
if t.text == "ex" && crate::pipeline::name_tokens::is_ex_grege(tokens, i) {
i += 2;
if i < n && tokens[i].kind == TokenKind::Dot {
i += 1;
}
continue;
}
if w.eq_ignore_ascii_case("cf")
|| w.eq_ignore_ascii_case("aff")
|| w.eq_ignore_ascii_case("nr")
|| w.eq_ignore_ascii_case("sp")
|| w.eq_ignore_ascii_case("spp")
|| 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("spp")
|| w.eq_ignore_ascii_case("spec");
let is_cf_or_aff = w.eq_ignore_ascii_case("cf")
|| w.eq_ignore_ascii_case("aff")
|| w.eq_ignore_ascii_case("nr");
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 tokens
.get(i)
.is_some_and(|t| t.kind == TokenKind::Word && starts_upper(t))
{
return n;
}
}
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 have_epithet && is_capitalised_autonym(tokens, i) {
i += 1;
} else if let Some(len) = single_letter_designation(tokens, i) {
i += len;
have_epithet = true;
} else if have_epithet && i < n && tokens[i].kind == TokenKind::Number {
i += 1;
if i + 1 == n
&& tokens[i].kind == TokenKind::Word
&& starts_lower(&tokens[i])
{
i += 1;
}
} else if have_epithet
&& i + 1 == n
&& tokens[i].kind == TokenKind::Word
&& is_strain_code(&tokens[i].text)
{
i += 1;
}
continue;
}
if after_genus
&& !have_epithet
&& !after_subgenus
&& rank_markers::match_infrageneric_allow_notho(w).is_some()
&& !is_epithet_before_dated_author(tokens, i)
{
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 after_genus
&& !have_epithet
&& w.chars().count() == 1
&& starts_lower(t)
&& !matches!(w, "v" | "d" | "y")
&& (i + 1 == n
|| (tokens[i + 1].kind == TokenKind::Word && starts_upper(&tokens[i + 1])))
{
name_words += 1;
have_epithet = true;
i += 1;
continue;
}
let weak_particle = is_weak_particle_before_surname(tokens, i);
if token::is_particle(&t.text)
|| looks_like_apostrophe_particle(&t.text)
|| weak_particle
{
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 after_genus && !have_epithet && is_capitalised_old_epithet(tokens, i, genus_text) {
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 epithet_at = |k: usize| {
tokens.get(k).is_some_and(|nx| {
nx.kind == TokenKind::Word
&& starts_lower(nx)
&& !token::is_particle(&nx.text)
})
};
let trailing_is_epithet = epithet_at(after_paren)
|| (next.is_some_and(|nx| nx.kind == TokenKind::HybridMark)
&& epithet_at(after_paren + 1))
|| is_capitalised_old_epithet(tokens, after_paren, genus_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 rank_requests_genus = ctx
.requested_rank
.is_some_and(|r| r == Rank::Genus || r.is_suprageneric());
let code = ctx.requested_code;
let subgenus = if trailing_is_epithet {
true
} else if abbreviated {
false
} else if !has_trailing
|| nominotypical
|| rank_requests_infragen
|| code == Some(NomCode::Zoological)
{
true
} else if code == Some(NomCode::Botanical) || rank_requests_genus {
false
} else {
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 is_strain_code(s: &str) -> bool {
s.chars().count() >= 3
&& s.chars().any(|c| c.is_alphabetic())
&& s.chars().any(|c| c.is_ascii_digit())
}
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)
}
pub(crate) 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) && !is_weak_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 is_weak_particle(word: &str) -> bool {
matches!(word, "den" | "dem" | "ver")
}
fn is_weak_particle_before_surname(tokens: &[Token], i: usize) -> bool {
let initials_after_comma = tokens
.get(i + 2)
.is_some_and(|c| c.kind == TokenKind::Comma)
&& tokens.get(i + 3).is_some_and(|t| {
t.kind == TokenKind::Word && t.text.chars().count() == 1 && starts_upper(t)
})
&& tokens.get(i + 4).is_some_and(|d| d.kind == TokenKind::Dot);
is_weak_particle(&tokens[i].text)
&& tokens
.get(i + 1)
.is_some_and(|nx| nx.kind == TokenKind::Word && starts_upper(nx))
&& !initials_after_comma
}
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 {
if continues_author_span(tokens, j, from) {
j += 1;
continue;
}
let t = &tokens[j];
if t.kind == TokenKind::Word {
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_allow_notho(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;
}
None
}
pub(crate) fn is_epithet_before_dated_author(tokens: &[Token], i: usize) -> bool {
if !matches!(tokens[i].text.as_str(), "ser" | "subser") {
return false;
}
if i + 1 == tokens.len() {
return true;
}
let author = tokens
.get(i + 1)
.is_some_and(|t| t.kind == TokenKind::Word && starts_upper(t));
let mut k = i + 2;
if tokens.get(k).is_some_and(|t| t.kind == TokenKind::Comma) {
k += 1;
}
author
&& tokens
.get(k)
.is_some_and(|t| has_year_token(std::slice::from_ref(t), 0, 1))
}
pub(crate) fn is_capitalised_old_epithet(tokens: &[Token], k: usize, genus: Option<&str>) -> bool {
let Some(t) = tokens.get(k) else {
return false;
};
let marker_at = k + 1;
t.kind == TokenKind::Word
&& starts_upper(t)
&& t.text.chars().count() >= 3
&& t.text.chars().skip(1).all(|c| c.is_lowercase())
&& !genus.is_some_and(|g| eq_ignore_case(g, &t.text))
&& tokens.get(marker_at).is_some_and(|m| {
m.kind == TokenKind::Word
&& m.text != "f"
&& rank_markers::match_infraspecific_allow_notho(strip_dot(&m.text)).is_some()
})
&& has_epithet_after_marker(tokens, marker_at, false)
}
pub(crate) fn is_capitalised_autonym(tokens: &[Token], k: usize) -> bool {
tokens.get(k).is_some_and(|t| {
t.kind == TokenKind::Word
&& starts_upper(t)
&& t.text.chars().count() > 1
&& tokens[..k].iter().any(|e| {
e.kind == TokenKind::Word && starts_lower(e) && eq_ignore_case(&e.text, &t.text)
})
})
}
pub(crate) fn continues_author_span(tokens: &[Token], j: usize, from: usize) -> bool {
let t = &tokens[j];
let inner = j > from || (j > 0 && tokens[j - 1].kind == TokenKind::CloseParen);
match t.kind {
TokenKind::Word => {
starts_upper(t)
|| token::is_particle(&t.text)
|| looks_like_apostrophe_particle(&t.text)
|| t.text.eq_ignore_ascii_case("al")
|| (t.text == "t"
&& j > 0
&& tokens[j - 1].text == "'"
&& next_word_starts_upper(tokens, j + 1))
|| (inner
&& matches!(t.text.as_str(), "ex" | "et" | "and")
&& next_word_starts_author(tokens, j + 1))
|| (inner && t.text == "f" && filius_before_marker_or_ex(tokens, j))
}
TokenKind::Dot | TokenKind::Ampersand | TokenKind::Comma => true,
TokenKind::Other => {
t.text == "'"
|| (inner
&& t.text == "-"
&& tokens[j - 1].kind == TokenKind::Dot
&& next_word_starts_upper(tokens, j + 1))
}
TokenKind::Number => {
inner
&& t.text.chars().count() == 4
&& matches!(t.text.chars().next(), Some('1') | Some('2'))
}
_ => false,
}
}
fn next_word_starts_author(tokens: &[Token], mut j: usize) -> bool {
while tokens.get(j).is_some_and(|t| t.kind == TokenKind::Dot) {
j += 1;
}
tokens.get(j).is_some_and(|t| {
t.kind == TokenKind::Word
&& (starts_upper(t) || token::is_particle(&t.text) || t.text == "al")
})
}
fn next_word_starts_upper(tokens: &[Token], mut j: usize) -> bool {
while tokens.get(j).is_some_and(|t| t.kind == TokenKind::Dot) {
j += 1;
}
tokens
.get(j)
.is_some_and(|t| t.kind == TokenKind::Word && starts_upper(t))
}
fn filius_before_marker_or_ex(tokens: &[Token], f_idx: usize) -> bool {
let mut k = f_idx + 1;
if tokens.get(k).is_some_and(|t| t.kind == TokenKind::Dot) {
k += 1;
}
tokens.get(k).is_some_and(|t| match t.kind {
TokenKind::Ampersand | TokenKind::Comma => true,
TokenKind::Word => {
matches!(t.text.as_str(), "ex" | "et" | "and")
|| (t.text != "f"
&& rank_markers::match_infraspecific_allow_notho(strip_dot(&t.text)).is_some())
}
_ => false,
})
}
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 && tokens[k].kind == TokenKind::HybridMark && k + 1 < n {
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 single_letter_designation(tokens, k).is_some()
&& (k + 1 == n
|| (tokens[k + 1].kind != TokenKind::Dot && next_word_starts_upper(tokens, k + 1)))
{
return true;
}
if is_capitalised_autonym(tokens, k) {
return true;
}
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; let from = j;
while j < n {
if continues_author_span(tokens, j, from) {
j += 1;
continue;
}
let t = &tokens[j];
if t.kind == TokenKind::Word {
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;
}
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
}
pub(crate) fn single_letter_designation(tokens: &[Token], i: usize) -> Option<usize> {
let is_letter = |t: &Token| {
t.kind == TokenKind::Word && t.text.len() == 1 && t.text.as_bytes()[0].is_ascii_alphabetic()
};
if tokens.get(i).is_some_and(is_letter) {
let lower_word_at = |j: usize| {
tokens
.get(j)
.is_some_and(|t| t.kind == TokenKind::Word && starts_lower(t))
};
let dot_next = tokens.get(i + 1).is_some_and(|t| t.kind == TokenKind::Dot);
let epithet_follows = lower_word_at(i + 1) || (dot_next && lower_word_at(i + 2));
return (!epithet_follows).then_some(1);
}
if tokens
.get(i)
.is_some_and(|t| t.kind == TokenKind::OpenParen)
&& tokens.get(i + 1).is_some_and(is_letter)
&& tokens
.get(i + 2)
.is_some_and(|t| t.kind == TokenKind::CloseParen)
{
return Some(3);
}
None
}
#[cfg(test)]
mod tests {
use super::*;
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);
}
}