mod vars;
mod safety;
mod stratification;
mod arity;
mod recursion;
mod reserved;
mod sqlexpr;
mod positional;
mod undefined;
pub use vars::VarCollector;
pub use safety::{SafetyError, check_safety};
pub use stratification::{StratificationError, check_stratification};
pub use arity::{ArityError, check_arity};
pub use recursion::{RecursionError, check_recursion, check_unbounded_recursion};
pub use reserved::{ReservedError, check_reserved, reserved_predicate_names};
pub use sqlexpr::{SqlExprError, check_sqlexpr};
pub use positional::{PositionalError, check_positional};
pub use undefined::{UndefinedError, builtin_function_names, check_undefined};
use crate::parser::Json;
use crate::errors::{VerifyError, VerifyResult};
#[derive(Debug, Clone)]
pub enum CheckError {
Safety(SafetyError),
Stratification(StratificationError),
Arity(ArityError),
Recursion(RecursionError),
Reserved(ReservedError),
SqlExpr(SqlExprError),
Positional(PositionalError),
Undefined(UndefinedError),
}
impl std::fmt::Display for CheckError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
CheckError::Safety(e) => write!(f, "{}", e),
CheckError::Stratification(e) => write!(f, "{}", e),
CheckError::Arity(e) => write!(f, "{}", e),
CheckError::Recursion(e) => write!(f, "{}", e),
CheckError::Reserved(e) => write!(f, "{}", e),
CheckError::SqlExpr(e) => write!(f, "{}", e),
CheckError::Positional(e) => write!(f, "{}", e),
CheckError::Undefined(e) => write!(f, "{}", e),
}
}
}
impl std::error::Error for CheckError {}
impl From<CheckError> for VerifyError {
fn from(e: CheckError) -> Self {
match e {
CheckError::Safety(se) => se.into(),
CheckError::Stratification(se) => se.into(),
CheckError::Arity(ae) => ae.into(),
CheckError::Recursion(re) => re.into(),
CheckError::Reserved(re) => re.into(),
CheckError::SqlExpr(se) => se.into(),
CheckError::Positional(pe) => pe.into(),
CheckError::Undefined(ue) => ue.into(),
}
}
}
impl From<CheckError> for crate::errors::SynalogError {
fn from(e: CheckError) -> Self {
crate::errors::SynalogError::Verify(e.into())
}
}
#[derive(Debug, Default)]
pub struct CheckResult {
pub errors: Vec<CheckError>,
pub warnings: Vec<String>,
}
impl CheckResult {
pub fn is_valid(&self) -> bool {
self.errors.is_empty()
}
pub fn merge(&mut self, other: CheckResult) {
self.errors.extend(other.errors);
self.warnings.extend(other.warnings);
}
pub fn to_verify_result(self) -> VerifyResult {
let mut result = VerifyResult::ok();
for err in self.errors {
result.add_error(err.into());
}
for warn in self.warnings {
result.add_warning(warn);
}
result
}
}
impl From<CheckResult> for VerifyResult {
fn from(r: CheckResult) -> Self {
r.to_verify_result()
}
}
pub fn validate(parsed: &Json) -> CheckResult {
let mut result = CheckResult::default();
let Some(rules_json) = parsed.as_object().get("rule") else {
return result;
};
let rules = rules_json.as_array();
let all_rules: Vec<&Json> = rules.iter().collect();
let normal_rules: Vec<&Json> = rules
.iter()
.filter(|r| {
let name = r.as_object()["head"].as_object()["predicate_name"].as_str();
!name.starts_with('@')
})
.collect();
for rule in &normal_rules {
for err in safety::check_rule_safety(rule) {
result.errors.push(CheckError::Safety(err));
}
}
if let Err(e) = stratification::check_stratification(&normal_rules) {
result.errors.push(CheckError::Stratification(e));
}
for err in arity::check_arity(&normal_rules) {
result.errors.push(CheckError::Arity(err));
}
for err in recursion::check_recursion(&normal_rules) {
result.errors.push(CheckError::Recursion(err));
}
for err in recursion::check_unbounded_recursion(&all_rules, &normal_rules) {
result.errors.push(CheckError::Recursion(err));
}
for err in reserved::check_reserved(&normal_rules) {
result.errors.push(CheckError::Reserved(err));
}
for err in sqlexpr::check_sqlexpr(&normal_rules) {
result.errors.push(CheckError::SqlExpr(err));
}
for err in positional::check_positional(&normal_rules) {
result.errors.push(CheckError::Positional(err));
}
for err in undefined::check_undefined(&normal_rules) {
result.errors.push(CheckError::Undefined(err));
}
result
}