1use serde::Serialize;
3use std::collections::{HashMap, HashSet};
4use std::sync::LazyLock;
5
6#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
8#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
9pub enum NameType {
10 Scientific,
11 Formula,
12 Informal,
13 Placeholder,
14 Identifier,
22 Other,
23}
24
25impl NameType {
26 pub fn is_parsable(&self) -> bool {
31 matches!(self, NameType::Scientific | NameType::Informal)
32 }
33}
34
35#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize)]
44#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
45pub enum NomCode {
46 Bacterial,
47 Botanical,
48 Cultivars,
49 Phyto,
50 Virus,
51 Zoological,
52 Phylo,
53}
54
55#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize)]
62#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
63pub enum NamePart {
64 Generic,
65 Infrageneric,
66 Specific,
67 Infraspecific,
68}
69
70#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
72#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
73pub enum State {
74 Complete,
75 Partial,
76 None,
77}
78
79#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize)]
111#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
112pub enum Rank {
113 Superdomain,
114 Domain,
115 Subdomain,
116 Infradomain,
117 Empire,
118 Realm,
119 Subrealm,
120 Superkingdom,
121 Kingdom,
122 Subkingdom,
123 Infrakingdom,
124 Superphylum,
125 Phylum,
126 Subphylum,
127 Infraphylum,
128 Parvphylum,
129 Microphylum,
130 Nanophylum,
131 Claudius,
132 Gigaclass,
133 Megaclass,
134 Superclass,
135 Class,
136 Subclass,
137 Infraclass,
138 Subterclass,
139 Parvclass,
140 Superdivision,
141 DivisionZoology,
142 Subdivision,
143 Infradivision,
144 Superlegion,
145 Legion,
146 Sublegion,
147 Infralegion,
148 Megacohort,
149 Supercohort,
150 Cohort,
151 Subcohort,
152 Infracohort,
153 Gigaorder,
154 Magnorder,
155 Grandorder,
156 Mirorder,
157 Superorder,
158 Order,
159 Nanorder,
160 Hypoorder,
161 Minorder,
162 Suborder,
163 Infraorder,
164 Parvorder,
165 SupersectionZoology,
166 SectionZoology,
167 SubsectionZoology,
168 SuperseriesZoology,
169 SeriesZoology,
170 SubseriesZoology,
171 Falanx,
172 Gigafamily,
173 Megafamily,
174 Grandfamily,
175 Superfamily,
176 Epifamily,
177 Family,
178 Subfamily,
179 Infrafamily,
180 Supertribe,
181 Tribe,
182 Subtribe,
183 Infratribe,
184 SupragenericName,
185 Supergenus,
186 Genus,
187 Subgenus,
188 Infragenus,
189 DivisionBotany,
190 SupersectionBotany,
191 SectionBotany,
192 SubsectionBotany,
193 SuperseriesBotany,
194 SeriesBotany,
195 SubseriesBotany,
196 InfragenericName,
197 SpeciesAggregate,
198 Species,
199 InfraspecificName,
200 Grex,
201 Klepton,
202 Subspecies,
203 CultivarGroup,
204 Convariety,
205 InfrasubspecificName,
206 Proles,
207 Natio,
208 Aberration,
209 Morph,
210 Supervariety,
211 Variety,
212 Subvariety,
213 Superform,
214 Form,
215 Subform,
216 Pathovar,
217 Biovar,
218 Chemovar,
219 Morphovar,
220 Phagovar,
221 Serovar,
222 Chemoform,
223 FormaSpecialis,
224 Lusus,
225 Cultivar,
226 Mutatio,
227 Strain,
228 Other,
229 Unranked,
230}
231
232const UNCOMPARABLE_RANKS: [Rank; 6] = [
236 Rank::SupragenericName,
237 Rank::InfragenericName,
238 Rank::InfraspecificName,
239 Rank::InfrasubspecificName,
240 Rank::Other,
241 Rank::Unranked,
242];
243
244const LEGACY_RANKS: [Rank; 8] = [
247 Rank::Morph,
248 Rank::Aberration,
249 Rank::Natio,
250 Rank::Proles,
251 Rank::Convariety,
252 Rank::Klepton,
253 Rank::Falanx,
254 Rank::Lusus,
255];
256
257const MAJOR_RANK_PREFIXES: [&str; 16] = [
269 "SUPER", "SUBTER", "SUB", "INFRA", "MICRO", "NANO", "GIGA", "MAGN", "GRAND", "MIR", "NAN",
270 "HYPO", "MIN", "PARV", "MEGA", "EPI",
271];
272
273fn strip_major_rank_prefix(name: &str) -> Option<&str> {
277 for prefix in MAJOR_RANK_PREFIXES {
278 if let Some(rest) = name.strip_prefix(prefix) {
279 return Some(rest);
280 }
281 }
282 None
283}
284
285fn rank_wire_name(rank: Rank) -> String {
291 serde_json::to_string(&rank)
292 .expect("Rank always serializes to a JSON string")
293 .trim_matches('"')
294 .to_string()
295}
296
297static MAJOR_RANKS: LazyLock<HashMap<Rank, Rank>> = LazyLock::new(|| {
304 let name_to_rank: HashMap<String, Rank> =
305 Rank::ALL.iter().map(|&r| (rank_wire_name(r), r)).collect();
306
307 let mut map = HashMap::with_capacity(Rank::ALL.len());
308 for &r in Rank::ALL.iter() {
309 let major = if r.is_infraspecific() {
310 Rank::InfraspecificName
311 } else {
312 strip_major_rank_prefix(&rank_wire_name(r))
313 .and_then(|rest| name_to_rank.get(rest))
314 .copied()
315 .unwrap_or(r)
316 };
317 map.insert(r, major);
318 }
319 map.insert(Rank::Nanorder, Rank::Order);
325 map.insert(Rank::SpeciesAggregate, Rank::Species);
326 map.insert(Rank::InfragenericName, Rank::Genus);
327 map.insert(Rank::Superdivision, Rank::DivisionZoology);
328 map.insert(Rank::Subdivision, Rank::DivisionZoology);
329 map.insert(Rank::Infradivision, Rank::DivisionZoology);
330 map
331});
332
333static AMBIGUOUS_MARKER: LazyLock<HashSet<Rank>> = LazyLock::new(|| {
339 let mut ambiguous = HashSet::new();
340 let mut seen: HashMap<&'static str, Rank> = HashMap::new();
341 for &r in Rank::ALL.iter() {
342 if let Some(marker) = r.marker() {
343 if let Some(&earlier) = seen.get(marker) {
344 ambiguous.insert(r);
345 ambiguous.insert(earlier);
346 } else {
347 seen.insert(marker, r);
348 }
349 }
350 }
351 ambiguous
352});
353
354impl Rank {
355 pub const ALL: [Rank; 117] = [
360 Rank::Superdomain,
361 Rank::Domain,
362 Rank::Subdomain,
363 Rank::Infradomain,
364 Rank::Empire,
365 Rank::Realm,
366 Rank::Subrealm,
367 Rank::Superkingdom,
368 Rank::Kingdom,
369 Rank::Subkingdom,
370 Rank::Infrakingdom,
371 Rank::Superphylum,
372 Rank::Phylum,
373 Rank::Subphylum,
374 Rank::Infraphylum,
375 Rank::Parvphylum,
376 Rank::Microphylum,
377 Rank::Nanophylum,
378 Rank::Claudius,
379 Rank::Gigaclass,
380 Rank::Megaclass,
381 Rank::Superclass,
382 Rank::Class,
383 Rank::Subclass,
384 Rank::Infraclass,
385 Rank::Subterclass,
386 Rank::Parvclass,
387 Rank::Superdivision,
388 Rank::DivisionZoology,
389 Rank::Subdivision,
390 Rank::Infradivision,
391 Rank::Superlegion,
392 Rank::Legion,
393 Rank::Sublegion,
394 Rank::Infralegion,
395 Rank::Megacohort,
396 Rank::Supercohort,
397 Rank::Cohort,
398 Rank::Subcohort,
399 Rank::Infracohort,
400 Rank::Gigaorder,
401 Rank::Magnorder,
402 Rank::Grandorder,
403 Rank::Mirorder,
404 Rank::Superorder,
405 Rank::Order,
406 Rank::Nanorder,
407 Rank::Hypoorder,
408 Rank::Minorder,
409 Rank::Suborder,
410 Rank::Infraorder,
411 Rank::Parvorder,
412 Rank::SupersectionZoology,
413 Rank::SectionZoology,
414 Rank::SubsectionZoology,
415 Rank::SuperseriesZoology,
416 Rank::SeriesZoology,
417 Rank::SubseriesZoology,
418 Rank::Falanx,
419 Rank::Gigafamily,
420 Rank::Megafamily,
421 Rank::Grandfamily,
422 Rank::Superfamily,
423 Rank::Epifamily,
424 Rank::Family,
425 Rank::Subfamily,
426 Rank::Infrafamily,
427 Rank::Supertribe,
428 Rank::Tribe,
429 Rank::Subtribe,
430 Rank::Infratribe,
431 Rank::SupragenericName,
432 Rank::Supergenus,
433 Rank::Genus,
434 Rank::Subgenus,
435 Rank::Infragenus,
436 Rank::DivisionBotany,
437 Rank::SupersectionBotany,
438 Rank::SectionBotany,
439 Rank::SubsectionBotany,
440 Rank::SuperseriesBotany,
441 Rank::SeriesBotany,
442 Rank::SubseriesBotany,
443 Rank::InfragenericName,
444 Rank::SpeciesAggregate,
445 Rank::Species,
446 Rank::InfraspecificName,
447 Rank::Grex,
448 Rank::Klepton,
449 Rank::Subspecies,
450 Rank::CultivarGroup,
451 Rank::Convariety,
452 Rank::InfrasubspecificName,
453 Rank::Proles,
454 Rank::Natio,
455 Rank::Aberration,
456 Rank::Morph,
457 Rank::Supervariety,
458 Rank::Variety,
459 Rank::Subvariety,
460 Rank::Superform,
461 Rank::Form,
462 Rank::Subform,
463 Rank::Pathovar,
464 Rank::Biovar,
465 Rank::Chemovar,
466 Rank::Morphovar,
467 Rank::Phagovar,
468 Rank::Serovar,
469 Rank::Chemoform,
470 Rank::FormaSpecialis,
471 Rank::Lusus,
472 Rank::Cultivar,
473 Rank::Mutatio,
474 Rank::Strain,
475 Rank::Other,
476 Rank::Unranked,
477 ];
478
479 pub const LINNEAN_RANKS: [Rank; 7] = [
482 Rank::Kingdom,
483 Rank::Phylum,
484 Rank::Class,
485 Rank::Order,
486 Rank::Family,
487 Rank::Genus,
488 Rank::Species,
489 ];
490
491 pub fn ordinal(&self) -> usize {
496 *self as usize
497 }
498
499 pub fn code(&self) -> Option<NomCode> {
508 match self {
509 Rank::Realm | Rank::Subrealm => Some(NomCode::Virus),
511 Rank::Parvphylum
513 | Rank::Microphylum
514 | Rank::Nanophylum
515 | Rank::Claudius
516 | Rank::Gigaclass
517 | Rank::Megaclass
518 | Rank::Subterclass
519 | Rank::Parvclass
520 | Rank::Superdivision
521 | Rank::DivisionZoology
522 | Rank::Subdivision
523 | Rank::Infradivision
524 | Rank::Superlegion
525 | Rank::Legion
526 | Rank::Sublegion
527 | Rank::Infralegion
528 | Rank::Megacohort
529 | Rank::Supercohort
530 | Rank::Cohort
531 | Rank::Subcohort
532 | Rank::Infracohort
533 | Rank::Gigaorder
534 | Rank::Magnorder
535 | Rank::Grandorder
536 | Rank::Mirorder
537 | Rank::Nanorder
538 | Rank::Hypoorder
539 | Rank::Minorder
540 | Rank::Parvorder
541 | Rank::SupersectionZoology
542 | Rank::SectionZoology
543 | Rank::SubsectionZoology
544 | Rank::SuperseriesZoology
545 | Rank::SeriesZoology
546 | Rank::SubseriesZoology
547 | Rank::Gigafamily
548 | Rank::Megafamily
549 | Rank::Grandfamily
550 | Rank::Epifamily
551 | Rank::Klepton
552 | Rank::Natio
553 | Rank::Aberration
554 | Rank::Morph
555 | Rank::Mutatio => Some(NomCode::Zoological),
556 Rank::DivisionBotany
558 | Rank::SupersectionBotany
559 | Rank::SectionBotany
560 | Rank::SubsectionBotany
561 | Rank::SuperseriesBotany
562 | Rank::SeriesBotany
563 | Rank::SubseriesBotany
564 | Rank::Proles
565 | Rank::FormaSpecialis
566 | Rank::Lusus => Some(NomCode::Botanical),
567 Rank::Grex | Rank::CultivarGroup | Rank::Convariety | Rank::Cultivar => {
569 Some(NomCode::Cultivars)
570 }
571 Rank::Pathovar
573 | Rank::Biovar
574 | Rank::Chemovar
575 | Rank::Morphovar
576 | Rank::Phagovar
577 | Rank::Serovar
578 | Rank::Chemoform => Some(NomCode::Bacterial),
579 Rank::Superdomain
581 | Rank::Domain
582 | Rank::Subdomain
583 | Rank::Infradomain
584 | Rank::Empire
585 | Rank::Superkingdom
586 | Rank::Kingdom
587 | Rank::Subkingdom
588 | Rank::Infrakingdom
589 | Rank::Superphylum
590 | Rank::Phylum
591 | Rank::Subphylum
592 | Rank::Infraphylum
593 | Rank::Superclass
594 | Rank::Class
595 | Rank::Subclass
596 | Rank::Infraclass
597 | Rank::Superorder
598 | Rank::Order
599 | Rank::Suborder
600 | Rank::Infraorder
601 | Rank::Falanx
602 | Rank::Superfamily
603 | Rank::Family
604 | Rank::Subfamily
605 | Rank::Infrafamily
606 | Rank::Supertribe
607 | Rank::Tribe
608 | Rank::Subtribe
609 | Rank::Infratribe
610 | Rank::SupragenericName
611 | Rank::Supergenus
612 | Rank::Genus
613 | Rank::Subgenus
614 | Rank::Infragenus
615 | Rank::InfragenericName
616 | Rank::SpeciesAggregate
617 | Rank::Species
618 | Rank::InfraspecificName
619 | Rank::Subspecies
620 | Rank::InfrasubspecificName
621 | Rank::Supervariety
622 | Rank::Variety
623 | Rank::Subvariety
624 | Rank::Superform
625 | Rank::Form
626 | Rank::Subform
627 | Rank::Strain
628 | Rank::Other
629 | Rank::Unranked => None,
630 }
631 }
632
633 pub fn is_restricted_to_code(&self) -> Option<NomCode> {
637 self.code()
638 }
639
640 pub fn marker(&self) -> Option<&'static str> {
647 match self {
648 Rank::Superdomain => Some("superdom."),
649 Rank::Domain => Some("dom."),
650 Rank::Subdomain => Some("subdom."),
651 Rank::Infradomain => Some("infradom."),
652 Rank::Empire => Some("imp."),
653 Rank::Realm => Some("realm"),
654 Rank::Subrealm => Some("subrealm"),
655 Rank::Superkingdom => Some("superreg."),
656 Rank::Kingdom => Some("regn."),
657 Rank::Subkingdom => Some("subreg."),
658 Rank::Infrakingdom => Some("infrareg."),
659 Rank::Superphylum => Some("superphyl."),
660 Rank::Phylum => Some("phyl."),
661 Rank::Subphylum => Some("subphyl."),
662 Rank::Infraphylum => Some("infraphyl."),
663 Rank::Parvphylum => Some("parvphyl."),
664 Rank::Microphylum => Some("microphyl."),
665 Rank::Nanophylum => Some("nanophyl."),
666 Rank::Claudius => Some("claud."),
667 Rank::Gigaclass => Some("gigacl."),
668 Rank::Megaclass => Some("megacl."),
669 Rank::Superclass => Some("supercl."),
670 Rank::Class => Some("cl."),
671 Rank::Subclass => Some("subcl."),
672 Rank::Infraclass => Some("infracl."),
673 Rank::Subterclass => Some("subtercl."),
674 Rank::Parvclass => Some("parvcl."),
675 Rank::Superdivision => Some("superdiv."),
676 Rank::DivisionZoology | Rank::DivisionBotany => Some("div."),
677 Rank::Subdivision => Some("subdiv."),
678 Rank::Infradivision => Some("infradiv."),
679 Rank::Superlegion => Some("superleg."),
680 Rank::Legion => Some("leg."),
681 Rank::Sublegion => Some("subleg."),
682 Rank::Infralegion => Some("infraleg."),
683 Rank::Megacohort => Some("megacohort"),
684 Rank::Supercohort => Some("supercohort"),
685 Rank::Cohort => Some("cohort"),
686 Rank::Subcohort => Some("subcohort"),
687 Rank::Infracohort => Some("infracohort"),
688 Rank::Gigaorder => Some("gigaord."),
689 Rank::Magnorder => Some("magnord."),
690 Rank::Grandorder => Some("grandord."),
691 Rank::Mirorder => Some("mirord."),
692 Rank::Superorder => Some("superord."),
693 Rank::Order => Some("ord."),
694 Rank::Nanorder => Some("nanord."),
695 Rank::Hypoorder => Some("hypoord."),
696 Rank::Minorder => Some("minord."),
697 Rank::Suborder => Some("subord."),
698 Rank::Infraorder => Some("infraord."),
699 Rank::Parvorder => Some("parvord."),
700 Rank::SupersectionZoology | Rank::SupersectionBotany => Some("supersect."),
701 Rank::SectionZoology | Rank::SectionBotany => Some("sect."),
702 Rank::SubsectionZoology | Rank::SubsectionBotany => Some("subsect."),
703 Rank::SuperseriesZoology | Rank::SuperseriesBotany => Some("superser."),
704 Rank::SeriesZoology | Rank::SeriesBotany => Some("ser."),
705 Rank::SubseriesZoology | Rank::SubseriesBotany => Some("subser."),
706 Rank::Falanx => Some("falanx"),
707 Rank::Gigafamily => Some("gigafam."),
708 Rank::Megafamily => Some("megafam."),
709 Rank::Grandfamily => Some("grandfam."),
710 Rank::Superfamily => Some("superfam."),
711 Rank::Epifamily => Some("epifam."),
712 Rank::Family => Some("fam."),
713 Rank::Subfamily => Some("subfam."),
714 Rank::Infrafamily => Some("infrafam."),
715 Rank::Supertribe => Some("supertrib."),
716 Rank::Tribe => Some("trib."),
717 Rank::Subtribe => Some("subtrib."),
718 Rank::Infratribe => Some("infratrib."),
719 Rank::SupragenericName => Some("supragen."),
720 Rank::Supergenus => Some("supergen."),
721 Rank::Genus => Some("gen."),
722 Rank::Subgenus => Some("subgen."),
723 Rank::Infragenus => Some("infrag."),
724 Rank::InfragenericName => Some("infragen."),
725 Rank::SpeciesAggregate => Some("agg."),
726 Rank::Species => Some("sp."),
727 Rank::InfraspecificName => Some("infrasp."),
728 Rank::Grex => Some("gx"),
729 Rank::Klepton => Some("klepton"),
730 Rank::Subspecies => Some("subsp."),
731 Rank::Convariety => Some("convar."),
732 Rank::InfrasubspecificName => Some("infrasubsp."),
733 Rank::Proles => Some("prol."),
734 Rank::Natio => Some("natio"),
735 Rank::Aberration => Some("ab."),
736 Rank::Morph => Some("morph"),
737 Rank::Supervariety => Some("supervar."),
738 Rank::Variety => Some("var."),
739 Rank::Subvariety => Some("subvar."),
740 Rank::Superform => Some("superf."),
741 Rank::Form => Some("f."),
742 Rank::Subform => Some("subf."),
743 Rank::Pathovar => Some("pv."),
744 Rank::Biovar => Some("biovar"),
745 Rank::Chemovar => Some("chemovar"),
746 Rank::Morphovar => Some("morphovar"),
747 Rank::Phagovar => Some("phagovar"),
748 Rank::Serovar => Some("serovar"),
749 Rank::Chemoform => Some("chemoform"),
750 Rank::FormaSpecialis => Some("f.sp."),
751 Rank::Lusus => Some("lusus"),
752 Rank::Cultivar => Some("cv."),
753 Rank::Mutatio => Some("mut."),
754 Rank::Strain => Some("strain"),
755 Rank::CultivarGroup | Rank::Other | Rank::Unranked => None,
756 }
757 }
758
759 pub fn plural(&self) -> Option<&'static str> {
769 match self {
770 Rank::Superdomain => Some("superdomains"),
771 Rank::Domain => Some("domains"),
772 Rank::Subdomain => Some("subdomains"),
773 Rank::Infradomain => Some("infradomains"),
774 Rank::Empire => Some("empires"),
775 Rank::Realm => Some("realms"),
776 Rank::Subrealm => Some("subrealms"),
777 Rank::Superkingdom => Some("superkingdoms"),
778 Rank::Kingdom => Some("kingdoms"),
779 Rank::Subkingdom => Some("subkingdoms"),
780 Rank::Infrakingdom => Some("infrakingdoms"),
781 Rank::Superphylum => Some("superphyla"),
782 Rank::Phylum => Some("phyla"),
783 Rank::Subphylum => Some("subphyla"),
784 Rank::Infraphylum => Some("infraphyla"),
785 Rank::Parvphylum => Some("parvphyla"),
786 Rank::Microphylum => Some("microphyla"),
787 Rank::Nanophylum => Some("nanophyla"),
788 Rank::Claudius => Some("claudius"),
789 Rank::Gigaclass => Some("gigaclasses"),
790 Rank::Megaclass => Some("megaclasses"),
791 Rank::Superclass => Some("superclasses"),
792 Rank::Class => Some("classes"),
793 Rank::Subclass => Some("subclasses"),
794 Rank::Infraclass => Some("infraclasses"),
795 Rank::Subterclass => Some("subterclasses"),
796 Rank::Parvclass => Some("parvclasses"),
797 Rank::Superdivision => Some("superdivisions"),
798 Rank::DivisionZoology => Some("division_zoologys"),
799 Rank::Subdivision => Some("subdivisions"),
800 Rank::Infradivision => Some("infradivisions"),
801 Rank::Superlegion => Some("superlegions"),
802 Rank::Legion => Some("legions"),
803 Rank::Sublegion => Some("sublegions"),
804 Rank::Infralegion => Some("infralegions"),
805 Rank::Megacohort => Some("megacohorts"),
806 Rank::Supercohort => Some("supercohorts"),
807 Rank::Cohort => Some("cohorts"),
808 Rank::Subcohort => Some("subcohorts"),
809 Rank::Infracohort => Some("infracohorts"),
810 Rank::Gigaorder => Some("gigaorders"),
811 Rank::Magnorder => Some("magnorders"),
812 Rank::Grandorder => Some("grandorders"),
813 Rank::Mirorder => Some("mirorders"),
814 Rank::Superorder => Some("superorders"),
815 Rank::Order => Some("orders"),
816 Rank::Nanorder => Some("nanorders"),
817 Rank::Hypoorder => Some("hypoorders"),
818 Rank::Minorder => Some("minorders"),
819 Rank::Suborder => Some("suborders"),
820 Rank::Infraorder => Some("infraorders"),
821 Rank::Parvorder => Some("parvorders"),
822 Rank::SupersectionZoology => Some("supersection_zoologys"),
823 Rank::SectionZoology => Some("section_zoologys"),
824 Rank::SubsectionZoology => Some("subsection_zoologys"),
825 Rank::SuperseriesZoology | Rank::SuperseriesBotany => Some("superseries"),
826 Rank::SeriesZoology | Rank::SeriesBotany => Some("series"),
827 Rank::SubseriesZoology | Rank::SubseriesBotany => Some("subseries"),
828 Rank::Falanx => Some("falanges"),
829 Rank::Gigafamily => Some("gigafamilies"),
830 Rank::Megafamily => Some("megafamilies"),
831 Rank::Grandfamily => Some("grandfamilies"),
832 Rank::Superfamily => Some("superfamilies"),
833 Rank::Epifamily => Some("epifamilies"),
834 Rank::Family => Some("families"),
835 Rank::Subfamily => Some("subfamilies"),
836 Rank::Infrafamily => Some("infrafamilies"),
837 Rank::Supertribe => Some("supertribes"),
838 Rank::Tribe => Some("tribes"),
839 Rank::Subtribe => Some("subtribes"),
840 Rank::Infratribe => Some("infratribes"),
841 Rank::SupragenericName => Some("suprageneric_names"),
842 Rank::Supergenus => Some("supergenera"),
843 Rank::Genus => Some("genera"),
844 Rank::Subgenus => Some("subgenera"),
845 Rank::Infragenus => Some("infragenera"),
846 Rank::DivisionBotany => Some("divisions"),
847 Rank::SupersectionBotany => Some("supersection_botanys"),
848 Rank::SectionBotany => Some("section_botanys"),
849 Rank::SubsectionBotany => Some("subsection_botanys"),
850 Rank::InfragenericName => Some("infrageneric_names"),
851 Rank::SpeciesAggregate => Some("species_aggregates"),
852 Rank::Species => Some("species"),
853 Rank::InfraspecificName => Some("infraspecific_names"),
854 Rank::Grex => Some("grexs"),
855 Rank::Klepton => Some("kleptons"),
856 Rank::Subspecies => Some("subspecies"),
857 Rank::Convariety => Some("convarieties"),
858 Rank::InfrasubspecificName => Some("infrasubspecific_names"),
859 Rank::Proles => Some("proles"),
860 Rank::Natio => Some("natios"),
861 Rank::Aberration => Some("aberrations"),
862 Rank::Morph => Some("morphs"),
863 Rank::Supervariety => Some("supervarieties"),
864 Rank::Variety => Some("varieties"),
865 Rank::Subvariety => Some("subvarieties"),
866 Rank::Superform => Some("superforms"),
867 Rank::Form => Some("forms"),
868 Rank::Subform => Some("subforms"),
869 Rank::Pathovar => Some("pathovars"),
870 Rank::Biovar => Some("biovars"),
871 Rank::Chemovar => Some("chemovars"),
872 Rank::Morphovar => Some("morphovars"),
873 Rank::Phagovar => Some("phagovars"),
874 Rank::Serovar => Some("serovars"),
875 Rank::Chemoform => Some("chemoforms"),
876 Rank::FormaSpecialis => Some("forma_specialiss"),
877 Rank::Lusus => Some("lusi"),
878 Rank::Cultivar => Some("cultivars"),
879 Rank::Mutatio => Some("mutatios"),
880 Rank::Strain => Some("strains"),
881 Rank::CultivarGroup | Rank::Other | Rank::Unranked => None,
882 }
883 }
884
885 pub fn has_ambiguous_marker(&self) -> bool {
887 AMBIGUOUS_MARKER.contains(self)
888 }
889
890 pub fn not_other_or_unranked(&self) -> bool {
892 *self != Rank::Other && *self != Rank::Unranked
893 }
894
895 pub fn other_or_unranked(&self) -> bool {
897 !self.not_other_or_unranked()
898 }
899
900 pub fn is_infraspecific(&self) -> bool {
903 self.ordinal() > Rank::Species.ordinal() && self.not_other_or_unranked()
904 }
905
906 pub fn is_infrageneric(&self) -> bool {
910 self.ordinal() > Rank::Genus.ordinal() && self.not_other_or_unranked()
911 }
912
913 pub fn is_infrageneric_strictly(&self) -> bool {
918 self.is_infrageneric() && self.ordinal() < Rank::SpeciesAggregate.ordinal()
919 }
920
921 pub fn is_linnean(&self) -> bool {
923 Self::LINNEAN_RANKS.contains(self)
924 }
925
926 pub fn get_major_rank(&self) -> Rank {
932 *MAJOR_RANKS
933 .get(self)
934 .expect("MAJOR_RANKS is populated for every Rank in Rank::ALL")
935 }
936
937 pub fn is_species_or_below(&self) -> bool {
939 self.ordinal() >= Rank::SpeciesAggregate.ordinal() && self.not_other_or_unranked()
940 }
941
942 pub fn is_family_group(&self) -> bool {
945 Rank::Gigafamily.ordinal() <= self.ordinal()
946 && self.ordinal() < Rank::SupragenericName.ordinal()
947 }
948
949 pub fn is_genus_group(&self) -> bool {
952 Rank::Supergenus.ordinal() <= self.ordinal()
953 && self.ordinal() < Rank::SpeciesAggregate.ordinal()
954 }
955
956 pub fn is_suprageneric(&self) -> bool {
958 self.ordinal() < Rank::Genus.ordinal()
959 }
960
961 pub fn is_uncomparable(&self) -> bool {
963 UNCOMPARABLE_RANKS.contains(self)
964 }
965
966 pub fn is_legacy(&self) -> bool {
968 LEGACY_RANKS.contains(self)
969 }
970
971 pub fn higher_than(&self, other: Rank) -> bool {
975 self.ordinal() < other.ordinal() && other.not_other_or_unranked()
976 }
977
978 pub fn lower_than(&self, other: Rank) -> bool {
982 self.ordinal() > other.ordinal() && self.not_other_or_unranked()
983 }
984}
985
986impl Rank {
993 pub fn from_name(name: &str) -> Option<Rank> {
1002 Rank::ALL
1003 .iter()
1004 .copied()
1005 .find(|&r| rank_wire_name(r) == name)
1006 }
1007}
1008
1009impl NomCode {
1010 pub fn from_name(name: &str) -> Option<NomCode> {
1019 match name {
1020 "BACTERIAL" => Some(NomCode::Bacterial),
1021 "BOTANICAL" => Some(NomCode::Botanical),
1022 "CULTIVARS" => Some(NomCode::Cultivars),
1023 "PHYTO" => Some(NomCode::Phyto),
1024 "VIRUS" => Some(NomCode::Virus),
1025 "ZOOLOGICAL" => Some(NomCode::Zoological),
1026 "PHYLO" => Some(NomCode::Phylo),
1027 _ => None,
1028 }
1029 }
1030}
1031
1032pub mod rank_utils {
1046 use super::{NomCode, Rank};
1047
1048 pub fn suffices_rank_map(code: NomCode) -> Option<&'static [(&'static str, Rank)]> {
1062 match code {
1063 NomCode::Bacterial => Some(&[
1064 ("oideae", Rank::Subfamily),
1065 ("aceae", Rank::Family),
1066 ("ineae", Rank::Suborder),
1067 ("ales", Rank::Order),
1068 ("idae", Rank::Subclass),
1069 ("inae", Rank::Subtribe),
1070 ("eae", Rank::Tribe),
1071 ("ia", Rank::Class),
1072 ]),
1073 NomCode::Botanical => Some(&[
1074 ("mycetidae", Rank::Subclass),
1075 ("phycidae", Rank::Subclass),
1076 ("mycotina", Rank::Subphylum),
1077 ("phytina", Rank::Subphylum),
1078 ("mycetes", Rank::Class),
1079 ("phyceae", Rank::Class),
1080 ("mycota", Rank::Phylum),
1081 ("opsida", Rank::Class),
1082 ("oideae", Rank::Subfamily),
1083 ("phyta", Rank::Phylum),
1084 ("ineae", Rank::Suborder),
1085 ("aceae", Rank::Family),
1086 ("idae", Rank::Subclass),
1087 ("anae", Rank::Superorder),
1088 ("acea", Rank::Superfamily),
1089 ("aria", Rank::Infraorder),
1090 ("ales", Rank::Order),
1091 ("inae", Rank::Subtribe),
1092 ("eae", Rank::Tribe),
1093 ]),
1094 NomCode::Zoological => Some(&[
1095 ("oidea", Rank::Superfamily),
1096 ("oidae", Rank::Epifamily),
1097 ("idae", Rank::Family),
1098 ("inae", Rank::Subfamily),
1099 ("ini", Rank::Tribe),
1100 ("ina", Rank::Subtribe),
1101 ]),
1102 NomCode::Virus => Some(&[
1103 ("viricetidae", Rank::Subclass),
1104 ("viricotina", Rank::Subphylum),
1105 ("viricetes", Rank::Class),
1106 ("viricota", Rank::Phylum),
1107 ("virineae", Rank::Suborder),
1108 ("virites", Rank::Subkingdom),
1109 ("virales", Rank::Order),
1110 ("viridae", Rank::Family),
1111 ("virinae", Rank::Subfamily),
1112 ("viriae", Rank::Kingdom),
1113 ("viria", Rank::Realm),
1114 ("vira", Rank::Subrealm),
1115 ]),
1116 NomCode::Cultivars | NomCode::Phyto | NomCode::Phylo => None,
1117 }
1118 }
1119}
1120
1121pub mod warnings {
1126 pub const NULL_EPITHET: &str = "epithet with literal value null";
1127 pub const HOMOGLYHPS: &str = "homoglyphs replaced";
1129 pub const UNUSUAL_CHARACTERS: &str = "unusual characters";
1130 pub const SUBSPECIES_ASSIGNED: &str =
1131 "Name was considered species but contains infraspecific epithet";
1132 pub const LC_MONOMIAL: &str = "lower case monomial match";
1133 pub const INDETERMINED: &str = "indetermined name missing its terminal epithet";
1134 pub const HIGHER_RANK_BINOMIAL: &str = "binomial with rank higher than species aggregate";
1135 pub const QUESTION_MARKS_REMOVED: &str = "question marks removed";
1136 pub const REPL_ENCLOSING_QUOTE: &str = "removed enclosing quotes";
1137 pub const MISSING_GENUS: &str = "epithet without genus";
1138 pub const DOUBTFUL_GENUS: &str = "genus quoted or in square brackets";
1139 pub const RANK_MISMATCH: &str = "rank does not fit the parsed name";
1140 pub const CODE_MISMATCH: &str = "nomenclatural code does not fit the parsed name";
1141 pub const HTML_ENTITIES: &str = "html entities unescaped";
1142 pub const XML_TAGS: &str = "xml tags removed";
1143 pub const BLACKLISTED_EPITHET: &str = "blacklisted epithet used";
1144 pub const NOMENCLATURAL_REFERENCE: &str = "nomenclatural reference removed";
1145 pub const AUTHORSHIP_REMOVED: &str = "authorship placeholder removed";
1146 pub const YEAR_INTERPRETED: &str =
1148 "authorship year was extract but originally was a year range or other form of year";
1149 pub const UNLIKELY_YEAR: &str = "unlikely authorship year";
1150 pub const UNCERTAIN_AUTHORSHIP: &str = "authorship marked as uncertain";
1151 pub const QUADRINOMIAL: &str = "name was quadrinomial";
1152 pub const ABBREVIATED_GENUS: &str = "abbreviated genus name";
1153 pub const ABBREVIATED_SUBGENUS: &str = "abbreviated subgenus name";
1154 pub const REMOVED_PREFIX: &str = "Removed: ";
1156 pub const LONG_NAME: &str = "unusually long name";
1157}
1158
1159#[cfg(test)]
1160mod tests {
1161 use super::*;
1162
1163 #[test]
1164 fn name_type_scientific_serializes_uppercase() {
1165 assert_eq!(
1166 serde_json::to_string(&NameType::Scientific).unwrap(),
1167 "\"SCIENTIFIC\""
1168 );
1169 }
1170
1171 #[test]
1172 fn name_type_first_and_last_variant() {
1173 assert_eq!(
1174 serde_json::to_string(&NameType::Scientific).unwrap(),
1175 "\"SCIENTIFIC\""
1176 );
1177 assert_eq!(
1178 serde_json::to_string(&NameType::Other).unwrap(),
1179 "\"OTHER\""
1180 );
1181 }
1182
1183 #[test]
1184 fn nom_code_first_last_and_zoological() {
1185 assert_eq!(
1186 serde_json::to_string(&NomCode::Bacterial).unwrap(),
1187 "\"BACTERIAL\""
1188 );
1189 assert_eq!(serde_json::to_string(&NomCode::Phylo).unwrap(), "\"PHYLO\"");
1190 assert_eq!(
1191 serde_json::to_string(&NomCode::Zoological).unwrap(),
1192 "\"ZOOLOGICAL\""
1193 );
1194 }
1195
1196 #[test]
1197 fn name_part_first_and_last_variant() {
1198 assert_eq!(
1199 serde_json::to_string(&NamePart::Generic).unwrap(),
1200 "\"GENERIC\""
1201 );
1202 assert_eq!(
1203 serde_json::to_string(&NamePart::Infraspecific).unwrap(),
1204 "\"INFRASPECIFIC\""
1205 );
1206 }
1207
1208 #[test]
1209 fn state_first_and_last_variant() {
1210 assert_eq!(
1211 serde_json::to_string(&State::Complete).unwrap(),
1212 "\"COMPLETE\""
1213 );
1214 assert_eq!(serde_json::to_string(&State::None).unwrap(), "\"NONE\"");
1215 }
1216
1217 #[test]
1218 fn rank_stub_unranked() {
1219 assert_eq!(
1220 serde_json::to_string(&Rank::Unranked).unwrap(),
1221 "\"UNRANKED\""
1222 );
1223 }
1224
1225 #[test]
1226 fn rank_stub_species_and_subspecies() {
1227 assert_eq!(
1228 serde_json::to_string(&Rank::Species).unwrap(),
1229 "\"SPECIES\""
1230 );
1231 assert_eq!(
1232 serde_json::to_string(&Rank::Subspecies).unwrap(),
1233 "\"SUBSPECIES\""
1234 );
1235 }
1236
1237 #[test]
1244 fn rank_stub_batch_2b_variants() {
1245 assert_eq!(serde_json::to_string(&Rank::Genus).unwrap(), "\"GENUS\"");
1246 assert_eq!(serde_json::to_string(&Rank::Family).unwrap(), "\"FAMILY\"");
1247 assert_eq!(
1248 serde_json::to_string(&Rank::Variety).unwrap(),
1249 "\"VARIETY\""
1250 );
1251 assert_eq!(serde_json::to_string(&Rank::Form).unwrap(), "\"FORM\"");
1252 assert_eq!(
1253 serde_json::to_string(&Rank::Cultivar).unwrap(),
1254 "\"CULTIVAR\""
1255 );
1256 assert_eq!(
1257 serde_json::to_string(&Rank::CultivarGroup).unwrap(),
1258 "\"CULTIVAR_GROUP\""
1259 );
1260 assert_eq!(serde_json::to_string(&Rank::Grex).unwrap(), "\"GREX\"");
1261 }
1262
1263 #[test]
1270 fn rank_stub_batch_2e_variants() {
1271 assert_eq!(
1272 serde_json::to_string(&Rank::Subfamily).unwrap(),
1273 "\"SUBFAMILY\""
1274 );
1275 assert_eq!(serde_json::to_string(&Rank::Tribe).unwrap(), "\"TRIBE\"");
1276 assert_eq!(
1277 serde_json::to_string(&Rank::Subtribe).unwrap(),
1278 "\"SUBTRIBE\""
1279 );
1280 assert_eq!(
1281 serde_json::to_string(&Rank::Supertribe).unwrap(),
1282 "\"SUPERTRIBE\""
1283 );
1284 assert_eq!(
1285 serde_json::to_string(&Rank::Infratribe).unwrap(),
1286 "\"INFRATRIBE\""
1287 );
1288 assert_eq!(
1289 serde_json::to_string(&Rank::Subgenus).unwrap(),
1290 "\"SUBGENUS\""
1291 );
1292 assert_eq!(
1293 serde_json::to_string(&Rank::SectionBotany).unwrap(),
1294 "\"SECTION_BOTANY\""
1295 );
1296 assert_eq!(
1297 serde_json::to_string(&Rank::SubsectionBotany).unwrap(),
1298 "\"SUBSECTION_BOTANY\""
1299 );
1300 assert_eq!(
1301 serde_json::to_string(&Rank::SupersectionBotany).unwrap(),
1302 "\"SUPERSECTION_BOTANY\""
1303 );
1304 assert_eq!(
1305 serde_json::to_string(&Rank::SeriesBotany).unwrap(),
1306 "\"SERIES_BOTANY\""
1307 );
1308 assert_eq!(
1309 serde_json::to_string(&Rank::SubseriesBotany).unwrap(),
1310 "\"SUBSERIES_BOTANY\""
1311 );
1312 assert_eq!(
1313 serde_json::to_string(&Rank::SuperseriesBotany).unwrap(),
1314 "\"SUPERSERIES_BOTANY\""
1315 );
1316 assert_eq!(
1317 serde_json::to_string(&Rank::SectionZoology).unwrap(),
1318 "\"SECTION_ZOOLOGY\""
1319 );
1320 assert_eq!(
1321 serde_json::to_string(&Rank::SubsectionZoology).unwrap(),
1322 "\"SUBSECTION_ZOOLOGY\""
1323 );
1324 assert_eq!(
1325 serde_json::to_string(&Rank::SupersectionZoology).unwrap(),
1326 "\"SUPERSECTION_ZOOLOGY\""
1327 );
1328 assert_eq!(
1329 serde_json::to_string(&Rank::SeriesZoology).unwrap(),
1330 "\"SERIES_ZOOLOGY\""
1331 );
1332 assert_eq!(
1333 serde_json::to_string(&Rank::SubseriesZoology).unwrap(),
1334 "\"SUBSERIES_ZOOLOGY\""
1335 );
1336 assert_eq!(
1337 serde_json::to_string(&Rank::SuperseriesZoology).unwrap(),
1338 "\"SUPERSERIES_ZOOLOGY\""
1339 );
1340 }
1341
1342 #[test]
1348 fn rank_stub_slice3_task1_variants() {
1349 assert_eq!(serde_json::to_string(&Rank::Other).unwrap(), "\"OTHER\"");
1350 assert_eq!(
1351 serde_json::to_string(&Rank::Subvariety).unwrap(),
1352 "\"SUBVARIETY\""
1353 );
1354 assert_eq!(
1355 serde_json::to_string(&Rank::Subform).unwrap(),
1356 "\"SUBFORM\""
1357 );
1358 assert_eq!(
1359 serde_json::to_string(&Rank::Pathovar).unwrap(),
1360 "\"PATHOVAR\""
1361 );
1362 assert_eq!(serde_json::to_string(&Rank::Biovar).unwrap(), "\"BIOVAR\"");
1363 assert_eq!(
1364 serde_json::to_string(&Rank::Chemoform).unwrap(),
1365 "\"CHEMOFORM\""
1366 );
1367 assert_eq!(
1368 serde_json::to_string(&Rank::Serovar).unwrap(),
1369 "\"SEROVAR\""
1370 );
1371 assert_eq!(serde_json::to_string(&Rank::Morph).unwrap(), "\"MORPH\"");
1372 assert_eq!(
1373 serde_json::to_string(&Rank::Morphovar).unwrap(),
1374 "\"MORPHOVAR\""
1375 );
1376 assert_eq!(
1377 serde_json::to_string(&Rank::Phagovar).unwrap(),
1378 "\"PHAGOVAR\""
1379 );
1380 assert_eq!(serde_json::to_string(&Rank::Natio).unwrap(), "\"NATIO\"");
1381 assert_eq!(
1382 serde_json::to_string(&Rank::Mutatio).unwrap(),
1383 "\"MUTATIO\""
1384 );
1385 assert_eq!(
1386 serde_json::to_string(&Rank::Convariety).unwrap(),
1387 "\"CONVARIETY\""
1388 );
1389 assert_eq!(serde_json::to_string(&Rank::Proles).unwrap(), "\"PROLES\"");
1390 assert_eq!(
1391 serde_json::to_string(&Rank::Aberration).unwrap(),
1392 "\"ABERRATION\""
1393 );
1394 assert_eq!(serde_json::to_string(&Rank::Strain).unwrap(), "\"STRAIN\"");
1395 assert_eq!(
1396 serde_json::to_string(&Rank::InfraspecificName).unwrap(),
1397 "\"INFRASPECIFIC_NAME\""
1398 );
1399 assert_eq!(
1400 serde_json::to_string(&Rank::DivisionBotany).unwrap(),
1401 "\"DIVISION_BOTANY\""
1402 );
1403 }
1404
1405 #[test]
1411 fn rank_stub_slice3_task3_variants() {
1412 assert_eq!(
1413 serde_json::to_string(&Rank::FormaSpecialis).unwrap(),
1414 "\"FORMA_SPECIALIS\""
1415 );
1416 assert_eq!(
1417 serde_json::to_string(&Rank::InfrasubspecificName).unwrap(),
1418 "\"INFRASUBSPECIFIC_NAME\""
1419 );
1420 assert_eq!(
1421 serde_json::to_string(&Rank::InfragenericName).unwrap(),
1422 "\"INFRAGENERIC_NAME\""
1423 );
1424 }
1425
1426 #[test]
1432 fn rank_code_matches_java_get_code() {
1433 assert_eq!(Rank::Unranked.code(), None);
1434 assert_eq!(Rank::Species.code(), None);
1435 assert_eq!(Rank::Subgenus.code(), None);
1436 assert_eq!(Rank::Tribe.code(), None);
1437 assert_eq!(Rank::Grex.code(), Some(NomCode::Cultivars));
1438 assert_eq!(Rank::CultivarGroup.code(), Some(NomCode::Cultivars));
1439 assert_eq!(Rank::Cultivar.code(), Some(NomCode::Cultivars));
1440 assert_eq!(Rank::SectionBotany.code(), Some(NomCode::Botanical));
1441 assert_eq!(Rank::SubsectionBotany.code(), Some(NomCode::Botanical));
1442 assert_eq!(Rank::SupersectionBotany.code(), Some(NomCode::Botanical));
1443 assert_eq!(Rank::SeriesBotany.code(), Some(NomCode::Botanical));
1444 assert_eq!(Rank::SubseriesBotany.code(), Some(NomCode::Botanical));
1445 assert_eq!(Rank::SuperseriesBotany.code(), Some(NomCode::Botanical));
1446 assert_eq!(Rank::SectionZoology.code(), Some(NomCode::Zoological));
1447 assert_eq!(Rank::SubsectionZoology.code(), Some(NomCode::Zoological));
1448 assert_eq!(Rank::SupersectionZoology.code(), Some(NomCode::Zoological));
1449 assert_eq!(Rank::SeriesZoology.code(), Some(NomCode::Zoological));
1450 assert_eq!(Rank::SubseriesZoology.code(), Some(NomCode::Zoological));
1451 assert_eq!(Rank::SuperseriesZoology.code(), Some(NomCode::Zoological));
1452 }
1453
1454 #[test]
1464 fn rank_code_matches_java_get_code_slice3_task1_variants() {
1465 assert_eq!(Rank::Pathovar.code(), Some(NomCode::Bacterial));
1466 assert_eq!(Rank::Biovar.code(), Some(NomCode::Bacterial));
1467 assert_eq!(Rank::Chemoform.code(), Some(NomCode::Bacterial));
1468 assert_eq!(Rank::Serovar.code(), Some(NomCode::Bacterial));
1469 assert_eq!(Rank::Morphovar.code(), Some(NomCode::Bacterial));
1470 assert_eq!(Rank::Phagovar.code(), Some(NomCode::Bacterial));
1471 assert_eq!(Rank::Morph.code(), Some(NomCode::Zoological));
1472 assert_eq!(Rank::Natio.code(), Some(NomCode::Zoological));
1473 assert_eq!(Rank::Mutatio.code(), Some(NomCode::Zoological));
1474 assert_eq!(Rank::Aberration.code(), Some(NomCode::Zoological));
1475 assert_eq!(Rank::Convariety.code(), Some(NomCode::Cultivars));
1476 assert_eq!(Rank::Proles.code(), Some(NomCode::Botanical));
1477 assert_eq!(Rank::DivisionBotany.code(), Some(NomCode::Botanical));
1478 assert_eq!(Rank::Other.code(), None);
1479 assert_eq!(Rank::Subvariety.code(), None);
1480 assert_eq!(Rank::Subform.code(), None);
1481 assert_eq!(Rank::Strain.code(), None);
1482 assert_eq!(Rank::InfraspecificName.code(), None);
1483 }
1484
1485 #[test]
1490 fn rank_code_matches_java_get_code_slice3_task3_variants() {
1491 assert_eq!(Rank::FormaSpecialis.code(), Some(NomCode::Botanical));
1492 assert_eq!(Rank::InfrasubspecificName.code(), None);
1493 assert_eq!(Rank::InfragenericName.code(), None);
1494 }
1495
1496 #[test]
1497 fn name_part_ord_matches_java_ordinal_order() {
1498 let mut parts = vec![
1499 NamePart::Infraspecific,
1500 NamePart::Generic,
1501 NamePart::Specific,
1502 NamePart::Infrageneric,
1503 ];
1504 parts.sort();
1505 assert_eq!(
1506 parts,
1507 vec![
1508 NamePart::Generic,
1509 NamePart::Infrageneric,
1510 NamePart::Specific,
1511 NamePart::Infraspecific,
1512 ]
1513 );
1514 }
1515
1516 #[test]
1529 fn rank_all_117_variants_in_java_declaration_order() {
1530 let expected: [(Rank, &str); 117] = [
1531 (Rank::Superdomain, "SUPERDOMAIN"),
1532 (Rank::Domain, "DOMAIN"),
1533 (Rank::Subdomain, "SUBDOMAIN"),
1534 (Rank::Infradomain, "INFRADOMAIN"),
1535 (Rank::Empire, "EMPIRE"),
1536 (Rank::Realm, "REALM"),
1537 (Rank::Subrealm, "SUBREALM"),
1538 (Rank::Superkingdom, "SUPERKINGDOM"),
1539 (Rank::Kingdom, "KINGDOM"),
1540 (Rank::Subkingdom, "SUBKINGDOM"),
1541 (Rank::Infrakingdom, "INFRAKINGDOM"),
1542 (Rank::Superphylum, "SUPERPHYLUM"),
1543 (Rank::Phylum, "PHYLUM"),
1544 (Rank::Subphylum, "SUBPHYLUM"),
1545 (Rank::Infraphylum, "INFRAPHYLUM"),
1546 (Rank::Parvphylum, "PARVPHYLUM"),
1547 (Rank::Microphylum, "MICROPHYLUM"),
1548 (Rank::Nanophylum, "NANOPHYLUM"),
1549 (Rank::Claudius, "CLAUDIUS"),
1550 (Rank::Gigaclass, "GIGACLASS"),
1551 (Rank::Megaclass, "MEGACLASS"),
1552 (Rank::Superclass, "SUPERCLASS"),
1553 (Rank::Class, "CLASS"),
1554 (Rank::Subclass, "SUBCLASS"),
1555 (Rank::Infraclass, "INFRACLASS"),
1556 (Rank::Subterclass, "SUBTERCLASS"),
1557 (Rank::Parvclass, "PARVCLASS"),
1558 (Rank::Superdivision, "SUPERDIVISION"),
1559 (Rank::DivisionZoology, "DIVISION_ZOOLOGY"),
1560 (Rank::Subdivision, "SUBDIVISION"),
1561 (Rank::Infradivision, "INFRADIVISION"),
1562 (Rank::Superlegion, "SUPERLEGION"),
1563 (Rank::Legion, "LEGION"),
1564 (Rank::Sublegion, "SUBLEGION"),
1565 (Rank::Infralegion, "INFRALEGION"),
1566 (Rank::Megacohort, "MEGACOHORT"),
1567 (Rank::Supercohort, "SUPERCOHORT"),
1568 (Rank::Cohort, "COHORT"),
1569 (Rank::Subcohort, "SUBCOHORT"),
1570 (Rank::Infracohort, "INFRACOHORT"),
1571 (Rank::Gigaorder, "GIGAORDER"),
1572 (Rank::Magnorder, "MAGNORDER"),
1573 (Rank::Grandorder, "GRANDORDER"),
1574 (Rank::Mirorder, "MIRORDER"),
1575 (Rank::Superorder, "SUPERORDER"),
1576 (Rank::Order, "ORDER"),
1577 (Rank::Nanorder, "NANORDER"),
1578 (Rank::Hypoorder, "HYPOORDER"),
1579 (Rank::Minorder, "MINORDER"),
1580 (Rank::Suborder, "SUBORDER"),
1581 (Rank::Infraorder, "INFRAORDER"),
1582 (Rank::Parvorder, "PARVORDER"),
1583 (Rank::SupersectionZoology, "SUPERSECTION_ZOOLOGY"),
1584 (Rank::SectionZoology, "SECTION_ZOOLOGY"),
1585 (Rank::SubsectionZoology, "SUBSECTION_ZOOLOGY"),
1586 (Rank::SuperseriesZoology, "SUPERSERIES_ZOOLOGY"),
1587 (Rank::SeriesZoology, "SERIES_ZOOLOGY"),
1588 (Rank::SubseriesZoology, "SUBSERIES_ZOOLOGY"),
1589 (Rank::Falanx, "FALANX"),
1590 (Rank::Gigafamily, "GIGAFAMILY"),
1591 (Rank::Megafamily, "MEGAFAMILY"),
1592 (Rank::Grandfamily, "GRANDFAMILY"),
1593 (Rank::Superfamily, "SUPERFAMILY"),
1594 (Rank::Epifamily, "EPIFAMILY"),
1595 (Rank::Family, "FAMILY"),
1596 (Rank::Subfamily, "SUBFAMILY"),
1597 (Rank::Infrafamily, "INFRAFAMILY"),
1598 (Rank::Supertribe, "SUPERTRIBE"),
1599 (Rank::Tribe, "TRIBE"),
1600 (Rank::Subtribe, "SUBTRIBE"),
1601 (Rank::Infratribe, "INFRATRIBE"),
1602 (Rank::SupragenericName, "SUPRAGENERIC_NAME"),
1603 (Rank::Supergenus, "SUPERGENUS"),
1604 (Rank::Genus, "GENUS"),
1605 (Rank::Subgenus, "SUBGENUS"),
1606 (Rank::Infragenus, "INFRAGENUS"),
1607 (Rank::DivisionBotany, "DIVISION_BOTANY"),
1608 (Rank::SupersectionBotany, "SUPERSECTION_BOTANY"),
1609 (Rank::SectionBotany, "SECTION_BOTANY"),
1610 (Rank::SubsectionBotany, "SUBSECTION_BOTANY"),
1611 (Rank::SuperseriesBotany, "SUPERSERIES_BOTANY"),
1612 (Rank::SeriesBotany, "SERIES_BOTANY"),
1613 (Rank::SubseriesBotany, "SUBSERIES_BOTANY"),
1614 (Rank::InfragenericName, "INFRAGENERIC_NAME"),
1615 (Rank::SpeciesAggregate, "SPECIES_AGGREGATE"),
1616 (Rank::Species, "SPECIES"),
1617 (Rank::InfraspecificName, "INFRASPECIFIC_NAME"),
1618 (Rank::Grex, "GREX"),
1619 (Rank::Klepton, "KLEPTON"),
1620 (Rank::Subspecies, "SUBSPECIES"),
1621 (Rank::CultivarGroup, "CULTIVAR_GROUP"),
1622 (Rank::Convariety, "CONVARIETY"),
1623 (Rank::InfrasubspecificName, "INFRASUBSPECIFIC_NAME"),
1624 (Rank::Proles, "PROLES"),
1625 (Rank::Natio, "NATIO"),
1626 (Rank::Aberration, "ABERRATION"),
1627 (Rank::Morph, "MORPH"),
1628 (Rank::Supervariety, "SUPERVARIETY"),
1629 (Rank::Variety, "VARIETY"),
1630 (Rank::Subvariety, "SUBVARIETY"),
1631 (Rank::Superform, "SUPERFORM"),
1632 (Rank::Form, "FORM"),
1633 (Rank::Subform, "SUBFORM"),
1634 (Rank::Pathovar, "PATHOVAR"),
1635 (Rank::Biovar, "BIOVAR"),
1636 (Rank::Chemovar, "CHEMOVAR"),
1637 (Rank::Morphovar, "MORPHOVAR"),
1638 (Rank::Phagovar, "PHAGOVAR"),
1639 (Rank::Serovar, "SEROVAR"),
1640 (Rank::Chemoform, "CHEMOFORM"),
1641 (Rank::FormaSpecialis, "FORMA_SPECIALIS"),
1642 (Rank::Lusus, "LUSUS"),
1643 (Rank::Cultivar, "CULTIVAR"),
1644 (Rank::Mutatio, "MUTATIO"),
1645 (Rank::Strain, "STRAIN"),
1646 (Rank::Other, "OTHER"),
1647 (Rank::Unranked, "UNRANKED"),
1648 ];
1649 assert_eq!(expected.len(), 117);
1650 assert_eq!(Rank::ALL.len(), 117);
1651 for (i, (rank, name)) in expected.iter().enumerate() {
1652 assert_eq!(Rank::ALL[i], *rank, "Rank::ALL[{i}] should be {rank:?}");
1653 assert_eq!(rank.ordinal(), i, "{rank:?}.ordinal() should be {i}");
1654 assert_eq!(
1655 serde_json::to_string(rank).unwrap(),
1656 format!("\"{name}\""),
1657 "{rank:?} should serialize to \"{name}\""
1658 );
1659 }
1660 }
1661
1662 #[test]
1665 fn rank_code_tdd_sample() {
1666 assert_eq!(Rank::Cultivar.code(), Some(NomCode::Cultivars));
1667 assert_eq!(Rank::Subgenus.code(), None);
1668 assert_eq!(Rank::Pathovar.code(), Some(NomCode::Bacterial));
1669 assert_eq!(Rank::SectionBotany.code(), Some(NomCode::Botanical));
1670 assert_eq!(Rank::Realm.code(), Some(NomCode::Virus));
1671 assert_eq!(Rank::Subrealm.code(), Some(NomCode::Virus));
1672 }
1673
1674 #[test]
1676 fn rank_ordinal_predicates_tdd_sample() {
1677 assert!(Rank::Subspecies.is_infraspecific());
1678 assert!(!Rank::Species.is_infraspecific());
1679 assert!(Rank::Subgenus.is_infrageneric_strictly());
1680 assert!(!Rank::Genus.is_infrageneric_strictly());
1681 assert!(!Rank::Species.is_infrageneric_strictly());
1682 assert!(Rank::Family.is_suprageneric());
1683 assert!(!Rank::Genus.is_suprageneric());
1684 assert!(Rank::Genus.higher_than(Rank::Species));
1685 assert!(!Rank::Species.higher_than(Rank::Genus));
1686 assert!(Rank::Species.higher_than(Rank::Subspecies));
1687 assert!(Rank::Subspecies.lower_than(Rank::Species));
1688 assert!(!Rank::Genus.higher_than(Rank::Other));
1689 assert!(!Rank::Genus.higher_than(Rank::Unranked));
1690 }
1691
1692 #[test]
1693 fn rank_markers_tdd_sample() {
1694 assert_eq!(Rank::Subspecies.marker(), Some("subsp."));
1695 assert_eq!(Rank::Species.marker(), Some("sp."));
1696 assert_eq!(Rank::CultivarGroup.marker(), None);
1697 assert_eq!(Rank::Other.marker(), None);
1698 assert_eq!(Rank::Unranked.marker(), None);
1699 assert_eq!(Rank::SectionZoology.marker(), Rank::SectionBotany.marker());
1701 assert_eq!(
1702 Rank::DivisionZoology.marker(),
1703 Rank::DivisionBotany.marker()
1704 );
1705 }
1706
1707 #[test]
1708 fn rank_plural_sample() {
1709 assert_eq!(Rank::Species.plural(), Some("species"));
1710 assert_eq!(Rank::Genus.plural(), Some("genera"));
1711 assert_eq!(Rank::Falanx.plural(), Some("falanges"));
1712 assert_eq!(Rank::Lusus.plural(), Some("lusi"));
1713 assert_eq!(Rank::CultivarGroup.plural(), None);
1714 assert_eq!(Rank::Other.plural(), None);
1715 assert_eq!(Rank::Unranked.plural(), None);
1716 assert_eq!(Rank::DivisionZoology.plural(), Some("division_zoologys"));
1719 assert_eq!(Rank::SectionBotany.plural(), Some("section_botanys"));
1720 assert_eq!(Rank::SeriesZoology.plural(), Some("series"));
1722 assert_eq!(Rank::SeriesBotany.plural(), Some("series"));
1723 }
1724
1725 #[test]
1726 fn rank_is_family_group_and_genus_group() {
1727 assert!(Rank::Family.is_family_group());
1728 assert!(Rank::Gigafamily.is_family_group());
1729 assert!(!Rank::SupragenericName.is_family_group());
1730 assert!(!Rank::Genus.is_family_group());
1731 assert!(Rank::Genus.is_genus_group());
1732 assert!(Rank::Supergenus.is_genus_group());
1733 assert!(Rank::Subgenus.is_genus_group());
1734 assert!(!Rank::SpeciesAggregate.is_genus_group());
1735 assert!(!Rank::SupragenericName.is_genus_group());
1736 }
1737
1738 #[test]
1739 fn rank_is_species_or_below() {
1740 assert!(Rank::SpeciesAggregate.is_species_or_below());
1741 assert!(Rank::Species.is_species_or_below());
1742 assert!(Rank::Subspecies.is_species_or_below());
1743 assert!(!Rank::Genus.is_species_or_below());
1744 assert!(!Rank::Other.is_species_or_below());
1745 assert!(!Rank::Unranked.is_species_or_below());
1746 }
1747
1748 #[test]
1749 fn rank_is_uncomparable() {
1750 assert!(Rank::SupragenericName.is_uncomparable());
1751 assert!(Rank::InfragenericName.is_uncomparable());
1752 assert!(Rank::InfraspecificName.is_uncomparable());
1753 assert!(Rank::InfrasubspecificName.is_uncomparable());
1754 assert!(Rank::Other.is_uncomparable());
1755 assert!(Rank::Unranked.is_uncomparable());
1756 assert!(!Rank::Species.is_uncomparable());
1757 assert!(!Rank::Genus.is_uncomparable());
1758 }
1759
1760 #[test]
1761 fn rank_is_legacy() {
1762 for r in [
1763 Rank::Morph,
1764 Rank::Aberration,
1765 Rank::Natio,
1766 Rank::Proles,
1767 Rank::Convariety,
1768 Rank::Klepton,
1769 Rank::Falanx,
1770 Rank::Lusus,
1771 ] {
1772 assert!(r.is_legacy(), "{r:?} should be legacy");
1773 }
1774 assert!(!Rank::Species.is_legacy());
1775 assert!(!Rank::Subspecies.is_legacy());
1776 }
1777
1778 #[test]
1779 fn rank_is_linnean() {
1780 for r in Rank::LINNEAN_RANKS {
1781 assert!(r.is_linnean(), "{r:?} should be Linnean");
1782 }
1783 assert!(!Rank::Subgenus.is_linnean());
1784 assert!(!Rank::Subspecies.is_linnean());
1785 assert_eq!(Rank::LINNEAN_RANKS.len(), 7);
1786 }
1787
1788 #[test]
1789 fn rank_is_restricted_to_code_matches_code() {
1790 assert_eq!(
1791 Rank::Cultivar.is_restricted_to_code(),
1792 Rank::Cultivar.code()
1793 );
1794 assert_eq!(Rank::Species.is_restricted_to_code(), Rank::Species.code());
1795 }
1796
1797 #[test]
1798 fn rank_has_ambiguous_marker() {
1799 for r in [
1801 Rank::DivisionZoology,
1802 Rank::DivisionBotany,
1803 Rank::SectionZoology,
1804 Rank::SectionBotany,
1805 Rank::SubsectionZoology,
1806 Rank::SubsectionBotany,
1807 Rank::SupersectionZoology,
1808 Rank::SupersectionBotany,
1809 Rank::SeriesZoology,
1810 Rank::SeriesBotany,
1811 Rank::SubseriesZoology,
1812 Rank::SubseriesBotany,
1813 Rank::SuperseriesZoology,
1814 Rank::SuperseriesBotany,
1815 ] {
1816 assert!(r.has_ambiguous_marker(), "{r:?} should be ambiguous");
1817 }
1818 assert!(!Rank::Species.has_ambiguous_marker());
1820 assert!(!Rank::Genus.has_ambiguous_marker());
1821 assert!(!Rank::Cultivar.has_ambiguous_marker());
1822 }
1823
1824 #[test]
1826 fn rank_get_major_rank_automatic() {
1827 assert_eq!(Rank::Subphylum.get_major_rank(), Rank::Phylum);
1828 assert_eq!(Rank::Nanophylum.get_major_rank(), Rank::Phylum);
1829 assert_eq!(Rank::Subclass.get_major_rank(), Rank::Class);
1830 assert_eq!(Rank::Subterclass.get_major_rank(), Rank::Class);
1832 assert_eq!(Rank::SubsectionBotany.get_major_rank(), Rank::SectionBotany);
1833 assert_eq!(
1834 Rank::SupersectionZoology.get_major_rank(),
1835 Rank::SectionZoology
1836 );
1837 assert_eq!(Rank::Species.get_major_rank(), Rank::Species);
1839 assert_eq!(Rank::Genus.get_major_rank(), Rank::Genus);
1840 assert_eq!(Rank::Other.get_major_rank(), Rank::Other);
1841 assert_eq!(Rank::Unranked.get_major_rank(), Rank::Unranked);
1842 }
1843
1844 #[test]
1847 fn rank_get_major_rank_manual_fixes() {
1848 assert_eq!(Rank::Nanorder.get_major_rank(), Rank::Order);
1849 assert_eq!(Rank::SpeciesAggregate.get_major_rank(), Rank::Species);
1850 assert_eq!(Rank::InfragenericName.get_major_rank(), Rank::Genus);
1851 assert_eq!(Rank::Superdivision.get_major_rank(), Rank::DivisionZoology);
1852 assert_eq!(Rank::Subdivision.get_major_rank(), Rank::DivisionZoology);
1853 assert_eq!(Rank::Infradivision.get_major_rank(), Rank::DivisionZoology);
1854 }
1855
1856 #[test]
1860 fn rank_get_major_rank_infraspecific_collapse() {
1861 for r in [
1862 Rank::Grex,
1863 Rank::Klepton,
1864 Rank::Subspecies,
1865 Rank::CultivarGroup,
1866 Rank::Variety,
1867 Rank::Cultivar,
1868 Rank::Strain,
1869 ] {
1870 assert_eq!(
1871 r.get_major_rank(),
1872 Rank::InfraspecificName,
1873 "{r:?} should collapse to INFRASPECIFIC_NAME"
1874 );
1875 }
1876 }
1877
1878 #[test]
1880 fn rank_utils_suffices_rank_map_sample() {
1881 let bot = rank_utils::suffices_rank_map(NomCode::Botanical).unwrap();
1882 assert!(bot.contains(&("aceae", Rank::Family)));
1883 assert!(bot.contains(&("oideae", Rank::Subfamily)));
1884
1885 let zoo = rank_utils::suffices_rank_map(NomCode::Zoological).unwrap();
1886 assert!(zoo.contains(&("idae", Rank::Family)));
1887 assert!(zoo.contains(&("oidae", Rank::Epifamily)));
1888 let bact = rank_utils::suffices_rank_map(NomCode::Bacterial).unwrap();
1891 assert!(bact.contains(&("idae", Rank::Subclass)));
1892
1893 let virus = rank_utils::suffices_rank_map(NomCode::Virus).unwrap();
1894 assert!(virus.contains(&("viridae", Rank::Family)));
1895
1896 assert_eq!(rank_utils::suffices_rank_map(NomCode::Cultivars), None);
1899 assert_eq!(rank_utils::suffices_rank_map(NomCode::Phyto), None);
1900 assert_eq!(rank_utils::suffices_rank_map(NomCode::Phylo), None);
1901 }
1902
1903 #[test]
1909 fn rank_from_name_round_trips_every_variant_via_its_own_serialize_impl() {
1910 for &r in Rank::ALL.iter() {
1911 let name = rank_wire_name(r);
1912 assert_eq!(
1913 Rank::from_name(&name),
1914 Some(r),
1915 "round-trip failed for {r:?}"
1916 );
1917 }
1918 }
1919
1920 #[test]
1921 fn rank_from_name_pins_a_multi_word_constant_and_rejects_nonsense() {
1922 assert_eq!(Rank::from_name("SPECIES"), Some(Rank::Species));
1923 assert_eq!(
1924 Rank::from_name("DIVISION_ZOOLOGY"),
1925 Some(Rank::DivisionZoology)
1926 );
1927 assert_eq!(Rank::from_name("NONSENSE"), None);
1928 assert_eq!(Rank::from_name(""), None);
1929 }
1930
1931 #[test]
1935 fn nomcode_from_name_round_trips_every_variant_via_its_own_serialize_impl() {
1936 for &c in &[
1937 NomCode::Bacterial,
1938 NomCode::Botanical,
1939 NomCode::Cultivars,
1940 NomCode::Phyto,
1941 NomCode::Virus,
1942 NomCode::Zoological,
1943 NomCode::Phylo,
1944 ] {
1945 let name = serde_json::to_string(&c)
1946 .unwrap()
1947 .trim_matches('"')
1948 .to_string();
1949 assert_eq!(
1950 NomCode::from_name(&name),
1951 Some(c),
1952 "round-trip failed for {c:?}"
1953 );
1954 }
1955 }
1956
1957 #[test]
1958 fn nomcode_from_name_pins_botanical_and_rejects_nonsense() {
1959 assert_eq!(NomCode::from_name("BOTANICAL"), Some(NomCode::Botanical));
1960 assert_eq!(NomCode::from_name("NONSENSE"), None);
1961 }
1962}