use sbol_ontology::Ontology;
use crate::validation::report::Severity;
use crate::validation::spec::validation_rule_statuses;
use sbol_core::validation::options::RuleOverrides;
pub use sbol_core::validation::options::{
HashAlgorithmRegistry, PolicyOptions, RuleOverride, TopologyCompleteness, UnknownRule,
ValidationConfig,
};
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct ValidationOptions {
pub topology_completeness: TopologyCompleteness,
pub policy: PolicyOptions,
pub config: ValidationConfig,
pub(crate) rules: RuleOverrides,
pub(crate) ontology_extensions: Vec<Ontology>,
}
impl Default for ValidationOptions {
fn default() -> Self {
Self {
topology_completeness: TopologyCompleteness::default(),
policy: PolicyOptions::default(),
config: ValidationConfig::default().with_best_practice(true),
rules: RuleOverrides::default(),
ontology_extensions: Vec::new(),
}
}
}
impl ValidationOptions {
pub fn allow(self, rule: &str) -> Result<Self, UnknownRule> {
self.override_rule(rule, RuleOverride::Suppress)
}
pub fn deny(self, rule: &str) -> Result<Self, UnknownRule> {
self.override_rule(rule, RuleOverride::Severity(Severity::Error))
}
pub fn warn(self, rule: &str) -> Result<Self, UnknownRule> {
self.override_rule(rule, RuleOverride::Severity(Severity::Warning))
}
pub fn with_severity_floor(mut self, floor: Severity) -> Self {
self.rules = self.rules.with_severity_floor(floor);
self
}
pub fn with_severity_ceiling(mut self, ceiling: Severity) -> Self {
self.rules = self.rules.with_severity_ceiling(ceiling);
self
}
pub fn best_practice(mut self, on: bool) -> Self {
self.config.best_practice = on;
self
}
pub fn complete(mut self, on: bool) -> Self {
self.config.complete = on;
self
}
pub fn with_config(mut self, config: ValidationConfig) -> Self {
self.config = config;
self
}
pub fn with_ontology_extension(mut self, extension: Ontology) -> Self {
self.ontology_extensions.push(extension);
self
}
pub(crate) fn take_ontology_extensions(&mut self) -> Vec<Ontology> {
std::mem::take(&mut self.ontology_extensions)
}
pub fn overrides(&self) -> impl Iterator<Item = (&'static str, RuleOverride)> + '_ {
self.rules.iter()
}
pub fn severity_floor(&self) -> Option<Severity> {
self.rules.severity_floor()
}
pub fn severity_ceiling(&self) -> Option<Severity> {
self.rules.severity_ceiling()
}
fn override_rule(mut self, rule: &str, ovr: RuleOverride) -> Result<Self, UnknownRule> {
self.rules = self.rules.set(rule, ovr, validation_rule_statuses())?;
Ok(self)
}
pub(crate) fn resolved_severity(
&self,
rule: &'static str,
catalog_default: Severity,
) -> Option<Severity> {
self.rules.resolved_severity(rule, catalog_default)
}
}