use serde::Serialize;
use std::collections::{HashMap, HashSet};
use std::sync::LazyLock;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum NameType {
Scientific,
Formula,
Informal,
Placeholder,
Identifier,
Other,
}
impl NameType {
pub fn is_parsable(&self) -> bool {
matches!(self, NameType::Scientific | NameType::Informal)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum NomCode {
Bacterial,
Botanical,
Cultivars,
Phyto,
Virus,
Zoological,
Phylo,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum NamePart {
Generic,
Infrageneric,
Specific,
Infraspecific,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum State {
Complete,
Partial,
None,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum Rank {
Superdomain,
Domain,
Subdomain,
Infradomain,
Empire,
Realm,
Subrealm,
Superkingdom,
Kingdom,
Subkingdom,
Infrakingdom,
Superphylum,
Phylum,
Subphylum,
Infraphylum,
Parvphylum,
Microphylum,
Nanophylum,
Claudius,
Gigaclass,
Megaclass,
Superclass,
Class,
Subclass,
Infraclass,
Subterclass,
Parvclass,
Superdivision,
DivisionZoology,
Subdivision,
Infradivision,
Superlegion,
Legion,
Sublegion,
Infralegion,
Megacohort,
Supercohort,
Cohort,
Subcohort,
Infracohort,
Gigaorder,
Magnorder,
Grandorder,
Mirorder,
Superorder,
Order,
Nanorder,
Hypoorder,
Minorder,
Suborder,
Infraorder,
Parvorder,
SupersectionZoology,
SectionZoology,
SubsectionZoology,
SuperseriesZoology,
SeriesZoology,
SubseriesZoology,
Falanx,
Gigafamily,
Megafamily,
Grandfamily,
Superfamily,
Epifamily,
Family,
Subfamily,
Infrafamily,
Supertribe,
Tribe,
Subtribe,
Infratribe,
SupragenericName,
Supergenus,
Genus,
Subgenus,
Infragenus,
DivisionBotany,
SupersectionBotany,
SectionBotany,
SubsectionBotany,
SuperseriesBotany,
SeriesBotany,
SubseriesBotany,
InfragenericName,
SpeciesAggregate,
Species,
InfraspecificName,
Grex,
Klepton,
Subspecies,
CultivarGroup,
Convariety,
InfrasubspecificName,
Proles,
Natio,
Aberration,
Morph,
Supervariety,
Variety,
Subvariety,
Superform,
Form,
Subform,
Pathovar,
Biovar,
Chemovar,
Morphovar,
Phagovar,
Serovar,
Chemoform,
FormaSpecialis,
Lusus,
Cultivar,
Mutatio,
Strain,
Other,
Unranked,
}
const UNCOMPARABLE_RANKS: [Rank; 6] = [
Rank::SupragenericName,
Rank::InfragenericName,
Rank::InfraspecificName,
Rank::InfrasubspecificName,
Rank::Other,
Rank::Unranked,
];
const LEGACY_RANKS: [Rank; 8] = [
Rank::Morph,
Rank::Aberration,
Rank::Natio,
Rank::Proles,
Rank::Convariety,
Rank::Klepton,
Rank::Falanx,
Rank::Lusus,
];
const MAJOR_RANK_PREFIXES: [&str; 16] = [
"SUPER", "SUBTER", "SUB", "INFRA", "MICRO", "NANO", "GIGA", "MAGN", "GRAND", "MIR", "NAN",
"HYPO", "MIN", "PARV", "MEGA", "EPI",
];
fn strip_major_rank_prefix(name: &str) -> Option<&str> {
for prefix in MAJOR_RANK_PREFIXES {
if let Some(rest) = name.strip_prefix(prefix) {
return Some(rest);
}
}
None
}
fn rank_wire_name(rank: Rank) -> String {
serde_json::to_string(&rank)
.expect("Rank always serializes to a JSON string")
.trim_matches('"')
.to_string()
}
static MAJOR_RANKS: LazyLock<HashMap<Rank, Rank>> = LazyLock::new(|| {
let name_to_rank: HashMap<String, Rank> =
Rank::ALL.iter().map(|&r| (rank_wire_name(r), r)).collect();
let mut map = HashMap::with_capacity(Rank::ALL.len());
for &r in Rank::ALL.iter() {
let major = if r.is_infraspecific() {
Rank::InfraspecificName
} else {
strip_major_rank_prefix(&rank_wire_name(r))
.and_then(|rest| name_to_rank.get(rest))
.copied()
.unwrap_or(r)
};
map.insert(r, major);
}
map.insert(Rank::Nanorder, Rank::Order);
map.insert(Rank::SpeciesAggregate, Rank::Species);
map.insert(Rank::InfragenericName, Rank::Genus);
map.insert(Rank::Superdivision, Rank::DivisionZoology);
map.insert(Rank::Subdivision, Rank::DivisionZoology);
map.insert(Rank::Infradivision, Rank::DivisionZoology);
map
});
static AMBIGUOUS_MARKER: LazyLock<HashSet<Rank>> = LazyLock::new(|| {
let mut ambiguous = HashSet::new();
let mut seen: HashMap<&'static str, Rank> = HashMap::new();
for &r in Rank::ALL.iter() {
if let Some(marker) = r.marker() {
if let Some(&earlier) = seen.get(marker) {
ambiguous.insert(r);
ambiguous.insert(earlier);
} else {
seen.insert(marker, r);
}
}
}
ambiguous
});
impl Rank {
pub const ALL: [Rank; 117] = [
Rank::Superdomain,
Rank::Domain,
Rank::Subdomain,
Rank::Infradomain,
Rank::Empire,
Rank::Realm,
Rank::Subrealm,
Rank::Superkingdom,
Rank::Kingdom,
Rank::Subkingdom,
Rank::Infrakingdom,
Rank::Superphylum,
Rank::Phylum,
Rank::Subphylum,
Rank::Infraphylum,
Rank::Parvphylum,
Rank::Microphylum,
Rank::Nanophylum,
Rank::Claudius,
Rank::Gigaclass,
Rank::Megaclass,
Rank::Superclass,
Rank::Class,
Rank::Subclass,
Rank::Infraclass,
Rank::Subterclass,
Rank::Parvclass,
Rank::Superdivision,
Rank::DivisionZoology,
Rank::Subdivision,
Rank::Infradivision,
Rank::Superlegion,
Rank::Legion,
Rank::Sublegion,
Rank::Infralegion,
Rank::Megacohort,
Rank::Supercohort,
Rank::Cohort,
Rank::Subcohort,
Rank::Infracohort,
Rank::Gigaorder,
Rank::Magnorder,
Rank::Grandorder,
Rank::Mirorder,
Rank::Superorder,
Rank::Order,
Rank::Nanorder,
Rank::Hypoorder,
Rank::Minorder,
Rank::Suborder,
Rank::Infraorder,
Rank::Parvorder,
Rank::SupersectionZoology,
Rank::SectionZoology,
Rank::SubsectionZoology,
Rank::SuperseriesZoology,
Rank::SeriesZoology,
Rank::SubseriesZoology,
Rank::Falanx,
Rank::Gigafamily,
Rank::Megafamily,
Rank::Grandfamily,
Rank::Superfamily,
Rank::Epifamily,
Rank::Family,
Rank::Subfamily,
Rank::Infrafamily,
Rank::Supertribe,
Rank::Tribe,
Rank::Subtribe,
Rank::Infratribe,
Rank::SupragenericName,
Rank::Supergenus,
Rank::Genus,
Rank::Subgenus,
Rank::Infragenus,
Rank::DivisionBotany,
Rank::SupersectionBotany,
Rank::SectionBotany,
Rank::SubsectionBotany,
Rank::SuperseriesBotany,
Rank::SeriesBotany,
Rank::SubseriesBotany,
Rank::InfragenericName,
Rank::SpeciesAggregate,
Rank::Species,
Rank::InfraspecificName,
Rank::Grex,
Rank::Klepton,
Rank::Subspecies,
Rank::CultivarGroup,
Rank::Convariety,
Rank::InfrasubspecificName,
Rank::Proles,
Rank::Natio,
Rank::Aberration,
Rank::Morph,
Rank::Supervariety,
Rank::Variety,
Rank::Subvariety,
Rank::Superform,
Rank::Form,
Rank::Subform,
Rank::Pathovar,
Rank::Biovar,
Rank::Chemovar,
Rank::Morphovar,
Rank::Phagovar,
Rank::Serovar,
Rank::Chemoform,
Rank::FormaSpecialis,
Rank::Lusus,
Rank::Cultivar,
Rank::Mutatio,
Rank::Strain,
Rank::Other,
Rank::Unranked,
];
pub const LINNEAN_RANKS: [Rank; 7] = [
Rank::Kingdom,
Rank::Phylum,
Rank::Class,
Rank::Order,
Rank::Family,
Rank::Genus,
Rank::Species,
];
pub fn ordinal(&self) -> usize {
*self as usize
}
pub fn code(&self) -> Option<NomCode> {
match self {
Rank::Realm | Rank::Subrealm => Some(NomCode::Virus),
Rank::Parvphylum
| Rank::Microphylum
| Rank::Nanophylum
| Rank::Claudius
| Rank::Gigaclass
| Rank::Megaclass
| Rank::Subterclass
| Rank::Parvclass
| Rank::Superdivision
| Rank::DivisionZoology
| Rank::Subdivision
| Rank::Infradivision
| Rank::Superlegion
| Rank::Legion
| Rank::Sublegion
| Rank::Infralegion
| Rank::Megacohort
| Rank::Supercohort
| Rank::Cohort
| Rank::Subcohort
| Rank::Infracohort
| Rank::Gigaorder
| Rank::Magnorder
| Rank::Grandorder
| Rank::Mirorder
| Rank::Nanorder
| Rank::Hypoorder
| Rank::Minorder
| Rank::Parvorder
| Rank::SupersectionZoology
| Rank::SectionZoology
| Rank::SubsectionZoology
| Rank::SuperseriesZoology
| Rank::SeriesZoology
| Rank::SubseriesZoology
| Rank::Gigafamily
| Rank::Megafamily
| Rank::Grandfamily
| Rank::Epifamily
| Rank::Klepton
| Rank::Natio
| Rank::Aberration
| Rank::Morph
| Rank::Mutatio => Some(NomCode::Zoological),
Rank::DivisionBotany
| Rank::SupersectionBotany
| Rank::SectionBotany
| Rank::SubsectionBotany
| Rank::SuperseriesBotany
| Rank::SeriesBotany
| Rank::SubseriesBotany
| Rank::Proles
| Rank::FormaSpecialis
| Rank::Lusus => Some(NomCode::Botanical),
Rank::Grex | Rank::CultivarGroup | Rank::Convariety | Rank::Cultivar => {
Some(NomCode::Cultivars)
}
Rank::Pathovar
| Rank::Biovar
| Rank::Chemovar
| Rank::Morphovar
| Rank::Phagovar
| Rank::Serovar
| Rank::Chemoform => Some(NomCode::Bacterial),
Rank::Superdomain
| Rank::Domain
| Rank::Subdomain
| Rank::Infradomain
| Rank::Empire
| Rank::Superkingdom
| Rank::Kingdom
| Rank::Subkingdom
| Rank::Infrakingdom
| Rank::Superphylum
| Rank::Phylum
| Rank::Subphylum
| Rank::Infraphylum
| Rank::Superclass
| Rank::Class
| Rank::Subclass
| Rank::Infraclass
| Rank::Superorder
| Rank::Order
| Rank::Suborder
| Rank::Infraorder
| Rank::Falanx
| Rank::Superfamily
| Rank::Family
| Rank::Subfamily
| Rank::Infrafamily
| Rank::Supertribe
| Rank::Tribe
| Rank::Subtribe
| Rank::Infratribe
| Rank::SupragenericName
| Rank::Supergenus
| Rank::Genus
| Rank::Subgenus
| Rank::Infragenus
| Rank::InfragenericName
| Rank::SpeciesAggregate
| Rank::Species
| Rank::InfraspecificName
| Rank::Subspecies
| Rank::InfrasubspecificName
| Rank::Supervariety
| Rank::Variety
| Rank::Subvariety
| Rank::Superform
| Rank::Form
| Rank::Subform
| Rank::Strain
| Rank::Other
| Rank::Unranked => None,
}
}
pub fn is_restricted_to_code(&self) -> Option<NomCode> {
self.code()
}
pub fn marker(&self) -> Option<&'static str> {
match self {
Rank::Superdomain => Some("superdom."),
Rank::Domain => Some("dom."),
Rank::Subdomain => Some("subdom."),
Rank::Infradomain => Some("infradom."),
Rank::Empire => Some("imp."),
Rank::Realm => Some("realm"),
Rank::Subrealm => Some("subrealm"),
Rank::Superkingdom => Some("superreg."),
Rank::Kingdom => Some("regn."),
Rank::Subkingdom => Some("subreg."),
Rank::Infrakingdom => Some("infrareg."),
Rank::Superphylum => Some("superphyl."),
Rank::Phylum => Some("phyl."),
Rank::Subphylum => Some("subphyl."),
Rank::Infraphylum => Some("infraphyl."),
Rank::Parvphylum => Some("parvphyl."),
Rank::Microphylum => Some("microphyl."),
Rank::Nanophylum => Some("nanophyl."),
Rank::Claudius => Some("claud."),
Rank::Gigaclass => Some("gigacl."),
Rank::Megaclass => Some("megacl."),
Rank::Superclass => Some("supercl."),
Rank::Class => Some("cl."),
Rank::Subclass => Some("subcl."),
Rank::Infraclass => Some("infracl."),
Rank::Subterclass => Some("subtercl."),
Rank::Parvclass => Some("parvcl."),
Rank::Superdivision => Some("superdiv."),
Rank::DivisionZoology | Rank::DivisionBotany => Some("div."),
Rank::Subdivision => Some("subdiv."),
Rank::Infradivision => Some("infradiv."),
Rank::Superlegion => Some("superleg."),
Rank::Legion => Some("leg."),
Rank::Sublegion => Some("subleg."),
Rank::Infralegion => Some("infraleg."),
Rank::Megacohort => Some("megacohort"),
Rank::Supercohort => Some("supercohort"),
Rank::Cohort => Some("cohort"),
Rank::Subcohort => Some("subcohort"),
Rank::Infracohort => Some("infracohort"),
Rank::Gigaorder => Some("gigaord."),
Rank::Magnorder => Some("magnord."),
Rank::Grandorder => Some("grandord."),
Rank::Mirorder => Some("mirord."),
Rank::Superorder => Some("superord."),
Rank::Order => Some("ord."),
Rank::Nanorder => Some("nanord."),
Rank::Hypoorder => Some("hypoord."),
Rank::Minorder => Some("minord."),
Rank::Suborder => Some("subord."),
Rank::Infraorder => Some("infraord."),
Rank::Parvorder => Some("parvord."),
Rank::SupersectionZoology | Rank::SupersectionBotany => Some("supersect."),
Rank::SectionZoology | Rank::SectionBotany => Some("sect."),
Rank::SubsectionZoology | Rank::SubsectionBotany => Some("subsect."),
Rank::SuperseriesZoology | Rank::SuperseriesBotany => Some("superser."),
Rank::SeriesZoology | Rank::SeriesBotany => Some("ser."),
Rank::SubseriesZoology | Rank::SubseriesBotany => Some("subser."),
Rank::Falanx => Some("falanx"),
Rank::Gigafamily => Some("gigafam."),
Rank::Megafamily => Some("megafam."),
Rank::Grandfamily => Some("grandfam."),
Rank::Superfamily => Some("superfam."),
Rank::Epifamily => Some("epifam."),
Rank::Family => Some("fam."),
Rank::Subfamily => Some("subfam."),
Rank::Infrafamily => Some("infrafam."),
Rank::Supertribe => Some("supertrib."),
Rank::Tribe => Some("trib."),
Rank::Subtribe => Some("subtrib."),
Rank::Infratribe => Some("infratrib."),
Rank::SupragenericName => Some("supragen."),
Rank::Supergenus => Some("supergen."),
Rank::Genus => Some("gen."),
Rank::Subgenus => Some("subgen."),
Rank::Infragenus => Some("infrag."),
Rank::InfragenericName => Some("infragen."),
Rank::SpeciesAggregate => Some("agg."),
Rank::Species => Some("sp."),
Rank::InfraspecificName => Some("infrasp."),
Rank::Grex => Some("gx"),
Rank::Klepton => Some("klepton"),
Rank::Subspecies => Some("subsp."),
Rank::Convariety => Some("convar."),
Rank::InfrasubspecificName => Some("infrasubsp."),
Rank::Proles => Some("prol."),
Rank::Natio => Some("natio"),
Rank::Aberration => Some("ab."),
Rank::Morph => Some("morph"),
Rank::Supervariety => Some("supervar."),
Rank::Variety => Some("var."),
Rank::Subvariety => Some("subvar."),
Rank::Superform => Some("superf."),
Rank::Form => Some("f."),
Rank::Subform => Some("subf."),
Rank::Pathovar => Some("pv."),
Rank::Biovar => Some("biovar"),
Rank::Chemovar => Some("chemovar"),
Rank::Morphovar => Some("morphovar"),
Rank::Phagovar => Some("phagovar"),
Rank::Serovar => Some("serovar"),
Rank::Chemoform => Some("chemoform"),
Rank::FormaSpecialis => Some("f.sp."),
Rank::Lusus => Some("lusus"),
Rank::Cultivar => Some("cv."),
Rank::Mutatio => Some("mut."),
Rank::Strain => Some("strain"),
Rank::CultivarGroup | Rank::Other | Rank::Unranked => None,
}
}
pub fn plural(&self) -> Option<&'static str> {
match self {
Rank::Superdomain => Some("superdomains"),
Rank::Domain => Some("domains"),
Rank::Subdomain => Some("subdomains"),
Rank::Infradomain => Some("infradomains"),
Rank::Empire => Some("empires"),
Rank::Realm => Some("realms"),
Rank::Subrealm => Some("subrealms"),
Rank::Superkingdom => Some("superkingdoms"),
Rank::Kingdom => Some("kingdoms"),
Rank::Subkingdom => Some("subkingdoms"),
Rank::Infrakingdom => Some("infrakingdoms"),
Rank::Superphylum => Some("superphyla"),
Rank::Phylum => Some("phyla"),
Rank::Subphylum => Some("subphyla"),
Rank::Infraphylum => Some("infraphyla"),
Rank::Parvphylum => Some("parvphyla"),
Rank::Microphylum => Some("microphyla"),
Rank::Nanophylum => Some("nanophyla"),
Rank::Claudius => Some("claudius"),
Rank::Gigaclass => Some("gigaclasses"),
Rank::Megaclass => Some("megaclasses"),
Rank::Superclass => Some("superclasses"),
Rank::Class => Some("classes"),
Rank::Subclass => Some("subclasses"),
Rank::Infraclass => Some("infraclasses"),
Rank::Subterclass => Some("subterclasses"),
Rank::Parvclass => Some("parvclasses"),
Rank::Superdivision => Some("superdivisions"),
Rank::DivisionZoology => Some("division_zoologys"),
Rank::Subdivision => Some("subdivisions"),
Rank::Infradivision => Some("infradivisions"),
Rank::Superlegion => Some("superlegions"),
Rank::Legion => Some("legions"),
Rank::Sublegion => Some("sublegions"),
Rank::Infralegion => Some("infralegions"),
Rank::Megacohort => Some("megacohorts"),
Rank::Supercohort => Some("supercohorts"),
Rank::Cohort => Some("cohorts"),
Rank::Subcohort => Some("subcohorts"),
Rank::Infracohort => Some("infracohorts"),
Rank::Gigaorder => Some("gigaorders"),
Rank::Magnorder => Some("magnorders"),
Rank::Grandorder => Some("grandorders"),
Rank::Mirorder => Some("mirorders"),
Rank::Superorder => Some("superorders"),
Rank::Order => Some("orders"),
Rank::Nanorder => Some("nanorders"),
Rank::Hypoorder => Some("hypoorders"),
Rank::Minorder => Some("minorders"),
Rank::Suborder => Some("suborders"),
Rank::Infraorder => Some("infraorders"),
Rank::Parvorder => Some("parvorders"),
Rank::SupersectionZoology => Some("supersection_zoologys"),
Rank::SectionZoology => Some("section_zoologys"),
Rank::SubsectionZoology => Some("subsection_zoologys"),
Rank::SuperseriesZoology | Rank::SuperseriesBotany => Some("superseries"),
Rank::SeriesZoology | Rank::SeriesBotany => Some("series"),
Rank::SubseriesZoology | Rank::SubseriesBotany => Some("subseries"),
Rank::Falanx => Some("falanges"),
Rank::Gigafamily => Some("gigafamilies"),
Rank::Megafamily => Some("megafamilies"),
Rank::Grandfamily => Some("grandfamilies"),
Rank::Superfamily => Some("superfamilies"),
Rank::Epifamily => Some("epifamilies"),
Rank::Family => Some("families"),
Rank::Subfamily => Some("subfamilies"),
Rank::Infrafamily => Some("infrafamilies"),
Rank::Supertribe => Some("supertribes"),
Rank::Tribe => Some("tribes"),
Rank::Subtribe => Some("subtribes"),
Rank::Infratribe => Some("infratribes"),
Rank::SupragenericName => Some("suprageneric_names"),
Rank::Supergenus => Some("supergenera"),
Rank::Genus => Some("genera"),
Rank::Subgenus => Some("subgenera"),
Rank::Infragenus => Some("infragenera"),
Rank::DivisionBotany => Some("divisions"),
Rank::SupersectionBotany => Some("supersection_botanys"),
Rank::SectionBotany => Some("section_botanys"),
Rank::SubsectionBotany => Some("subsection_botanys"),
Rank::InfragenericName => Some("infrageneric_names"),
Rank::SpeciesAggregate => Some("species_aggregates"),
Rank::Species => Some("species"),
Rank::InfraspecificName => Some("infraspecific_names"),
Rank::Grex => Some("grexs"),
Rank::Klepton => Some("kleptons"),
Rank::Subspecies => Some("subspecies"),
Rank::Convariety => Some("convarieties"),
Rank::InfrasubspecificName => Some("infrasubspecific_names"),
Rank::Proles => Some("proles"),
Rank::Natio => Some("natios"),
Rank::Aberration => Some("aberrations"),
Rank::Morph => Some("morphs"),
Rank::Supervariety => Some("supervarieties"),
Rank::Variety => Some("varieties"),
Rank::Subvariety => Some("subvarieties"),
Rank::Superform => Some("superforms"),
Rank::Form => Some("forms"),
Rank::Subform => Some("subforms"),
Rank::Pathovar => Some("pathovars"),
Rank::Biovar => Some("biovars"),
Rank::Chemovar => Some("chemovars"),
Rank::Morphovar => Some("morphovars"),
Rank::Phagovar => Some("phagovars"),
Rank::Serovar => Some("serovars"),
Rank::Chemoform => Some("chemoforms"),
Rank::FormaSpecialis => Some("forma_specialiss"),
Rank::Lusus => Some("lusi"),
Rank::Cultivar => Some("cultivars"),
Rank::Mutatio => Some("mutatios"),
Rank::Strain => Some("strains"),
Rank::CultivarGroup | Rank::Other | Rank::Unranked => None,
}
}
pub fn has_ambiguous_marker(&self) -> bool {
AMBIGUOUS_MARKER.contains(self)
}
pub fn not_other_or_unranked(&self) -> bool {
*self != Rank::Other && *self != Rank::Unranked
}
pub fn other_or_unranked(&self) -> bool {
!self.not_other_or_unranked()
}
pub fn is_infraspecific(&self) -> bool {
self.ordinal() > Rank::Species.ordinal() && self.not_other_or_unranked()
}
pub fn is_infrageneric(&self) -> bool {
self.ordinal() > Rank::Genus.ordinal() && self.not_other_or_unranked()
}
pub fn is_infrageneric_strictly(&self) -> bool {
self.is_infrageneric() && self.ordinal() < Rank::SpeciesAggregate.ordinal()
}
pub fn is_linnean(&self) -> bool {
Self::LINNEAN_RANKS.contains(self)
}
pub fn get_major_rank(&self) -> Rank {
*MAJOR_RANKS
.get(self)
.expect("MAJOR_RANKS is populated for every Rank in Rank::ALL")
}
pub fn is_species_or_below(&self) -> bool {
self.ordinal() >= Rank::SpeciesAggregate.ordinal() && self.not_other_or_unranked()
}
pub fn is_family_group(&self) -> bool {
Rank::Gigafamily.ordinal() <= self.ordinal()
&& self.ordinal() < Rank::SupragenericName.ordinal()
}
pub fn is_genus_group(&self) -> bool {
Rank::Supergenus.ordinal() <= self.ordinal()
&& self.ordinal() < Rank::SpeciesAggregate.ordinal()
}
pub fn is_suprageneric(&self) -> bool {
self.ordinal() < Rank::Genus.ordinal()
}
pub fn is_uncomparable(&self) -> bool {
UNCOMPARABLE_RANKS.contains(self)
}
pub fn is_legacy(&self) -> bool {
LEGACY_RANKS.contains(self)
}
pub fn higher_than(&self, other: Rank) -> bool {
self.ordinal() < other.ordinal() && other.not_other_or_unranked()
}
pub fn lower_than(&self, other: Rank) -> bool {
self.ordinal() > other.ordinal() && self.not_other_or_unranked()
}
}
impl Rank {
pub fn from_name(name: &str) -> Option<Rank> {
Rank::ALL
.iter()
.copied()
.find(|&r| rank_wire_name(r) == name)
}
}
impl NomCode {
pub fn from_name(name: &str) -> Option<NomCode> {
match name {
"BACTERIAL" => Some(NomCode::Bacterial),
"BOTANICAL" => Some(NomCode::Botanical),
"CULTIVARS" => Some(NomCode::Cultivars),
"PHYTO" => Some(NomCode::Phyto),
"VIRUS" => Some(NomCode::Virus),
"ZOOLOGICAL" => Some(NomCode::Zoological),
"PHYLO" => Some(NomCode::Phylo),
_ => None,
}
}
}
pub mod rank_utils {
use super::{NomCode, Rank};
pub fn suffices_rank_map(code: NomCode) -> Option<&'static [(&'static str, Rank)]> {
match code {
NomCode::Bacterial => Some(&[
("oideae", Rank::Subfamily),
("aceae", Rank::Family),
("ineae", Rank::Suborder),
("ales", Rank::Order),
("idae", Rank::Subclass),
("inae", Rank::Subtribe),
("eae", Rank::Tribe),
("ia", Rank::Class),
]),
NomCode::Botanical => Some(&[
("mycetidae", Rank::Subclass),
("phycidae", Rank::Subclass),
("mycotina", Rank::Subphylum),
("phytina", Rank::Subphylum),
("mycetes", Rank::Class),
("phyceae", Rank::Class),
("mycota", Rank::Phylum),
("opsida", Rank::Class),
("oideae", Rank::Subfamily),
("phyta", Rank::Phylum),
("ineae", Rank::Suborder),
("aceae", Rank::Family),
("idae", Rank::Subclass),
("anae", Rank::Superorder),
("acea", Rank::Superfamily),
("aria", Rank::Infraorder),
("ales", Rank::Order),
("inae", Rank::Subtribe),
("eae", Rank::Tribe),
]),
NomCode::Zoological => Some(&[
("oidea", Rank::Superfamily),
("oidae", Rank::Epifamily),
("idae", Rank::Family),
("inae", Rank::Subfamily),
("ini", Rank::Tribe),
("ina", Rank::Subtribe),
]),
NomCode::Virus => Some(&[
("viricetidae", Rank::Subclass),
("viricotina", Rank::Subphylum),
("viricetes", Rank::Class),
("viricota", Rank::Phylum),
("virineae", Rank::Suborder),
("virites", Rank::Subkingdom),
("virales", Rank::Order),
("viridae", Rank::Family),
("virinae", Rank::Subfamily),
("viriae", Rank::Kingdom),
("viria", Rank::Realm),
("vira", Rank::Subrealm),
]),
NomCode::Cultivars | NomCode::Phyto | NomCode::Phylo => None,
}
}
}
pub mod warnings {
pub const NULL_EPITHET: &str = "epithet with literal value null";
pub const HOMOGLYHPS: &str = "homoglyphs replaced";
pub const UNUSUAL_CHARACTERS: &str = "unusual characters";
pub const SUBSPECIES_ASSIGNED: &str =
"Name was considered species but contains infraspecific epithet";
pub const LC_MONOMIAL: &str = "lower case monomial match";
pub const INDETERMINED: &str = "indetermined name missing its terminal epithet";
pub const HIGHER_RANK_BINOMIAL: &str = "binomial with rank higher than species aggregate";
pub const QUESTION_MARKS_REMOVED: &str = "question marks removed";
pub const REPL_ENCLOSING_QUOTE: &str = "removed enclosing quotes";
pub const MISSING_GENUS: &str = "epithet without genus";
pub const DOUBTFUL_GENUS: &str = "genus quoted or in square brackets";
pub const RANK_MISMATCH: &str = "rank does not fit the parsed name";
pub const CODE_MISMATCH: &str = "nomenclatural code does not fit the parsed name";
pub const HTML_ENTITIES: &str = "html entities unescaped";
pub const XML_TAGS: &str = "xml tags removed";
pub const BLACKLISTED_EPITHET: &str = "blacklisted epithet used";
pub const NOMENCLATURAL_REFERENCE: &str = "nomenclatural reference removed";
pub const AUTHORSHIP_REMOVED: &str = "authorship placeholder removed";
pub const YEAR_INTERPRETED: &str =
"authorship year was extract but originally was a year range or other form of year";
pub const UNLIKELY_YEAR: &str = "unlikely authorship year";
pub const UNCERTAIN_AUTHORSHIP: &str = "authorship marked as uncertain";
pub const QUADRINOMIAL: &str = "name was quadrinomial";
pub const ABBREVIATED_GENUS: &str = "abbreviated genus name";
pub const ABBREVIATED_SUBGENUS: &str = "abbreviated subgenus name";
pub const REMOVED_PREFIX: &str = "Removed: ";
pub const LONG_NAME: &str = "unusually long name";
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn name_type_scientific_serializes_uppercase() {
assert_eq!(
serde_json::to_string(&NameType::Scientific).unwrap(),
"\"SCIENTIFIC\""
);
}
#[test]
fn name_type_first_and_last_variant() {
assert_eq!(
serde_json::to_string(&NameType::Scientific).unwrap(),
"\"SCIENTIFIC\""
);
assert_eq!(
serde_json::to_string(&NameType::Other).unwrap(),
"\"OTHER\""
);
}
#[test]
fn nom_code_first_last_and_zoological() {
assert_eq!(
serde_json::to_string(&NomCode::Bacterial).unwrap(),
"\"BACTERIAL\""
);
assert_eq!(serde_json::to_string(&NomCode::Phylo).unwrap(), "\"PHYLO\"");
assert_eq!(
serde_json::to_string(&NomCode::Zoological).unwrap(),
"\"ZOOLOGICAL\""
);
}
#[test]
fn name_part_first_and_last_variant() {
assert_eq!(
serde_json::to_string(&NamePart::Generic).unwrap(),
"\"GENERIC\""
);
assert_eq!(
serde_json::to_string(&NamePart::Infraspecific).unwrap(),
"\"INFRASPECIFIC\""
);
}
#[test]
fn state_first_and_last_variant() {
assert_eq!(
serde_json::to_string(&State::Complete).unwrap(),
"\"COMPLETE\""
);
assert_eq!(serde_json::to_string(&State::None).unwrap(), "\"NONE\"");
}
#[test]
fn rank_stub_unranked() {
assert_eq!(
serde_json::to_string(&Rank::Unranked).unwrap(),
"\"UNRANKED\""
);
}
#[test]
fn rank_stub_species_and_subspecies() {
assert_eq!(
serde_json::to_string(&Rank::Species).unwrap(),
"\"SPECIES\""
);
assert_eq!(
serde_json::to_string(&Rank::Subspecies).unwrap(),
"\"SUBSPECIES\""
);
}
#[test]
fn rank_stub_batch_2b_variants() {
assert_eq!(serde_json::to_string(&Rank::Genus).unwrap(), "\"GENUS\"");
assert_eq!(serde_json::to_string(&Rank::Family).unwrap(), "\"FAMILY\"");
assert_eq!(
serde_json::to_string(&Rank::Variety).unwrap(),
"\"VARIETY\""
);
assert_eq!(serde_json::to_string(&Rank::Form).unwrap(), "\"FORM\"");
assert_eq!(
serde_json::to_string(&Rank::Cultivar).unwrap(),
"\"CULTIVAR\""
);
assert_eq!(
serde_json::to_string(&Rank::CultivarGroup).unwrap(),
"\"CULTIVAR_GROUP\""
);
assert_eq!(serde_json::to_string(&Rank::Grex).unwrap(), "\"GREX\"");
}
#[test]
fn rank_stub_batch_2e_variants() {
assert_eq!(
serde_json::to_string(&Rank::Subfamily).unwrap(),
"\"SUBFAMILY\""
);
assert_eq!(serde_json::to_string(&Rank::Tribe).unwrap(), "\"TRIBE\"");
assert_eq!(
serde_json::to_string(&Rank::Subtribe).unwrap(),
"\"SUBTRIBE\""
);
assert_eq!(
serde_json::to_string(&Rank::Supertribe).unwrap(),
"\"SUPERTRIBE\""
);
assert_eq!(
serde_json::to_string(&Rank::Infratribe).unwrap(),
"\"INFRATRIBE\""
);
assert_eq!(
serde_json::to_string(&Rank::Subgenus).unwrap(),
"\"SUBGENUS\""
);
assert_eq!(
serde_json::to_string(&Rank::SectionBotany).unwrap(),
"\"SECTION_BOTANY\""
);
assert_eq!(
serde_json::to_string(&Rank::SubsectionBotany).unwrap(),
"\"SUBSECTION_BOTANY\""
);
assert_eq!(
serde_json::to_string(&Rank::SupersectionBotany).unwrap(),
"\"SUPERSECTION_BOTANY\""
);
assert_eq!(
serde_json::to_string(&Rank::SeriesBotany).unwrap(),
"\"SERIES_BOTANY\""
);
assert_eq!(
serde_json::to_string(&Rank::SubseriesBotany).unwrap(),
"\"SUBSERIES_BOTANY\""
);
assert_eq!(
serde_json::to_string(&Rank::SuperseriesBotany).unwrap(),
"\"SUPERSERIES_BOTANY\""
);
assert_eq!(
serde_json::to_string(&Rank::SectionZoology).unwrap(),
"\"SECTION_ZOOLOGY\""
);
assert_eq!(
serde_json::to_string(&Rank::SubsectionZoology).unwrap(),
"\"SUBSECTION_ZOOLOGY\""
);
assert_eq!(
serde_json::to_string(&Rank::SupersectionZoology).unwrap(),
"\"SUPERSECTION_ZOOLOGY\""
);
assert_eq!(
serde_json::to_string(&Rank::SeriesZoology).unwrap(),
"\"SERIES_ZOOLOGY\""
);
assert_eq!(
serde_json::to_string(&Rank::SubseriesZoology).unwrap(),
"\"SUBSERIES_ZOOLOGY\""
);
assert_eq!(
serde_json::to_string(&Rank::SuperseriesZoology).unwrap(),
"\"SUPERSERIES_ZOOLOGY\""
);
}
#[test]
fn rank_stub_slice3_task1_variants() {
assert_eq!(serde_json::to_string(&Rank::Other).unwrap(), "\"OTHER\"");
assert_eq!(
serde_json::to_string(&Rank::Subvariety).unwrap(),
"\"SUBVARIETY\""
);
assert_eq!(
serde_json::to_string(&Rank::Subform).unwrap(),
"\"SUBFORM\""
);
assert_eq!(
serde_json::to_string(&Rank::Pathovar).unwrap(),
"\"PATHOVAR\""
);
assert_eq!(serde_json::to_string(&Rank::Biovar).unwrap(), "\"BIOVAR\"");
assert_eq!(
serde_json::to_string(&Rank::Chemoform).unwrap(),
"\"CHEMOFORM\""
);
assert_eq!(
serde_json::to_string(&Rank::Serovar).unwrap(),
"\"SEROVAR\""
);
assert_eq!(serde_json::to_string(&Rank::Morph).unwrap(), "\"MORPH\"");
assert_eq!(
serde_json::to_string(&Rank::Morphovar).unwrap(),
"\"MORPHOVAR\""
);
assert_eq!(
serde_json::to_string(&Rank::Phagovar).unwrap(),
"\"PHAGOVAR\""
);
assert_eq!(serde_json::to_string(&Rank::Natio).unwrap(), "\"NATIO\"");
assert_eq!(
serde_json::to_string(&Rank::Mutatio).unwrap(),
"\"MUTATIO\""
);
assert_eq!(
serde_json::to_string(&Rank::Convariety).unwrap(),
"\"CONVARIETY\""
);
assert_eq!(serde_json::to_string(&Rank::Proles).unwrap(), "\"PROLES\"");
assert_eq!(
serde_json::to_string(&Rank::Aberration).unwrap(),
"\"ABERRATION\""
);
assert_eq!(serde_json::to_string(&Rank::Strain).unwrap(), "\"STRAIN\"");
assert_eq!(
serde_json::to_string(&Rank::InfraspecificName).unwrap(),
"\"INFRASPECIFIC_NAME\""
);
assert_eq!(
serde_json::to_string(&Rank::DivisionBotany).unwrap(),
"\"DIVISION_BOTANY\""
);
}
#[test]
fn rank_stub_slice3_task3_variants() {
assert_eq!(
serde_json::to_string(&Rank::FormaSpecialis).unwrap(),
"\"FORMA_SPECIALIS\""
);
assert_eq!(
serde_json::to_string(&Rank::InfrasubspecificName).unwrap(),
"\"INFRASUBSPECIFIC_NAME\""
);
assert_eq!(
serde_json::to_string(&Rank::InfragenericName).unwrap(),
"\"INFRAGENERIC_NAME\""
);
}
#[test]
fn rank_code_matches_java_get_code() {
assert_eq!(Rank::Unranked.code(), None);
assert_eq!(Rank::Species.code(), None);
assert_eq!(Rank::Subgenus.code(), None);
assert_eq!(Rank::Tribe.code(), None);
assert_eq!(Rank::Grex.code(), Some(NomCode::Cultivars));
assert_eq!(Rank::CultivarGroup.code(), Some(NomCode::Cultivars));
assert_eq!(Rank::Cultivar.code(), Some(NomCode::Cultivars));
assert_eq!(Rank::SectionBotany.code(), Some(NomCode::Botanical));
assert_eq!(Rank::SubsectionBotany.code(), Some(NomCode::Botanical));
assert_eq!(Rank::SupersectionBotany.code(), Some(NomCode::Botanical));
assert_eq!(Rank::SeriesBotany.code(), Some(NomCode::Botanical));
assert_eq!(Rank::SubseriesBotany.code(), Some(NomCode::Botanical));
assert_eq!(Rank::SuperseriesBotany.code(), Some(NomCode::Botanical));
assert_eq!(Rank::SectionZoology.code(), Some(NomCode::Zoological));
assert_eq!(Rank::SubsectionZoology.code(), Some(NomCode::Zoological));
assert_eq!(Rank::SupersectionZoology.code(), Some(NomCode::Zoological));
assert_eq!(Rank::SeriesZoology.code(), Some(NomCode::Zoological));
assert_eq!(Rank::SubseriesZoology.code(), Some(NomCode::Zoological));
assert_eq!(Rank::SuperseriesZoology.code(), Some(NomCode::Zoological));
}
#[test]
fn rank_code_matches_java_get_code_slice3_task1_variants() {
assert_eq!(Rank::Pathovar.code(), Some(NomCode::Bacterial));
assert_eq!(Rank::Biovar.code(), Some(NomCode::Bacterial));
assert_eq!(Rank::Chemoform.code(), Some(NomCode::Bacterial));
assert_eq!(Rank::Serovar.code(), Some(NomCode::Bacterial));
assert_eq!(Rank::Morphovar.code(), Some(NomCode::Bacterial));
assert_eq!(Rank::Phagovar.code(), Some(NomCode::Bacterial));
assert_eq!(Rank::Morph.code(), Some(NomCode::Zoological));
assert_eq!(Rank::Natio.code(), Some(NomCode::Zoological));
assert_eq!(Rank::Mutatio.code(), Some(NomCode::Zoological));
assert_eq!(Rank::Aberration.code(), Some(NomCode::Zoological));
assert_eq!(Rank::Convariety.code(), Some(NomCode::Cultivars));
assert_eq!(Rank::Proles.code(), Some(NomCode::Botanical));
assert_eq!(Rank::DivisionBotany.code(), Some(NomCode::Botanical));
assert_eq!(Rank::Other.code(), None);
assert_eq!(Rank::Subvariety.code(), None);
assert_eq!(Rank::Subform.code(), None);
assert_eq!(Rank::Strain.code(), None);
assert_eq!(Rank::InfraspecificName.code(), None);
}
#[test]
fn rank_code_matches_java_get_code_slice3_task3_variants() {
assert_eq!(Rank::FormaSpecialis.code(), Some(NomCode::Botanical));
assert_eq!(Rank::InfrasubspecificName.code(), None);
assert_eq!(Rank::InfragenericName.code(), None);
}
#[test]
fn name_part_ord_matches_java_ordinal_order() {
let mut parts = vec![
NamePart::Infraspecific,
NamePart::Generic,
NamePart::Specific,
NamePart::Infrageneric,
];
parts.sort();
assert_eq!(
parts,
vec![
NamePart::Generic,
NamePart::Infrageneric,
NamePart::Specific,
NamePart::Infraspecific,
]
);
}
#[test]
fn rank_all_117_variants_in_java_declaration_order() {
let expected: [(Rank, &str); 117] = [
(Rank::Superdomain, "SUPERDOMAIN"),
(Rank::Domain, "DOMAIN"),
(Rank::Subdomain, "SUBDOMAIN"),
(Rank::Infradomain, "INFRADOMAIN"),
(Rank::Empire, "EMPIRE"),
(Rank::Realm, "REALM"),
(Rank::Subrealm, "SUBREALM"),
(Rank::Superkingdom, "SUPERKINGDOM"),
(Rank::Kingdom, "KINGDOM"),
(Rank::Subkingdom, "SUBKINGDOM"),
(Rank::Infrakingdom, "INFRAKINGDOM"),
(Rank::Superphylum, "SUPERPHYLUM"),
(Rank::Phylum, "PHYLUM"),
(Rank::Subphylum, "SUBPHYLUM"),
(Rank::Infraphylum, "INFRAPHYLUM"),
(Rank::Parvphylum, "PARVPHYLUM"),
(Rank::Microphylum, "MICROPHYLUM"),
(Rank::Nanophylum, "NANOPHYLUM"),
(Rank::Claudius, "CLAUDIUS"),
(Rank::Gigaclass, "GIGACLASS"),
(Rank::Megaclass, "MEGACLASS"),
(Rank::Superclass, "SUPERCLASS"),
(Rank::Class, "CLASS"),
(Rank::Subclass, "SUBCLASS"),
(Rank::Infraclass, "INFRACLASS"),
(Rank::Subterclass, "SUBTERCLASS"),
(Rank::Parvclass, "PARVCLASS"),
(Rank::Superdivision, "SUPERDIVISION"),
(Rank::DivisionZoology, "DIVISION_ZOOLOGY"),
(Rank::Subdivision, "SUBDIVISION"),
(Rank::Infradivision, "INFRADIVISION"),
(Rank::Superlegion, "SUPERLEGION"),
(Rank::Legion, "LEGION"),
(Rank::Sublegion, "SUBLEGION"),
(Rank::Infralegion, "INFRALEGION"),
(Rank::Megacohort, "MEGACOHORT"),
(Rank::Supercohort, "SUPERCOHORT"),
(Rank::Cohort, "COHORT"),
(Rank::Subcohort, "SUBCOHORT"),
(Rank::Infracohort, "INFRACOHORT"),
(Rank::Gigaorder, "GIGAORDER"),
(Rank::Magnorder, "MAGNORDER"),
(Rank::Grandorder, "GRANDORDER"),
(Rank::Mirorder, "MIRORDER"),
(Rank::Superorder, "SUPERORDER"),
(Rank::Order, "ORDER"),
(Rank::Nanorder, "NANORDER"),
(Rank::Hypoorder, "HYPOORDER"),
(Rank::Minorder, "MINORDER"),
(Rank::Suborder, "SUBORDER"),
(Rank::Infraorder, "INFRAORDER"),
(Rank::Parvorder, "PARVORDER"),
(Rank::SupersectionZoology, "SUPERSECTION_ZOOLOGY"),
(Rank::SectionZoology, "SECTION_ZOOLOGY"),
(Rank::SubsectionZoology, "SUBSECTION_ZOOLOGY"),
(Rank::SuperseriesZoology, "SUPERSERIES_ZOOLOGY"),
(Rank::SeriesZoology, "SERIES_ZOOLOGY"),
(Rank::SubseriesZoology, "SUBSERIES_ZOOLOGY"),
(Rank::Falanx, "FALANX"),
(Rank::Gigafamily, "GIGAFAMILY"),
(Rank::Megafamily, "MEGAFAMILY"),
(Rank::Grandfamily, "GRANDFAMILY"),
(Rank::Superfamily, "SUPERFAMILY"),
(Rank::Epifamily, "EPIFAMILY"),
(Rank::Family, "FAMILY"),
(Rank::Subfamily, "SUBFAMILY"),
(Rank::Infrafamily, "INFRAFAMILY"),
(Rank::Supertribe, "SUPERTRIBE"),
(Rank::Tribe, "TRIBE"),
(Rank::Subtribe, "SUBTRIBE"),
(Rank::Infratribe, "INFRATRIBE"),
(Rank::SupragenericName, "SUPRAGENERIC_NAME"),
(Rank::Supergenus, "SUPERGENUS"),
(Rank::Genus, "GENUS"),
(Rank::Subgenus, "SUBGENUS"),
(Rank::Infragenus, "INFRAGENUS"),
(Rank::DivisionBotany, "DIVISION_BOTANY"),
(Rank::SupersectionBotany, "SUPERSECTION_BOTANY"),
(Rank::SectionBotany, "SECTION_BOTANY"),
(Rank::SubsectionBotany, "SUBSECTION_BOTANY"),
(Rank::SuperseriesBotany, "SUPERSERIES_BOTANY"),
(Rank::SeriesBotany, "SERIES_BOTANY"),
(Rank::SubseriesBotany, "SUBSERIES_BOTANY"),
(Rank::InfragenericName, "INFRAGENERIC_NAME"),
(Rank::SpeciesAggregate, "SPECIES_AGGREGATE"),
(Rank::Species, "SPECIES"),
(Rank::InfraspecificName, "INFRASPECIFIC_NAME"),
(Rank::Grex, "GREX"),
(Rank::Klepton, "KLEPTON"),
(Rank::Subspecies, "SUBSPECIES"),
(Rank::CultivarGroup, "CULTIVAR_GROUP"),
(Rank::Convariety, "CONVARIETY"),
(Rank::InfrasubspecificName, "INFRASUBSPECIFIC_NAME"),
(Rank::Proles, "PROLES"),
(Rank::Natio, "NATIO"),
(Rank::Aberration, "ABERRATION"),
(Rank::Morph, "MORPH"),
(Rank::Supervariety, "SUPERVARIETY"),
(Rank::Variety, "VARIETY"),
(Rank::Subvariety, "SUBVARIETY"),
(Rank::Superform, "SUPERFORM"),
(Rank::Form, "FORM"),
(Rank::Subform, "SUBFORM"),
(Rank::Pathovar, "PATHOVAR"),
(Rank::Biovar, "BIOVAR"),
(Rank::Chemovar, "CHEMOVAR"),
(Rank::Morphovar, "MORPHOVAR"),
(Rank::Phagovar, "PHAGOVAR"),
(Rank::Serovar, "SEROVAR"),
(Rank::Chemoform, "CHEMOFORM"),
(Rank::FormaSpecialis, "FORMA_SPECIALIS"),
(Rank::Lusus, "LUSUS"),
(Rank::Cultivar, "CULTIVAR"),
(Rank::Mutatio, "MUTATIO"),
(Rank::Strain, "STRAIN"),
(Rank::Other, "OTHER"),
(Rank::Unranked, "UNRANKED"),
];
assert_eq!(expected.len(), 117);
assert_eq!(Rank::ALL.len(), 117);
for (i, (rank, name)) in expected.iter().enumerate() {
assert_eq!(Rank::ALL[i], *rank, "Rank::ALL[{i}] should be {rank:?}");
assert_eq!(rank.ordinal(), i, "{rank:?}.ordinal() should be {i}");
assert_eq!(
serde_json::to_string(rank).unwrap(),
format!("\"{name}\""),
"{rank:?} should serialize to \"{name}\""
);
}
}
#[test]
fn rank_code_tdd_sample() {
assert_eq!(Rank::Cultivar.code(), Some(NomCode::Cultivars));
assert_eq!(Rank::Subgenus.code(), None);
assert_eq!(Rank::Pathovar.code(), Some(NomCode::Bacterial));
assert_eq!(Rank::SectionBotany.code(), Some(NomCode::Botanical));
assert_eq!(Rank::Realm.code(), Some(NomCode::Virus));
assert_eq!(Rank::Subrealm.code(), Some(NomCode::Virus));
}
#[test]
fn rank_ordinal_predicates_tdd_sample() {
assert!(Rank::Subspecies.is_infraspecific());
assert!(!Rank::Species.is_infraspecific());
assert!(Rank::Subgenus.is_infrageneric_strictly());
assert!(!Rank::Genus.is_infrageneric_strictly());
assert!(!Rank::Species.is_infrageneric_strictly());
assert!(Rank::Family.is_suprageneric());
assert!(!Rank::Genus.is_suprageneric());
assert!(Rank::Genus.higher_than(Rank::Species));
assert!(!Rank::Species.higher_than(Rank::Genus));
assert!(Rank::Species.higher_than(Rank::Subspecies));
assert!(Rank::Subspecies.lower_than(Rank::Species));
assert!(!Rank::Genus.higher_than(Rank::Other));
assert!(!Rank::Genus.higher_than(Rank::Unranked));
}
#[test]
fn rank_markers_tdd_sample() {
assert_eq!(Rank::Subspecies.marker(), Some("subsp."));
assert_eq!(Rank::Species.marker(), Some("sp."));
assert_eq!(Rank::CultivarGroup.marker(), None);
assert_eq!(Rank::Other.marker(), None);
assert_eq!(Rank::Unranked.marker(), None);
assert_eq!(Rank::SectionZoology.marker(), Rank::SectionBotany.marker());
assert_eq!(
Rank::DivisionZoology.marker(),
Rank::DivisionBotany.marker()
);
}
#[test]
fn rank_plural_sample() {
assert_eq!(Rank::Species.plural(), Some("species"));
assert_eq!(Rank::Genus.plural(), Some("genera"));
assert_eq!(Rank::Falanx.plural(), Some("falanges"));
assert_eq!(Rank::Lusus.plural(), Some("lusi"));
assert_eq!(Rank::CultivarGroup.plural(), None);
assert_eq!(Rank::Other.plural(), None);
assert_eq!(Rank::Unranked.plural(), None);
assert_eq!(Rank::DivisionZoology.plural(), Some("division_zoologys"));
assert_eq!(Rank::SectionBotany.plural(), Some("section_botanys"));
assert_eq!(Rank::SeriesZoology.plural(), Some("series"));
assert_eq!(Rank::SeriesBotany.plural(), Some("series"));
}
#[test]
fn rank_is_family_group_and_genus_group() {
assert!(Rank::Family.is_family_group());
assert!(Rank::Gigafamily.is_family_group());
assert!(!Rank::SupragenericName.is_family_group());
assert!(!Rank::Genus.is_family_group());
assert!(Rank::Genus.is_genus_group());
assert!(Rank::Supergenus.is_genus_group());
assert!(Rank::Subgenus.is_genus_group());
assert!(!Rank::SpeciesAggregate.is_genus_group());
assert!(!Rank::SupragenericName.is_genus_group());
}
#[test]
fn rank_is_species_or_below() {
assert!(Rank::SpeciesAggregate.is_species_or_below());
assert!(Rank::Species.is_species_or_below());
assert!(Rank::Subspecies.is_species_or_below());
assert!(!Rank::Genus.is_species_or_below());
assert!(!Rank::Other.is_species_or_below());
assert!(!Rank::Unranked.is_species_or_below());
}
#[test]
fn rank_is_uncomparable() {
assert!(Rank::SupragenericName.is_uncomparable());
assert!(Rank::InfragenericName.is_uncomparable());
assert!(Rank::InfraspecificName.is_uncomparable());
assert!(Rank::InfrasubspecificName.is_uncomparable());
assert!(Rank::Other.is_uncomparable());
assert!(Rank::Unranked.is_uncomparable());
assert!(!Rank::Species.is_uncomparable());
assert!(!Rank::Genus.is_uncomparable());
}
#[test]
fn rank_is_legacy() {
for r in [
Rank::Morph,
Rank::Aberration,
Rank::Natio,
Rank::Proles,
Rank::Convariety,
Rank::Klepton,
Rank::Falanx,
Rank::Lusus,
] {
assert!(r.is_legacy(), "{r:?} should be legacy");
}
assert!(!Rank::Species.is_legacy());
assert!(!Rank::Subspecies.is_legacy());
}
#[test]
fn rank_is_linnean() {
for r in Rank::LINNEAN_RANKS {
assert!(r.is_linnean(), "{r:?} should be Linnean");
}
assert!(!Rank::Subgenus.is_linnean());
assert!(!Rank::Subspecies.is_linnean());
assert_eq!(Rank::LINNEAN_RANKS.len(), 7);
}
#[test]
fn rank_is_restricted_to_code_matches_code() {
assert_eq!(
Rank::Cultivar.is_restricted_to_code(),
Rank::Cultivar.code()
);
assert_eq!(Rank::Species.is_restricted_to_code(), Rank::Species.code());
}
#[test]
fn rank_has_ambiguous_marker() {
for r in [
Rank::DivisionZoology,
Rank::DivisionBotany,
Rank::SectionZoology,
Rank::SectionBotany,
Rank::SubsectionZoology,
Rank::SubsectionBotany,
Rank::SupersectionZoology,
Rank::SupersectionBotany,
Rank::SeriesZoology,
Rank::SeriesBotany,
Rank::SubseriesZoology,
Rank::SubseriesBotany,
Rank::SuperseriesZoology,
Rank::SuperseriesBotany,
] {
assert!(r.has_ambiguous_marker(), "{r:?} should be ambiguous");
}
assert!(!Rank::Species.has_ambiguous_marker());
assert!(!Rank::Genus.has_ambiguous_marker());
assert!(!Rank::Cultivar.has_ambiguous_marker());
}
#[test]
fn rank_get_major_rank_automatic() {
assert_eq!(Rank::Subphylum.get_major_rank(), Rank::Phylum);
assert_eq!(Rank::Nanophylum.get_major_rank(), Rank::Phylum);
assert_eq!(Rank::Subclass.get_major_rank(), Rank::Class);
assert_eq!(Rank::Subterclass.get_major_rank(), Rank::Class);
assert_eq!(Rank::SubsectionBotany.get_major_rank(), Rank::SectionBotany);
assert_eq!(
Rank::SupersectionZoology.get_major_rank(),
Rank::SectionZoology
);
assert_eq!(Rank::Species.get_major_rank(), Rank::Species);
assert_eq!(Rank::Genus.get_major_rank(), Rank::Genus);
assert_eq!(Rank::Other.get_major_rank(), Rank::Other);
assert_eq!(Rank::Unranked.get_major_rank(), Rank::Unranked);
}
#[test]
fn rank_get_major_rank_manual_fixes() {
assert_eq!(Rank::Nanorder.get_major_rank(), Rank::Order);
assert_eq!(Rank::SpeciesAggregate.get_major_rank(), Rank::Species);
assert_eq!(Rank::InfragenericName.get_major_rank(), Rank::Genus);
assert_eq!(Rank::Superdivision.get_major_rank(), Rank::DivisionZoology);
assert_eq!(Rank::Subdivision.get_major_rank(), Rank::DivisionZoology);
assert_eq!(Rank::Infradivision.get_major_rank(), Rank::DivisionZoology);
}
#[test]
fn rank_get_major_rank_infraspecific_collapse() {
for r in [
Rank::Grex,
Rank::Klepton,
Rank::Subspecies,
Rank::CultivarGroup,
Rank::Variety,
Rank::Cultivar,
Rank::Strain,
] {
assert_eq!(
r.get_major_rank(),
Rank::InfraspecificName,
"{r:?} should collapse to INFRASPECIFIC_NAME"
);
}
}
#[test]
fn rank_utils_suffices_rank_map_sample() {
let bot = rank_utils::suffices_rank_map(NomCode::Botanical).unwrap();
assert!(bot.contains(&("aceae", Rank::Family)));
assert!(bot.contains(&("oideae", Rank::Subfamily)));
let zoo = rank_utils::suffices_rank_map(NomCode::Zoological).unwrap();
assert!(zoo.contains(&("idae", Rank::Family)));
assert!(zoo.contains(&("oidae", Rank::Epifamily)));
let bact = rank_utils::suffices_rank_map(NomCode::Bacterial).unwrap();
assert!(bact.contains(&("idae", Rank::Subclass)));
let virus = rank_utils::suffices_rank_map(NomCode::Virus).unwrap();
assert!(virus.contains(&("viridae", Rank::Family)));
assert_eq!(rank_utils::suffices_rank_map(NomCode::Cultivars), None);
assert_eq!(rank_utils::suffices_rank_map(NomCode::Phyto), None);
assert_eq!(rank_utils::suffices_rank_map(NomCode::Phylo), None);
}
#[test]
fn rank_from_name_round_trips_every_variant_via_its_own_serialize_impl() {
for &r in Rank::ALL.iter() {
let name = rank_wire_name(r);
assert_eq!(
Rank::from_name(&name),
Some(r),
"round-trip failed for {r:?}"
);
}
}
#[test]
fn rank_from_name_pins_a_multi_word_constant_and_rejects_nonsense() {
assert_eq!(Rank::from_name("SPECIES"), Some(Rank::Species));
assert_eq!(
Rank::from_name("DIVISION_ZOOLOGY"),
Some(Rank::DivisionZoology)
);
assert_eq!(Rank::from_name("NONSENSE"), None);
assert_eq!(Rank::from_name(""), None);
}
#[test]
fn nomcode_from_name_round_trips_every_variant_via_its_own_serialize_impl() {
for &c in &[
NomCode::Bacterial,
NomCode::Botanical,
NomCode::Cultivars,
NomCode::Phyto,
NomCode::Virus,
NomCode::Zoological,
NomCode::Phylo,
] {
let name = serde_json::to_string(&c)
.unwrap()
.trim_matches('"')
.to_string();
assert_eq!(
NomCode::from_name(&name),
Some(c),
"round-trip failed for {c:?}"
);
}
}
#[test]
fn nomcode_from_name_pins_botanical_and_rejects_nonsense() {
assert_eq!(NomCode::from_name("BOTANICAL"), Some(NomCode::Botanical));
assert_eq!(NomCode::from_name("NONSENSE"), None);
}
}