shacl 0.3.10

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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

use crate::error::{IRError, ShaclParserError};
use rudof_rdf::rdf_core::{RDFError, Rdf};
#[cfg(feature = "sparql")]
use rudof_rdf::rdf_impl::OxigraphEndpointError;
use rudof_rdf::rdf_impl::OxigraphInMemoryError;
#[cfg(feature = "sparql")]
use sparql_service::RdfDataError;
use thiserror::Error;

// TODO - Maybe move to validation module
// TODO - Check if all the SPARQL error can be merged in one and if not improve enum variant names for
// TODO - better readability. Also check with other cases like constraints
#[derive(Debug, Error)]
pub enum ValidationError {
    #[cfg(feature = "sparql")]
    #[error("Query error: {0}")]
    QueryError(String),

    #[error("Unsupported SHACL validation mode: {0}")]
    UnsupportedMode(String),

    #[error(transparent)]
    IRError(#[from] Box<IRError>),

    #[error("Graph error: {0}")]
    GraphError(String),

    #[error(transparent)]
    RDFError(#[from] Box<RDFError>),

    #[cfg(feature = "sparql")]
    #[error(transparent)]
    OxigraphEndpointError(#[from] Box<OxigraphEndpointError>),

    #[cfg(feature = "sparql")]
    #[error(transparent)]
    RdfDataError(#[from] Box<RdfDataError>),

    #[error(transparent)]
    OxigraphInMemoryError(#[from] Box<OxigraphInMemoryError>),

    #[error(transparent)]
    ShaclParserError(#[from] Box<ShaclParserError>),

    #[error("Cannot convert {0} into {1}")]
    CastError(String, String),

    #[error("Parsing error: the required field '{0}' is missing")]
    MissingRequiredField(String),

    #[error("Parsing error: the field '{field}' has an invalid IRI value: {value}")]
    InvalidIriValue { field: String, value: String },

    #[error("TargetNode cannot be a Blank Node")]
    TargetNodeBNode,

    #[error("TargetClass should be an IRI")]
    TargetClassNotIri,
}

impl ValidationError {
    #[cfg(feature = "sparql")]
    pub fn ask_query_error<RDF: Rdf>(error: RDF::Err) -> Self {
        Self::QueryError(format!("ASK query failed: {error}"))
    }

    #[cfg(feature = "sparql")]
    pub fn select_query_error<RDF: Rdf>(error: RDF::Err) -> Self {
        Self::QueryError(format!("SELECT query failed: {error}"))
    }

    pub fn new_graph_error<RDF: Rdf>(err: RDF::Err) -> Self {
        Self::GraphError(err.to_string())
    }

    pub fn new_graph_error_ctx<RDF: Rdf>(err: RDF::Err, ctx: &str) -> Self {
        Self::GraphError(format!("{ctx}: {err}"))
    }
}

impl From<IRError> for ValidationError {
    fn from(value: IRError) -> Self {
        Self::IRError(Box::new(value))
    }
}

impl From<RDFError> for ValidationError {
    fn from(value: RDFError) -> Self {
        Self::RDFError(Box::new(value))
    }
}

#[cfg(feature = "sparql")]
impl From<OxigraphEndpointError> for ValidationError {
    fn from(value: OxigraphEndpointError) -> Self {
        Self::OxigraphEndpointError(Box::new(value))
    }
}

#[cfg(feature = "sparql")]
impl From<RdfDataError> for ValidationError {
    fn from(value: RdfDataError) -> Self {
        Self::RdfDataError(Box::new(value))
    }
}

impl From<ShaclParserError> for ValidationError {
    fn from(value: ShaclParserError) -> Self {
        Self::ShaclParserError(Box::new(value))
    }
}

impl From<OxigraphInMemoryError> for ValidationError {
    fn from(value: OxigraphInMemoryError) -> Self {
        Self::OxigraphInMemoryError(Box::new(value))
    }
}