use std::sync::LazyLock;
use regex::Regex;
use unicode_normalization::UnicodeNormalization;
use crate::model::enums::{NamePart, NameType, NomCode, Rank};
use crate::model::name::{Authorship, CombinedAuthorship, ParsedName};
use crate::model::Informal;
use crate::unicode::java_trim;
const HYBRID_MARKER: char = '×';
const NOTHO_PREFIX: &str = "notho";
const ET_AL: &str = "et al.";
const ITALICS_OPEN: &str = "<i>";
const ITALICS_CLOSE: &str = "</i>";
static AL: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"^al\.?$").unwrap());
static PHRASE_SPECIES_MARKER: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"(?i)^(?:(?:species|spec|sp)(?-u:\b)|(?:n_)?sp_|n_gen(?-u:\b)).*$").unwrap()
});
static PHRASE_AUTHOR_TAIL: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"^[\p{Lu}](?:\.[\p{Lu}])*\..+$").unwrap());
struct Flags {
hybrid_marker: bool,
rank_marker: bool,
authorship: bool,
genus_for_infrageneric: bool,
infrageneric: bool,
decomposition: bool,
ascii_only: bool,
show_qualifier: bool,
show_indet: bool,
nom_note: bool,
show_sensu: bool,
show_cultivar: bool,
show_phrase: bool,
show_strain: bool,
show_extra_authorship: bool,
html: bool,
}
impl Informal {
pub fn canonical_name(&self) -> String {
let pn = ParsedName {
type_: NameType::Informal,
rank: self.rank,
code: self.code,
phrase: self.phrase.clone(),
genus: (self.taxon_rank == Rank::Genus).then(|| self.taxon.clone()),
uninomial: (self.taxon_rank != Rank::Genus).then(|| self.taxon.clone()),
..ParsedName::default()
};
pn.canonical_name_without_authorship()
.unwrap_or_else(|| self.taxon.clone())
}
}
impl ParsedName {
pub fn canonical_name(&self) -> Option<String> {
build_name(
self,
&Flags {
hybrid_marker: true,
rank_marker: true,
authorship: true,
genus_for_infrageneric: true,
infrageneric: false,
decomposition: false,
ascii_only: false,
show_qualifier: true,
show_indet: true,
nom_note: false,
show_sensu: false,
show_cultivar: true,
show_phrase: true,
show_strain: true,
show_extra_authorship: false,
html: false,
},
)
}
pub fn canonical_name_without_authorship(&self) -> Option<String> {
build_name(
self,
&Flags {
hybrid_marker: true,
rank_marker: true,
authorship: false,
genus_for_infrageneric: true,
infrageneric: false,
decomposition: false,
ascii_only: false,
show_qualifier: true,
show_indet: true,
nom_note: false,
show_sensu: false,
show_cultivar: true,
show_phrase: true,
show_strain: true,
show_extra_authorship: false,
html: false,
},
)
}
pub fn canonical_name_minimal(&self) -> Option<String> {
build_name(
self,
&Flags {
hybrid_marker: false,
rank_marker: false,
authorship: false,
genus_for_infrageneric: false,
infrageneric: false,
decomposition: true,
ascii_only: true,
show_qualifier: false,
show_indet: false,
nom_note: false,
show_sensu: false,
show_cultivar: false,
show_phrase: false,
show_strain: false,
show_extra_authorship: false,
html: false,
},
)
}
pub fn canonical_name_complete(&self) -> Option<String> {
build_name(self, &complete_flags(false))
}
pub fn canonical_name_complete_html(&self) -> Option<String> {
build_name(self, &complete_flags(true))
}
pub fn authorship_complete(&self) -> Option<String> {
let mut sb = String::new();
append_authorship_parts(
&mut sb,
&self.basionym_authorship,
&self.combination_authorship,
self.sanctioning_author.as_deref(),
true,
self.code,
);
if sb.is_empty() {
None
} else {
Some(sb)
}
}
pub fn has_generic_authorship(&self) -> bool {
self.generic_authorship
.as_ref()
.is_some_and(CombinedAuthorship::has_authorship)
}
pub fn has_specific_authorship(&self) -> bool {
self.specific_authorship
.as_ref()
.is_some_and(CombinedAuthorship::has_authorship)
}
pub fn has_epithet_qualifier(&self, part: NamePart) -> bool {
self.epithet_qualifier
.as_ref()
.is_some_and(|m| m.contains_key(&part))
}
pub fn is_hybrid_name(&self) -> bool {
self.notho.as_ref().is_some_and(|s| !s.is_empty())
}
pub fn is_phrase_name(&self) -> bool {
self.phrase.as_ref().is_some_and(|p| !p.is_empty())
}
}
fn complete_flags(html: bool) -> Flags {
Flags {
hybrid_marker: true,
rank_marker: true,
authorship: true,
genus_for_infrageneric: true,
infrageneric: true,
decomposition: true,
ascii_only: false,
show_qualifier: true,
show_indet: true,
nom_note: true,
show_sensu: true,
show_cultivar: true,
show_phrase: true,
show_strain: true,
show_extra_authorship: true,
html,
}
}
fn has_notho(n: &ParsedName, part: NamePart) -> bool {
n.notho.as_ref().is_some_and(|s| s.contains(&part))
}
fn is_unknown(r: Rank) -> bool {
r.other_or_unranked()
}
fn is_infraspecific_marker(r: Rank) -> bool {
r.is_infraspecific() && !r.is_uncomparable()
}
fn append_in_italics(sb: &mut String, x: &str, html: bool) {
if html {
sb.push_str(ITALICS_OPEN);
sb.push_str(x);
sb.push_str(ITALICS_CLOSE);
} else {
sb.push_str(x);
}
}
fn append_if_not_empty(sb: &mut String, to_append: &str) {
if !sb.is_empty() {
sb.push_str(to_append);
}
}
fn phrase_leads_with_species_marker(n: &ParsedName) -> bool {
n.is_phrase_name()
&& PHRASE_SPECIES_MARKER.is_match(java_trim(n.phrase.as_deref().unwrap_or("")))
}
fn phrase_leads_with_rank_marker(n: &ParsedName) -> bool {
let Some(marker) = n.rank.marker() else {
return false;
};
let phrase = java_trim(n.phrase.as_deref().unwrap_or(""));
let Some(lead) = phrase.split_whitespace().next() else {
return false;
};
lead.trim_end_matches('.')
.eq_ignore_ascii_case(marker.trim_end_matches('.'))
}
fn append_rank_marker(
sb: &mut String,
rank: Rank,
if_rank: Option<fn(Rank) -> bool>,
notho_prefix: bool,
) -> bool {
if let Some(marker) = rank.marker() {
if if_rank.is_none_or(|f| f(rank)) {
if notho_prefix {
sb.push_str(NOTHO_PREFIX);
}
sb.push_str(marker);
return true;
}
}
false
}
fn append_genus(
sb: &mut String,
n: &ParsedName,
hybrid_marker: bool,
show_qualifier: bool,
html: bool,
) {
if show_qualifier && n.has_epithet_qualifier(NamePart::Generic) {
sb.push_str(qualifier(n, NamePart::Generic));
sb.push(' ');
}
if hybrid_marker && has_notho(n, NamePart::Generic) {
sb.push(HYBRID_MARKER);
sb.push(' ');
}
append_in_italics(sb, n.genus.as_deref().unwrap_or(""), html);
}
fn append_infraspecific(
sb: &mut String,
n: &ParsedName,
hybrid_marker: bool,
show_qualifier: bool,
rank_marker: bool,
force_rank_marker: bool,
html: bool,
) {
sb.push(' ');
if show_qualifier && n.has_epithet_qualifier(NamePart::Infraspecific) {
sb.push_str(qualifier(n, NamePart::Infraspecific));
sb.push(' ');
}
if hybrid_marker && has_notho(n, NamePart::Infraspecific) {
if rank_marker && is_infraspecific_marker(n.rank) {
sb.push_str("notho");
} else {
sb.push(HYBRID_MARKER);
sb.push(' ');
}
}
#[allow(clippy::collapsible_if)]
if force_rank_marker
|| (rank_marker
&& (n.code != Some(NomCode::Zoological)
|| n.rank != Rank::Subspecies
|| n.is_hybrid_name()))
{
if append_rank_marker(sb, n.rank, Some(is_infraspecific_marker), false)
&& n.infraspecific_epithet.is_some()
{
sb.push(' ');
}
}
if let Some(ie) = &n.infraspecific_epithet {
append_in_italics(sb, ie, html);
}
}
fn qualifier(n: &ParsedName, part: NamePart) -> &str {
n.epithet_qualifier
.as_ref()
.and_then(|m| m.get(&part))
.map(String::as_str)
.unwrap_or("")
}
fn join_authors(authors: &[String], max_authors: Option<usize>) -> String {
if let Some(max) = max_authors {
if authors.len() > max {
return format!("{} {}", authors[0], ET_AL);
}
}
if authors.len() > 1 {
let last = &authors[authors.len() - 1];
let end = if AL.is_match(last) {
format!(" {ET_AL}")
} else {
format!(" & {last}")
};
return format!("{}{}", authors[..authors.len() - 1].join(", "), end);
}
authors.join(", ")
}
fn append_authorship(
sb: &mut String,
auth: &Authorship,
include_year: bool,
code: Option<NomCode>,
) {
if !auth.exists() {
return;
}
let mut authors_appended = false;
let max = if code == Some(NomCode::Bacterial) {
Some(2)
} else {
None
};
if !auth.ex_authors.is_empty() {
sb.push_str(&join_authors(&auth.ex_authors, max));
sb.push_str(" ex ");
authors_appended = true;
}
if !auth.authors.is_empty() {
sb.push_str(&join_authors(&auth.authors, max));
authors_appended = true;
}
if include_year {
if let Some(year) = &auth.year {
if authors_appended {
if code != Some(NomCode::Bacterial) {
sb.push(',');
}
sb.push(' ');
}
sb.push_str(year);
}
if let Some(iy) = &auth.imprint_year {
sb.push_str(" [");
sb.push_str(iy);
sb.push(']');
}
}
}
fn append_authorship_parts(
sb: &mut String,
basionym: &Authorship,
combination: &Authorship,
sanctioning: Option<&str>,
include_year: bool,
code: Option<NomCode>,
) {
let orig_len = sb.len();
if basionym.exists() {
sb.push('(');
append_authorship(sb, basionym, include_year, code);
sb.push(')');
}
if combination.exists() {
if orig_len < sb.len() {
sb.push(' ');
}
append_authorship(sb, combination, include_year, code);
if let Some(sanct) = sanctioning {
sb.push_str(" : ");
sb.push_str(sanct);
}
}
}
fn append_name_authorship(sb: &mut String, n: &ParsedName, include_year: bool) {
append_authorship_parts(
sb,
&n.basionym_authorship,
&n.combination_authorship,
n.sanctioning_author.as_deref(),
include_year,
n.code,
);
}
fn append_combined_authorship(
sb: &mut String,
c: &CombinedAuthorship,
include_year: bool,
code: Option<NomCode>,
) {
append_authorship_parts(
sb,
&c.basionym_authorship,
&c.combination_authorship,
c.sanctioning_author.as_deref(),
include_year,
code,
);
}
fn decompose(x: &str) -> String {
let mut out = String::with_capacity(x.len());
for c in x.chars() {
match c {
'æ' => out.push_str("ae"),
'Æ' => out.push_str("Ae"),
'œ' => out.push_str("oe"),
'Œ' => out.push_str("Oe"),
'IJ' => out.push_str("Ij"),
'ij' => out.push_str("ij"),
'Lj' => out.push_str("Lj"),
'lj' => out.push_str("lj"),
'ȸ' => out.push_str("db"),
'ȹ' => out.push_str("qp"),
'ß' => out.push_str("ss"),
'st' => out.push_str("st"),
'ſt' => out.push_str("ft"),
'ff' => out.push_str("ff"),
'fi' => out.push_str("fi"),
'fl' => out.push_str("fl"),
'ffi' => out.push_str("ffi"),
'ffl' => out.push_str("ffl"),
other => out.push(other),
}
}
out
}
fn replace_special_cases(x: &str) -> String {
let mut out = String::with_capacity(x.len());
for c in x.chars() {
match c {
'ß' => out.push_str("ss"),
'ſ' => out.push('s'),
'Æ' => out.push_str("AE"),
'æ' => out.push_str("ae"),
'Ð' => out.push('D'),
'đ' => out.push('d'),
'ð' => out.push('d'),
'Ø' => out.push('O'),
'ø' => out.push('o'),
'Œ' => out.push_str("OE"),
'œ' => out.push_str("oe"),
'Ŧ' => out.push('T'),
'ŧ' => out.push('t'),
'Ł' => out.push('L'),
'ł' => out.push('l'),
other => out.push(other),
}
}
out
}
static MARK: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"\p{M}").unwrap());
fn fold_to_ascii(x: &str) -> String {
let x = replace_special_cases(x);
let nfd: String = x.nfd().collect();
MARK.replace_all(&nfd, "").into_owned()
}
fn build_name(n: &ParsedName, f: &Flags) -> Option<String> {
let mut sb = String::new();
let mut html = f.html;
let mut authorship = f.authorship;
let mut candidate_italics = false;
if n.candidatus {
sb.push('"');
if html {
sb.push_str(ITALICS_OPEN);
candidate_italics = true;
html = false;
}
sb.push_str("Candidatus ");
}
if let Some(uninomial) = &n.uninomial {
if f.hybrid_marker && has_notho(n, NamePart::Generic) {
sb.push(HYBRID_MARKER);
sb.push(' ');
}
append_in_italics(&mut sb, uninomial, html);
} else {
if let Some(infrageneric_epithet) = &n.infrageneric_epithet {
if (is_unknown(n.rank) && n.specific_epithet.is_none())
|| n.rank.is_infrageneric_strictly()
{
let mut show_infra_gen = true;
if n.genus.is_some() && f.genus_for_infrageneric {
append_genus(&mut sb, n, f.hybrid_marker, f.show_qualifier, html);
if f.show_extra_authorship && n.has_generic_authorship() {
sb.push(' ');
append_combined_authorship(
&mut sb,
n.generic_authorship.as_ref().unwrap(),
true,
n.code,
);
}
sb.push(' ');
if n.code == Some(NomCode::Zoological) {
sb.push('(');
if f.hybrid_marker && has_notho(n, NamePart::Infrageneric) {
sb.push(HYBRID_MARKER);
sb.push(' ');
}
append_in_italics(&mut sb, infrageneric_epithet, html);
sb.push(')');
show_infra_gen = false;
}
}
if show_infra_gen {
if f.rank_marker {
if append_rank_marker(
&mut sb,
n.rank,
None,
f.hybrid_marker && has_notho(n, NamePart::Infrageneric),
) {
sb.push(' ');
}
}
append_in_italics(&mut sb, infrageneric_epithet, html);
}
} else {
if n.genus.is_some() {
append_genus(&mut sb, n, f.hybrid_marker, f.show_qualifier, html);
}
if f.infrageneric {
sb.push_str(" (");
append_in_italics(&mut sb, infrageneric_epithet, html);
sb.push(')');
}
}
} else if n.genus.is_some() {
append_genus(&mut sb, n, f.hybrid_marker, f.show_qualifier, html);
}
if n.specific_epithet.is_none() {
if (f.show_indet && n.genus.is_some() && n.cultivar_epithet.is_none())
|| (f.show_phrase && n.is_phrase_name())
{
if n.rank.is_species_or_below() {
if n.rank.is_infraspecific() {
if !phrase_leads_with_rank_marker(n) {
append_infraspecific(
&mut sb,
n,
f.hybrid_marker,
f.show_qualifier,
f.rank_marker,
true,
html,
);
}
} else if !phrase_leads_with_species_marker(n) {
sb.push(' ');
sb.push_str(n.rank.marker().unwrap_or(""));
}
authorship = false;
}
} else if n.infraspecific_epithet.is_some() {
append_infraspecific(
&mut sb,
n,
f.hybrid_marker,
f.show_qualifier,
f.rank_marker,
false,
html,
);
}
} else {
sb.push(' ');
if f.show_qualifier && n.has_epithet_qualifier(NamePart::Specific) {
sb.push_str(qualifier(n, NamePart::Specific));
sb.push(' ');
}
if f.hybrid_marker && has_notho(n, NamePart::Specific) {
sb.push(HYBRID_MARKER);
sb.push(' ');
}
append_in_italics(&mut sb, n.specific_epithet.as_deref().unwrap_or(""), html);
if f.show_extra_authorship && n.has_specific_authorship() {
sb.push(' ');
append_combined_authorship(
&mut sb,
n.specific_authorship.as_ref().unwrap(),
true,
n.code,
);
}
if n.infraspecific_epithet.is_none() {
if f.show_indet
&& n.rank.is_infraspecific()
&& (n.rank.is_restricted_to_code() != Some(NomCode::Cultivars)
|| n.cultivar_epithet.is_none())
{
if n.rank == Rank::Subspecies {
sb.push_str(" ssp.");
} else {
sb.push(' ');
sb.push_str(n.rank.marker().unwrap_or("null"));
}
authorship = false;
}
} else {
if n.is_autonym() && n.code == Some(NomCode::Botanical) {
if authorship && n.has_authorship() {
sb.push(' ');
append_name_authorship(&mut sb, n, true);
}
authorship = false;
}
append_infraspecific(
&mut sb,
n,
f.hybrid_marker,
f.show_qualifier,
f.rank_marker,
false,
html,
);
}
}
}
if n.candidatus {
if candidate_italics {
sb.push_str(ITALICS_CLOSE);
}
sb.push('"');
}
let cultivar_shown = f.show_cultivar && n.cultivar_epithet.is_some();
if authorship && n.has_authorship() && !cultivar_shown {
sb.push(' ');
append_name_authorship(&mut sb, n, true);
}
if f.show_strain && n.phrase.is_some() && !n.is_phrase_name() {
sb.push(' ');
sb.push_str(n.phrase.as_deref().unwrap_or(""));
}
if f.show_cultivar {
if let Some(cultivar) = &n.cultivar_epithet {
if n.rank == Rank::CultivarGroup {
sb.push(' ');
sb.push_str(cultivar);
sb.push_str(" Group");
} else if n.rank == Rank::Grex {
sb.push(' ');
sb.push_str(cultivar);
sb.push_str(" gx");
} else {
sb.push_str(" '");
sb.push_str(cultivar);
sb.push('\'');
}
if authorship && n.has_authorship() {
sb.push(' ');
append_name_authorship(&mut sb, n, true);
}
}
}
if f.show_phrase && n.is_phrase_name() {
let phrase_full = n.phrase.as_deref().unwrap_or("");
let mut phrase = phrase_full;
if let Some(last_close) = phrase_full.rfind(')') {
if last_close < phrase_full.len() - 1 {
let tail = java_trim(&phrase_full[last_close + 1..]);
if PHRASE_AUTHOR_TAIL.is_match(tail) {
phrase = &phrase_full[..last_close + 1];
}
}
}
append_if_not_empty(&mut sb, " ");
sb.push_str(phrase);
}
if f.show_sensu {
if let Some(tn) = &n.taxonomic_note {
append_if_not_empty(&mut sb, " ");
sb.push_str(tn);
}
}
if f.nom_note {
if let Some(nn) = &n.nomenclatural_note {
append_if_not_empty(&mut sb, ", ");
sb.push_str(nn);
}
}
let mut name = java_trim(&sb).to_string();
if f.decomposition {
name = decompose(&name);
}
if f.ascii_only {
name = fold_to_ascii(&name);
}
let name = java_trim(&name);
if name.is_empty() {
None
} else {
Some(name.to_string())
}
}
#[cfg(test)]
mod tests {
use crate::parse_name as parse;
fn p(input: &str) -> crate::model::ParsedName {
parse(input, None, None, None).unwrap_or_else(|_| panic!("should parse: {input:?}"))
}
#[test]
fn informal_canonical_rebuilds_the_parser_rendering() {
use crate::model::enums::Rank;
use crate::model::Informal;
let inf = |taxon: &str, taxon_rank, rank, phrase: Option<&str>| Informal {
taxon: taxon.into(),
taxon_rank,
rank,
phrase: phrase.map(str::to_string),
code: None,
};
assert_eq!(
inf(
"Rhizobium",
Rank::Genus,
Rank::Species,
Some("sp. RMCC TR1811")
)
.canonical_name(),
"Rhizobium sp. RMCC TR1811"
);
assert_eq!(
inf("Allium", Rank::Genus, Rank::Species, Some("1")).canonical_name(),
"Allium sp. 1"
);
assert_eq!(
inf("Ichneumonidae", Rank::Genus, Rank::Species, None).canonical_name(),
"Ichneumonidae sp."
);
assert_eq!(
inf("Bartonella", Rank::Genus, Rank::Unranked, Some("group")).canonical_name(),
"Bartonella group"
);
}
#[test]
fn basic_binomial_with_author() {
let n = p("Abies alba Mill.");
assert_eq!(n.canonical_name().as_deref(), Some("Abies alba Mill."));
assert_eq!(
n.canonical_name_without_authorship().as_deref(),
Some("Abies alba")
);
assert_eq!(n.canonical_name_minimal().as_deref(), Some("Abies alba"));
assert_eq!(
n.canonical_name_complete().as_deref(),
Some("Abies alba Mill.")
);
assert_eq!(n.authorship_complete().as_deref(), Some("Mill."));
}
#[test]
fn authorless_name_has_no_authorship_string() {
let n = p("Abies alba");
assert_eq!(n.canonical_name().as_deref(), Some("Abies alba"));
assert_eq!(n.authorship_complete(), None);
}
#[test]
fn zoological_subspecies_shows_no_rank_marker() {
let n = p("Vulpes vulpes silaceus Miller, 1907");
assert_eq!(
n.canonical_name().as_deref(),
Some("Vulpes vulpes silaceus Miller, 1907")
);
assert_eq!(
n.canonical_name_without_authorship().as_deref(),
Some("Vulpes vulpes silaceus")
);
assert_eq!(n.authorship_complete().as_deref(), Some("Miller, 1907"));
}
#[test]
fn botanical_autonym_keeps_marker_but_minimal_drops_it() {
let n = p("Acer rubrum var. rubrum");
assert_eq!(
n.canonical_name().as_deref(),
Some("Acer rubrum var. rubrum")
);
assert_eq!(
n.canonical_name_minimal().as_deref(),
Some("Acer rubrum rubrum")
);
}
#[test]
fn botanical_autonym_places_author_after_species_epithet() {
let n = p("Trimezia spathata (Klatt) Baker subsp. spathata");
assert_eq!(
n.canonical_name().as_deref(),
Some("Trimezia spathata (Klatt) Baker subsp. spathata")
);
assert_eq!(
n.canonical_name_without_authorship().as_deref(),
Some("Trimezia spathata subsp. spathata")
);
assert_eq!(n.authorship_complete().as_deref(), Some("(Klatt) Baker"));
}
#[test]
fn infrageneric_botanical_uses_rank_marker_and_minimal_drops_genus() {
let n = p("Astragalus subg. Cercidothrix");
assert_eq!(
n.canonical_name().as_deref(),
Some("Astragalus subgen. Cercidothrix")
);
assert_eq!(n.canonical_name_minimal().as_deref(), Some("Cercidothrix"));
}
#[test]
fn basionym_and_combination_authorship() {
let n = p("Baeomyces rufus (Huds.) Rebent.");
assert_eq!(
n.canonical_name().as_deref(),
Some("Baeomyces rufus (Huds.) Rebent.")
);
assert_eq!(
n.canonical_name_without_authorship().as_deref(),
Some("Baeomyces rufus")
);
assert_eq!(n.authorship_complete().as_deref(), Some("(Huds.) Rebent."));
}
#[test]
fn basionym_parens_with_year() {
let n = p("Oenanthe oenanthe (Linnaeus, 1758)");
assert_eq!(
n.canonical_name().as_deref(),
Some("Oenanthe oenanthe (Linnaeus, 1758)")
);
assert_eq!(n.authorship_complete().as_deref(), Some("(Linnaeus, 1758)"));
}
#[test]
fn sanctioning_author_rendered_with_colon() {
let n = p("Agaricus campestris L. : Fr.");
assert_eq!(
n.canonical_name().as_deref(),
Some("Agaricus campestris L. : Fr.")
);
assert_eq!(n.authorship_complete().as_deref(), Some("L. : Fr."));
}
#[test]
fn notho_genus_hybrid_marker_with_space() {
let n = p("×Agropogon littoralis");
assert_eq!(
n.canonical_name().as_deref(),
Some("× Agropogon littoralis")
);
assert_eq!(
n.canonical_name_minimal().as_deref(),
Some("Agropogon littoralis")
);
}
#[test]
fn notho_species_hybrid_marker() {
let n = p("Salix ×capreola Andersson");
assert_eq!(
n.canonical_name().as_deref(),
Some("Salix × capreola Andersson")
);
assert_eq!(
n.canonical_name_minimal().as_deref(),
Some("Salix capreola")
);
}
#[test]
fn cultivar_epithet_in_single_quotes_and_minimal_drops_it() {
let n = p("Acer campestre 'Elsrijk'");
assert_eq!(
n.canonical_name().as_deref(),
Some("Acer campestre 'Elsrijk'")
);
assert_eq!(
n.canonical_name_minimal().as_deref(),
Some("Acer campestre")
);
}
#[test]
fn candidatus_wraps_in_quotes_with_bacterial_comma_less_year() {
let n = p("Candidatus Nanopelagicus abundans Ghai, 2013");
assert_eq!(
n.canonical_name().as_deref(),
Some("\"Candidatus Nanopelagicus abundans\" Ghai 2013")
);
assert_eq!(n.authorship_complete().as_deref(), Some("Ghai 2013"));
}
#[test]
fn minimal_folds_ligatures_and_diacritics_to_ascii() {
assert_eq!(
p("Læptura").canonical_name_minimal().as_deref(),
Some("Laeptura")
);
assert_eq!(
p("Rübsaamenia excelsa").canonical_name_minimal().as_deref(),
Some("Rubsaamenia excelsa")
);
assert_eq!(p("Læptura").canonical_name().as_deref(), Some("Læptura"));
}
#[test]
fn cultivar_group_indet_mirrors_javas_null_marker_append() {
use crate::model::{ParsedName, Rank};
let pn = ParsedName {
rank: Rank::CultivarGroup,
genus: Some("Aaa".to_string()),
specific_epithet: Some("bbb".to_string()),
..Default::default()
};
assert_eq!(pn.canonical_name().as_deref(), Some("Aaa bbb null"));
assert_eq!(
pn.canonical_name_complete().as_deref(),
Some("Aaa bbb null")
);
}
#[test]
fn complete_html_italicises_name_parts() {
assert_eq!(
p("Abies alba Mill.")
.canonical_name_complete_html()
.as_deref(),
Some("<i>Abies</i> <i>alba</i> Mill.")
);
assert_eq!(
p("Salix ×capreola Andersson")
.canonical_name_complete_html()
.as_deref(),
Some("<i>Salix</i> × <i>capreola</i> Andersson")
);
assert_eq!(
p("Astragalus subg. Cercidothrix")
.canonical_name_complete_html()
.as_deref(),
Some("<i>Astragalus</i> subgen. <i>Cercidothrix</i>")
);
}
}