shacl 0.2.19

A SHACL validator for RDF data, implemented in Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

use crate::error::ValidationError;
use crate::ir::components::Not;
use crate::ir::{IRComponent, IRSchema, IRShape};
use crate::types::MessageMap;
use crate::validator::constraints::Validator;
use crate::validator::engine::{Engine, Validate};
use crate::validator::nodes::{FocusNodes, ValueNodes};
use crate::validator::report::ValidationResult;
use rudof_rdf::rdf_core::term::Object;
use rudof_rdf::rdf_core::{NeighsRDF, SHACLPath};
use std::fmt::Debug;

impl<S: NeighsRDF + Debug> Validator<S> for Not {
    fn validate(
        &self,
        component: &IRComponent,
        shape: &IRShape,
        store: &S,
        engine: &mut dyn Engine<S>,
        value_nodes: &ValueNodes<S>,
        _: Option<&IRShape>,
        maybe_path: Option<&SHACLPath>,
        shapes_graph: &IRSchema,
    ) -> Result<Vec<ValidationResult>, ValidationError> {
        let mut validation_results = Vec::new();

        for (fnode, nodes) in value_nodes.iter() {
            let fnode_obj = S::term_as_object(fnode)?;
            for node in nodes.iter() {
                let focus_nodes = FocusNodes::single(node.clone());
                let not_shape = shapes_graph.get_shape_from_idx_e(self.shape())?;
                let inner_results = not_shape.validate(store, engine, Some(&focus_nodes), Some(shape), shapes_graph);
                let is_valid_inside = match inner_results {
                    Ok(results) => results.is_empty(),
                    Err(_) => false, // TODO - Should we fail instead of considering it valid?
                };
                if is_valid_inside {
                    let msg = format!(
                        "Shape: {}. NOT constraint not satisfied for focus node {fnode} and internal shape {}",
                        shape.id(),
                        not_shape.id()
                    );
                    let component = Object::iri(component.into());
                    let node_object = S::term_as_object(node).ok();
                    let vr = ValidationResult::new(fnode_obj.clone(), component.clone(), shape.severity().clone())
                        .with_message(MessageMap::from(msg))
                        .with_path(maybe_path.cloned())
                        .with_source(Some(shape.id().clone()))
                        .with_value(node_object);
                    validation_results.push(vr);
                }
            }
        }

        Ok(validation_results)
    }
}