pub mod format;
pub mod model;
pub mod pipeline;
pub mod regexes;
pub mod token;
pub mod unicode;
pub mod viral;
use model::{Informal, NameType, NomCode, ParseError, ParsedName, Rank};
pub fn parse_name(
name: &str,
authorship: Option<&str>,
rank: Option<Rank>,
code: Option<NomCode>,
) -> Result<ParsedName, ParseError> {
pipeline::run(name, authorship, rank, code)
}
#[allow(clippy::large_enum_variant)]
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ParseResult {
Parsed(ParsedName),
Informal(Informal),
Unparsable(ParseError),
}
impl ParseResult {
pub fn type_(&self) -> NameType {
match self {
ParseResult::Parsed(pn) => pn.type_,
ParseResult::Informal(_) => NameType::Informal,
ParseResult::Unparsable(e) => e.type_,
}
}
pub fn code(&self) -> Option<NomCode> {
match self {
ParseResult::Parsed(pn) => pn.code,
ParseResult::Informal(i) => i.code,
ParseResult::Unparsable(e) => e.code,
}
}
pub fn parsed(&self) -> Option<&ParsedName> {
match self {
ParseResult::Parsed(pn) => Some(pn),
_ => None,
}
}
pub fn is_parsable(&self) -> bool {
matches!(self, ParseResult::Parsed(_))
}
}
pub fn parse(
name: &str,
authorship: Option<&str>,
rank: Option<Rank>,
code: Option<NomCode>,
) -> ParseResult {
match pipeline::run(name, authorship, rank, code) {
Ok(pn) if is_informal(&pn) => ParseResult::Informal(to_informal(pn)),
Ok(pn) => ParseResult::Parsed(pn),
Err(e) => ParseResult::Unparsable(e.clamped_to_unparsable()),
}
}
fn is_informal(pn: &ParsedName) -> bool {
pn.type_ == NameType::Informal
&& pn.specific_epithet.is_none()
&& (pn.genus.is_some() || pn.uninomial.is_some() || pn.infrageneric_epithet.is_some())
}
fn to_informal(pn: ParsedName) -> Informal {
let (taxon, taxon_rank) = if let Some(g) = pn.genus.as_deref() {
(g.to_string(), Rank::Genus)
} else if let Some(u) = pn.uninomial.as_deref() {
(u.to_string(), pn.rank)
} else {
(pn.infrageneric_epithet.clone().unwrap_or_default(), pn.rank)
};
Informal {
taxon,
taxon_rank,
rank: pn.rank,
phrase: pn.phrase,
code: pn.code,
}
}
#[cfg(test)]
mod tests {
use super::*;
use model::NameType;
#[test]
fn parse_delegates_to_pipeline_run() {
let pn = parse_name("Abies alba", None, None, None).expect("should parse");
assert_eq!(pn.type_, NameType::Scientific);
}
#[test]
fn parse_rejects_empty_input() {
let err = parse_name("", None, None, None).unwrap_err();
assert_eq!(err.type_, NameType::Other);
}
#[test]
fn parse_classifies_three_way() {
use model::Rank;
match parse("Serratia sp. RE1-2a", None, None, None) {
ParseResult::Informal(i) => {
assert_eq!(i.taxon, "Serratia");
assert_eq!(i.taxon_rank, Rank::Genus);
assert_eq!(i.rank, Rank::Species);
assert_eq!(i.phrase.as_deref(), Some("sp. RE1-2a"));
}
other => panic!("expected Informal, got {other:?}"),
}
match parse("Rhizobium sp.", None, None, None) {
ParseResult::Informal(i) => {
assert_eq!(i.taxon, "Rhizobium");
assert_eq!(i.taxon_rank, Rank::Genus);
assert_eq!(i.rank, Rank::Species);
assert_eq!(i.phrase.as_deref(), Some("sp."));
}
other => panic!("expected Informal, got {other:?}"),
}
match parse("Allium sp. 1", None, None, None) {
ParseResult::Informal(i) => {
assert_eq!(i.taxon, "Allium");
assert_eq!(i.phrase.as_deref(), Some("sp. 1"));
}
other => panic!("expected Informal, got {other:?}"),
}
assert!(
matches!(
parse("Salix alba subsp. B", None, None, None),
ParseResult::Parsed(_)
),
"infraspecific-indet binomial must stay Parsed"
);
match parse("Salicornia cf. patula", None, None, None) {
ParseResult::Parsed(pn) => assert_eq!(pn.specific_epithet.as_deref(), Some("patula")),
other => panic!("expected Parsed, got {other:?}"),
}
assert!(parse("Abies alba", None, None, None).is_parsable());
assert!(parse("Rhizobium", None, None, None).is_parsable());
match parse("", None, None, None) {
ParseResult::Unparsable(e) => assert_eq!(e.type_, NameType::Other),
other => panic!("expected Unparsable, got {other:?}"),
}
}
#[test]
fn clamped_to_unparsable_forces_a_nonparsable_type() {
use model::{NomCode, ParseError};
let clamped = ParseError::new(NameType::Informal, Some(NomCode::Bacterial), "X group")
.clamped_to_unparsable();
assert_eq!(clamped.type_, NameType::Other);
assert!(!clamped.type_.is_parsable());
assert_eq!(clamped.code, Some(NomCode::Bacterial));
assert_eq!(clamped.message, "Unparsable OTHER name: X group");
let other = ParseError::new(NameType::Other, None, "junk");
assert_eq!(other.clone().clamped_to_unparsable(), other);
match parse("Amauropeltoid clade", None, None, None) {
ParseResult::Unparsable(e) => assert_eq!(e.type_, NameType::Other),
other => panic!("expected Unparsable(OTHER), got {other:?}"),
}
}
}