[](https://crates.io/crates/securiety)
[](https://docs.rs/securiety)
[](LICENSE)
[](https://robinsongroup.github.io/)
[](https://github.com/biopragmatics/bioregistry)
# Securiety
A robust Rust crate for parsing and validating Compact Uniform Resource Identifiers (CURIEs). It provides standard syntax validation as well as specific, regex-based validation for hundreds of biological and biomedical ontologies (e.g., GO, MONDO, CHEBI) generated directly from Bioregistry.
### Features
- **General Validation**: Parse and validate CURIEs based on standard syntactic rules (W3C-style prefix/reference separation).
- **Ontology-Specific Validation**: precise Regex validation for over 100+ supported ontologies (including GO, CHEBI, NCIT, etc.).
- **Auto-Generated Patterns**: Validation logic is generated from upstream Bioregistry metadata, ensuring compliance with current standards.
- **Dynamic Lookup**: Instantiate validators dynamically using string prefixes (e.g., from_prefix("go")).
- **Lightweight**: Core dependencies are minimal (primarily regex).
### Installation
Add this to your Cargo.toml:
```toml
[dependencies]
securiety = "0.2.0"
```
### Usage
1. General Parsing
If you need to validate that a string is simply a well-formed CURIE (has a valid prefix and reference structure) without enforcing specific ontology patterns:
```Rust
use securiety::{CurieParser, CurieParsing};
fn main() {
// Create a general parser
let parser = CurieParser::general();
// Valid syntax
let curie = parser.parse("AnyPrefix:12345").unwrap();
println!("Prefix: {}, Reference: {}", curie.prefix(), curie.reference());
// Invalid syntax (e.g., no separator, invalid characters)
let result = parser.parse("InvalidString");
assert!(result.is_err());
}
```
2. Specific Ontology Validation
You can use strict, pre-compiled regex validators for specific ontologies. This ensures that a GO term actually looks like a GO term (e.g., GO:0001234).
```Rust
use securiety::{CurieParser, CurieParsing};
fn main() {
// strict validator for Gene Ontology
let go_parser = CurieParser::go();
// Passes: Matches ^GO:\d{7}$
let valid = go_parser.parse("GO:0006915");
assert!(valid.is_ok());
// Fails: Syntax is okay, but pattern matches invalid GO ID
let invalid = go_parser.parse("GO:ABC");
assert!(invalid.is_err());
}
```
3. Dynamic Prefix Lookup
If you are processing data where the ontology prefix is determined at runtime, you can look up the validator dynamically:
```Rust
use securiety::{CurieParser, CurieParsing, CurieRegexValidator, CurieValidation};
fn main() {
let input_prefix = "mondo";
let input_curie = "MONDO:0012345";
// Attempt to find a validator for the given prefix
if let Some(parser) = CurieParser::from_prefix(input_prefix) {
match parser.parse(input_curie) {
Ok(curie) => println!("Valid {} term: {}", input_prefix, curie),
Err(e) => println!("Invalid term: {}", e),
}
} else {
println!("No validator found for prefix: {}", input_prefix);
}
}
```
### Supported Ontologies
This crate includes generated validators for a wide range of biological ontologies found in the Bioregistry, including but not limited to:
- GO (Gene Ontology)
- MONDO (Mondo Disease Ontology)
- CHEBI (Chemical Entities of Biological Interest)
- NCIT (NCI Thesaurus)
- HP (Human Phenotype Ontology)
- UBERON (Uber Anatomy Ontology)
Note: The patterns are generated using the create.rs utility which fetches metadata from the Bioregistry API.
### Error Handling
The parser returns a CurieParsingError enum to distinguish between structural failures and validation failures:
- InvalidCurie(String): The string failed the specific validation logic (e.g., Regex mismatch).
- UnparsableCurie(String): The string lacked the basic structure of a CURIE (e.g., missing a colon).