Refactoring the shacl_validation crate according to the refactoring of the core of rudof

python/src/pyrudof_lib.rs

@@ -362,7 +362,7 @@ impl PyRudof {
         let shapes_graph_source = cnv_shapes_graph_source(shapes_graph_source);
         let result = self
             .inner
-            .validate_shacl(&mode, &shapes_graph_source)
+            .validate_shacl(&shapes_graph_source, mode)
             .map_err(cnv_err)?;
         Ok(PyValidationReport { inner: result })
     }

rudof_cli/src/cli.rs

@@ -1,7 +1,7 @@
 use crate::input_spec::InputSpec;
 use crate::{InputConvertFormat, OutputConvertFormat};
 use clap::{Parser, Subcommand, ValueEnum};
-use shacl_validation::shacl_processor::ShaclValidationMode;
+use rudof_lib::ShaclValidationMode;
 use srdf::{RDFFormat, ReaderMode};
 use std::fmt::Display;
 use std::{fmt::Formatter, path::PathBuf};

rudof_cli/src/main.rs

@@ -627,9 +627,9 @@ fn run_validate_shacl(
         let reader_mode = reader_mode_convert(*reader_mode);
         let shapes_format = shapes_format.unwrap_or_default();
         add_shacl_schema_rudof(&mut rudof, schema, &shapes_format, &reader_mode, config)?;
-        rudof.validate_shacl(&mode, &ShapesGraphSource::current_schema())
+        rudof.validate_shacl(&ShapesGraphSource::current_schema(), mode)
     } else {
-        rudof.validate_shacl(&mode, &ShapesGraphSource::current_data())
+        rudof.validate_shacl(&ShapesGraphSource::current_schema(), mode)
     }?;
 
     writeln!(writer, "Result:\n{}", result)?;
@@ -1159,17 +1159,14 @@ fn run_node(
     )
 }
 
-fn show_node_info<S, W: Write>(
+fn show_node_info<Q: Query, W: Write>(
     node_selector: NodeSelector,
     predicates: &Vec<String>,
-    rdf: &S,
+    rdf: &Q,
     show_node_mode: &ShowNodeMode,
     _show_hyperlinks: &bool,
     writer: &mut W,
-) -> Result<()>
-where
-    S: Query,
-{
+) -> Result<()> {
     for node in node_selector.iter_node(rdf) {
         let subject = node_to_subject(node, rdf)?;
         writeln!(
@@ -1215,7 +1212,7 @@ where
         match show_node_mode {
             ShowNodeMode::Incoming | ShowNodeMode::Both => {
                 writeln!(writer, "Incoming arcs")?;
-                let object: S::Term = subject.clone().into();
+                let object: Q::Term = subject.clone().into();
                 let map = match rdf.incoming_arcs(object.clone()) {
                     Result::Ok(m) => m,
                     Err(e) => bail!("Can't get outgoing arcs of node {subject}: {e}"),
@@ -1240,10 +1237,7 @@ where
     Ok(())
 }
 
-fn cnv_predicates<S>(predicates: &Vec<String>, rdf: &S) -> Result<Vec<S::IRI>>
-where
-    S: Query,
-{
+fn cnv_predicates<Q: Query>(predicates: &Vec<String>, rdf: &Q) -> Result<Vec<Q::IRI>> {
     let mut vs = Vec::new();
     for s in predicates {
         let iri_ref = parse_iri_ref(s)?;
@@ -1278,20 +1272,17 @@ fn run_shapemap(
     Ok(())
 }
 
-fn node_to_subject<S>(node: &ObjectValue, rdf: &S) -> Result<S::Subject>
-where
-    S: Query,
-{
+fn node_to_subject<Q: Query>(node: &ObjectValue, rdf: &Q) -> Result<Q::Subject> {
     match node {
         ObjectValue::IriRef(iri_ref) => {
-            let iri: S::IRI = match iri_ref {
+            let iri: Q::IRI = match iri_ref {
                 IriRef::Iri(iri_s) => iri_s.clone().into(),
                 IriRef::Prefixed { prefix, local } => {
                     let iri_s = rdf.resolve_prefix_local(prefix, local)?;
                     iri_s.into()
                 }
             };
-            let term: S::Term = iri.into();
+            let term: Q::Term = iri.into();
             match term.clone().try_into() {
                 Ok(subject) => Ok(subject),
                 Err(_) => bail!("node_to_subject: Can't convert term {term} to subject"),

rudof_lib/Cargo.toml

@@ -30,3 +30,4 @@ thiserror = "1.0"
 serde_json.workspace = true
 serde_yml = "0.0.12"
 oxrdf = { workspace = true, features = ["oxsdatatypes"] }
+clap.workspace = true

rudof_lib/src/rudof.rs

@@ -1,8 +1,8 @@
 use crate::{RudofConfig, RudofError, ShapesGraphSource};
+use clap::ValueEnum;
 use iri_s::IriS;
 use shacl_ast::{ShaclParser, ShaclWriter};
-use shacl_validation::shacl_processor::{GraphValidation, ShaclProcessor};
-use shacl_validation::store::graph::Graph;
+use shacl_validation::shacl_processor::{DefaultShaclProcessor, SparqlShaclProcessor};
 
 use shapemap::{NodeSelector, ShapeSelector};
 use shapes_converter::{ShEx2Uml, Tap2ShEx};
@@ -21,7 +21,6 @@ pub use dctap::{DCTAPFormat, DCTap as DCTAP};
 pub use iri_s::iri;
 pub use prefixmap::PrefixMap;
 pub use shacl_ast::ShaclFormat;
-pub use shacl_validation::shacl_processor::ShaclValidationMode;
 pub use shacl_validation::validation_report::report::ValidationReport;
 pub use shapemap::{QueryShapeMap, ResultShapeMap, ShapeMapFormat, ValidationStatus};
 pub use shex_compact::{ShExFormatter, ShapeMapParser, ShapemapFormatter as ShapeMapFormatter};
@@ -34,6 +33,12 @@ pub use shapes_converter::UmlGenerationMode;
 pub use shex_ast::Schema as ShExSchema;
 pub use sparql_service::RdfData;
 
+#[derive(ValueEnum, Copy, Clone, Debug, PartialEq)]
+pub enum ShaclValidationMode {
+    Native,
+    Sparql,
+}
+
 /// This represents the public API to interact with `rudof`
 #[derive(Debug)]
 pub struct Rudof {
@@ -469,10 +474,12 @@ impl Rudof {
     /// If there is no current SHACL schema, it tries to get it from the current RDF data
     pub fn validate_shacl(
         &mut self,
-        mode: &ShaclValidationMode,
         shapes_graph_source: &ShapesGraphSource,
+        mode: ShaclValidationMode,
     ) -> Result<ValidationReport> {
-        let (compiled_schema, shacl_schema) = match shapes_graph_source {
+        let data = self.rdf_data.clone();
+
+        let (schema, original_schema) = match shapes_graph_source {
             ShapesGraphSource::CurrentSchema if self.shacl_schema.is_some() => {
                 let ast_schema = self.shacl_schema.as_ref().unwrap();
                 let compiled_schema = ast_schema.clone().to_owned().try_into().map_err(|e| {
@@ -494,14 +501,17 @@ impl Rudof {
                 Ok((compiled_schema, ast_schema))
             }
         }?;
-        let validator = GraphValidation::from_graph(Graph::from_data(self.rdf_data.clone()), *mode);
-        let result = ShaclProcessor::validate(&validator, &compiled_schema).map_err(|e| {
-            RudofError::SHACLValidationError {
-                error: format!("{e}"),
-                schema: Box::new(shacl_schema),
-            }
+
+        // TODO: fix the error thing...
+        let report = match mode {
+            ShaclValidationMode::Native => DefaultShaclProcessor::new(data).validate(&schema),
+            ShaclValidationMode::Sparql => SparqlShaclProcessor::new(data).validate(&schema),
+        }
+        .map_err(|e| RudofError::SHACLValidationError {
+            error: format!("{e}"),
+            schema: Box::new(original_schema),
         })?;
-        Ok(result)
+        Ok(report)
     }
 
     /// Validate RDF data using ShEx
@@ -692,7 +702,6 @@ fn shacl_format2rdf_format(shacl_format: &ShaclFormat) -> Result<RDFFormat> {
 mod tests {
     use iri_s::iri;
     use shacl_ast::ShaclFormat;
-    use shacl_validation::shacl_processor::ShaclValidationMode;
     use shapemap::ShapeMapFormat;
     use shex_ast::{compiled::shape_label::ShapeLabel, Node};
     use shex_validation::ShExFormat;
@@ -793,8 +802,8 @@ mod tests {
             .unwrap();
         let result = rudof
             .validate_shacl(
-                &ShaclValidationMode::Native,
                 &crate::ShapesGraphSource::CurrentSchema,
+                crate::ShaclValidationMode::Native,
             )
             .unwrap();
         assert!(result.results().is_empty())
@@ -838,8 +847,8 @@ mod tests {
             .unwrap();
         let result = rudof
             .validate_shacl(
-                &ShaclValidationMode::Native,
                 &crate::ShapesGraphSource::CurrentSchema,
+                crate::ShaclValidationMode::Native,
             )
             .unwrap();
         assert!(!result.conforms())
@@ -873,8 +882,8 @@ mod tests {
             .unwrap();
         let result = rudof
             .validate_shacl(
-                &ShaclValidationMode::Native,
                 &crate::ShapesGraphSource::CurrentData,
+                crate::ShaclValidationMode::Native,
             )
             .unwrap();
         assert!(!result.conforms())
@@ -908,8 +917,8 @@ mod tests {
             .unwrap();
         let result = rudof
             .validate_shacl(
-                &ShaclValidationMode::Native,
                 &crate::ShapesGraphSource::CurrentData,
+                crate::ShaclValidationMode::Native,
             )
             .unwrap();
         assert!(result.conforms())

shacl_ast/Cargo.toml

@@ -23,4 +23,3 @@ thiserror = "1.0"
 lazy_static = "1"
 const_format = "0.2"
 itertools = "0.13"
-oxrdf = { workspace = true, features = ["oxsdatatypes"] }

shacl_ast/src/ast/node_kind.rs

@@ -1,5 +1,7 @@
 use std::fmt::Display;
 
+use srdf::TermKind;
+
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
 pub enum NodeKind {
     Iri,
@@ -23,3 +25,23 @@ impl Display for NodeKind {
         write!(f, "{}", node)
     }
 }
+
+impl PartialEq<TermKind> for NodeKind {
+    fn eq(&self, other: &TermKind) -> bool {
+        matches!(
+            (self, other),
+            (NodeKind::Iri, TermKind::Iri)
+                | (NodeKind::Literal, TermKind::Literal)
+                | (NodeKind::BlankNode, TermKind::BlankNode)
+                | (
+                    NodeKind::BlankNodeOrIri,
+                    TermKind::BlankNode | TermKind::Iri
+                )
+                | (
+                    NodeKind::BlankNodeOrLiteral,
+                    TermKind::BlankNode | TermKind::Literal
+                )
+                | (NodeKind::IRIOrLiteral, TermKind::Iri | TermKind::Literal)
+        )
+    }
+}