Fix evaluation of sh:and, sh:or and sh:xone

Author: atextor

core/esmf-aspect-model-validator/src/main/java/org/eclipse/esmf/aspectmodel/shacl/ShaclValidator.java

@@ -170,18 +170,18 @@ public List<Violation> validateElements( final List<Resource> elements ) {
    }
 
    public List<Violation> validateShapeForElement( final Resource element, final Shape.Node nodeShape, final Model resolvedModel ) {
-      return validateShapeForElement( element, nodeShape, resolvedModel, Optional.empty(), Optional.empty() );
+      return validateShapeForElement( element, nodeShape, resolvedModel, Optional.empty() );
    }
 
    public List<Violation> validateShapeForElement( final Resource element, final Shape.Node nodeShape, final Model resolvedModel,
-         final Optional<Resource> parentElement, final Optional<Property> parentProperty ) {
+         final Optional<EvaluationContext> parentContext ) {
       final List<Violation> violations = new ArrayList<>();
       for ( final Shape.Property propertyShape : nodeShape.properties() ) {
-         violations.addAll( validateShapeForElement( element, nodeShape, propertyShape, resolvedModel, parentElement, parentProperty ) );
+         violations.addAll( validateShapeForElement( element, nodeShape, propertyShape, resolvedModel, parentContext ) );
       }
 
       final EvaluationContext context = new EvaluationContext( element, nodeShape, Optional.empty(), Optional.empty(),
-            parentElement, parentProperty, List.of(), this, resolvedModel );
+            parentContext, List.of(), this, resolvedModel );
       for ( final Constraint constraint : nodeShape.attributes().constraints() ) {
          if ( !constraint.canBeUsedOnNodeShapes() ) {
             continue;
@@ -192,24 +192,23 @@ public List<Violation> validateShapeForElement( final Resource element, final Sh
    }
 
    public List<Violation> validateShapeForElement( final Resource element, final Shape.Node nodeShape, final Shape.Property propertyShape,
-         final Model resolvedModel, final Optional<Resource> parentElement, final Optional<Property> parentProperty ) {
+         final Model resolvedModel, final Optional<EvaluationContext> parentContext ) {
       final List<Violation> violations = new ArrayList<>();
 
       for ( final Constraint constraint : propertyShape.attributes().constraints() ) {
          final List<Statement> reachableNodes = propertyShape.path().accept( element, retriever );
          // For all values that are present on the target node, check the applicable shapes and collect violations
          for ( final Statement assertion : reachableNodes ) {
             final EvaluationContext context = new EvaluationContext( element, nodeShape, Optional.of( propertyShape ),
-                  Optional.of( assertion.getPredicate() ),
-                  parentElement, parentProperty, List.of( assertion ), this, resolvedModel );
+                  Optional.of( assertion.getPredicate() ), parentContext, List.of( assertion ), this, resolvedModel );
             violations.addAll( constraint.apply( assertion.getObject(), context ) );
          }
 
          // important detail: Sparql constraints must run independent of whether there are any matches via the sh:path property or not
          // ( the check could be the verification whether the property exists )
          if ( reachableNodes.isEmpty() && constraint instanceof SparqlConstraint ) {
             final EvaluationContext context = new EvaluationContext( element, nodeShape, Optional.of( propertyShape ), Optional.empty(),
-                  parentElement, parentProperty, List.of(), this, resolvedModel );
+                  parentContext, List.of(), this, resolvedModel );
             violations.addAll( constraint.apply( null, context ) );
          }
 
@@ -219,7 +218,7 @@ public List<Violation> validateShapeForElement( final Resource element, final Sh
                && propertyShape.path() instanceof final PredicatePath predicatePath ) {
             final Property rdfProperty = resolvedModel.createProperty( predicatePath.predicate().getURI() );
             final EvaluationContext context = new EvaluationContext( element, nodeShape, Optional.of( propertyShape ),
-                  Optional.of( rdfProperty ), parentElement, parentProperty, List.of(), this, resolvedModel );
+                  Optional.of( rdfProperty ), parentContext, List.of(), this, resolvedModel );
             violations.addAll( constraint.apply( null, context ) );
          }
       }

core/esmf-aspect-model-validator/src/main/java/org/eclipse/esmf/aspectmodel/shacl/Shape.java

@@ -16,24 +16,37 @@
 import java.util.List;
 import java.util.Optional;
 
+import org.eclipse.esmf.aspectmodel.shacl.constraint.Constraint;
+import org.eclipse.esmf.aspectmodel.shacl.path.Path;
+
 import org.apache.jena.query.Query;
 import org.apache.jena.rdf.model.RDFNode;
 import org.apache.jena.rdf.model.Resource;
 
-import org.eclipse.esmf.aspectmodel.shacl.path.Path;
-import org.eclipse.esmf.aspectmodel.shacl.constraint.Constraint;
-
 /**
  * Implements <a href="https://www.w3.org/TR/shacl/#node-shapes">sh:NodeShape</a>
  */
 public interface Shape {
    Attributes attributes();
 
+   <T> T accept( Visitor<T> visitor );
+
    /**
     * Implements the valid values for <a href="https://www.w3.org/TR/shacl/#NodeKindConstraintComponent">sh:nodeKind</a>
     */
    enum NodeKind {
-      BlankNode, IRI, Literal, BlankNodeOrIRI, BlankNodeOrLiteral, IRIOrLiteral;
+      BlankNode( "an anonymous node" ),
+      IRI( "a named element" ),
+      Literal( "a value" ),
+      BlankNodeOrIRI( "an anonymous node or a named element" ),
+      BlankNodeOrLiteral( "an anonymous node or a value" ),
+      IRIOrLiteral( "a named element or a value" );
+
+      private final String humanRepresentation;
+
+      NodeKind( final String humanRepresentation ) {
+         this.humanRepresentation = humanRepresentation;
+      }
 
       public static NodeKind forNode( final RDFNode node ) {
          if ( node.isLiteral() ) {
@@ -47,6 +60,10 @@ public static NodeKind forNode( final RDFNode node ) {
          }
          throw new RuntimeException( "Invalid nodekind: " + node );
       }
+
+      public String humanReadable() {
+         return humanRepresentation;
+      }
    }
 
    record Attributes(
@@ -76,6 +93,10 @@ record Node(
          Attributes attributes,
          List<Property> properties
    ) implements Shape {
+      @Override
+      public <T> T accept( final Visitor<T> visitor ) {
+         return visitor.visitNodeShape( this );
+      }
    }
 
    /**
@@ -85,6 +106,16 @@ record Property(
          Attributes attributes,
          Path path
    ) implements Shape {
+      @Override
+      public <T> T accept( final Visitor<T> visitor ) {
+         return visitor.visitPropertyShape( this );
+      }
+   }
+
+   interface Visitor<T> {
+      T visitNodeShape( Shape.Node shapeNode );
+
+      T visitPropertyShape( Shape.Property propertyShape );
    }
 }
 

core/esmf-aspect-model-validator/src/main/java/org/eclipse/esmf/aspectmodel/shacl/ShapeLoader.java

@@ -131,8 +131,8 @@ Constraint>> builder()
                      context.statement().getModel().createProperty( context.statement().getResource().getURI() ) ) )
          .put( SHACL.not(), context ->
                new NotConstraint( constraints( context.statement().getObject().asResource(), context.path() ).get( 0 ) ) )
-         .put( SHACL.and(), context -> new AndConstraint( nestedConstraintList( context.statement(), context.path() ) ) )
-         .put( SHACL.or(), context -> new OrConstraint( nestedConstraintList( context.statement(), context.path() ) ) )
+         .put( SHACL.and(), context -> new AndConstraint( nestedShapesList( context.statement() ) ) )
+         .put( SHACL.or(), context -> new OrConstraint( nestedShapesList( context.statement() ) ) )
          .put( SHACL.xone(), context -> new XoneConstraint( nestedShapesList( context.statement() ) ) )
          .put( SHACL.node(), context -> {
             // Since sh:node can recursively refer to the same NodeShape is used in when shapes define recursive structures,

core/esmf-aspect-model-validator/src/main/java/org/eclipse/esmf/aspectmodel/shacl/ShapeSummarizer.java

@@ -0,0 +1,214 @@
+/*
+ * Copyright (c) 2023 Robert Bosch Manufacturing Solutions GmbH
+ *
+ * See the AUTHORS file(s) distributed with this work for additional
+ * information regarding authorship.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+package org.eclipse.esmf.aspectmodel.shacl;
+
+import java.util.stream.Collectors;
+
+import org.eclipse.esmf.aspectmodel.shacl.constraint.AllowedLanguagesConstraint;
+import org.eclipse.esmf.aspectmodel.shacl.constraint.AllowedValuesConstraint;
+import org.eclipse.esmf.aspectmodel.shacl.constraint.AndConstraint;
+import org.eclipse.esmf.aspectmodel.shacl.constraint.ClassConstraint;
+import org.eclipse.esmf.aspectmodel.shacl.constraint.Constraint;
+import org.eclipse.esmf.aspectmodel.shacl.constraint.DatatypeConstraint;
+import org.eclipse.esmf.aspectmodel.shacl.constraint.DisjointConstraint;
+import org.eclipse.esmf.aspectmodel.shacl.constraint.EqualsConstraint;
+import org.eclipse.esmf.aspectmodel.shacl.constraint.HasValueConstraint;
+import org.eclipse.esmf.aspectmodel.shacl.constraint.LessThanConstraint;
+import org.eclipse.esmf.aspectmodel.shacl.constraint.LessThanOrEqualsConstraint;
+import org.eclipse.esmf.aspectmodel.shacl.constraint.MaxCountConstraint;
+import org.eclipse.esmf.aspectmodel.shacl.constraint.MaxExclusiveConstraint;
+import org.eclipse.esmf.aspectmodel.shacl.constraint.MaxInclusiveConstraint;
+import org.eclipse.esmf.aspectmodel.shacl.constraint.MaxLengthConstraint;
+import org.eclipse.esmf.aspectmodel.shacl.constraint.MinCountConstraint;
+import org.eclipse.esmf.aspectmodel.shacl.constraint.MinExclusiveConstraint;
+import org.eclipse.esmf.aspectmodel.shacl.constraint.MinInclusiveConstraint;
+import org.eclipse.esmf.aspectmodel.shacl.constraint.MinLengthConstraint;
+import org.eclipse.esmf.aspectmodel.shacl.constraint.NodeConstraint;
+import org.eclipse.esmf.aspectmodel.shacl.constraint.NodeKindConstraint;
+import org.eclipse.esmf.aspectmodel.shacl.constraint.NotConstraint;
+import org.eclipse.esmf.aspectmodel.shacl.constraint.OrConstraint;
+import org.eclipse.esmf.aspectmodel.shacl.constraint.PatternConstraint;
+import org.eclipse.esmf.aspectmodel.shacl.constraint.XoneConstraint;
+import org.eclipse.esmf.aspectmodel.shacl.violation.EvaluationContext;
+
+import org.apache.jena.rdf.model.Property;
+
+/**
+ * Creates a short textual summary of a {@link Shape} or a {@link Constraint}.
+ */
+public class ShapeSummarizer implements Shape.Visitor<String>, Constraint.Visitor<String> {
+   private final EvaluationContext context;
+
+   public ShapeSummarizer( final EvaluationContext context ) {
+      this.context = context;
+   }
+
+   @Override
+   public String visitNodeShape( final Shape.Node nodeShape ) {
+      return "%s: %s".formatted( nodeShape.attributes().uri().map( context::shortUri ).orElse( "(anonymous node shape)" ),
+            nodeShape.attributes().constraints().stream().map( constraint ->
+                  constraint.accept( this ) ).collect( Collectors.joining( ", " ) ) );
+   }
+
+   @Override
+   public String visitPropertyShape( final Shape.Property propertyShape ) {
+      return "%s with path %s: %s".formatted(
+            propertyShape.attributes().uri().map( context::shortUri ).orElse( "(anonymous property shape)" ), propertyShape.path(),
+            propertyShape.attributes().constraints().stream().map( constraint ->
+                  constraint.accept( this ) ).collect( Collectors.joining( ", " ) ) );
+   }
+
+   /**
+    * Default implementation for those constraints that either have no args (e.g. sh:closed) or for which the args should be
+    * excluded since they could be too long (e.g. sh:SPARQLConstraint).
+    *
+    * @param constraint the constraint
+    * @return a short string representation of the constraint
+    */
+   @Override
+   public String visit( final Constraint constraint ) {
+      return constraint.name();
+   }
+
+   @Override
+   public String visitAllowedLanguagesConstraint( final AllowedLanguagesConstraint constraint ) {
+      return "%s (allowed languages: %s)".formatted( constraint.name(), constraint.allowedLanguages() );
+   }
+
+   @Override
+   public String visitAllowedValuesConstraint( final AllowedValuesConstraint constraint ) {
+      return "%s (allowed values: %s)".formatted( constraint.name(), constraint.allowedValues().stream().map( context::value ).toList() );
+   }
+
+   @Override
+   public String visitAndConstraint( final AndConstraint constraint ) {
+      return "%s (with referenced shapes: %s)".formatted( constraint.name(),
+            constraint.shapes().stream().map( shape -> shape.accept( this ) ) );
+   }
+
+   @Override
+   public String visitClassConstraint( final ClassConstraint constraint ) {
+      return "%s (allowed class: %s)".formatted( constraint.name(), context.shortUri( constraint.allowedClass().getURI() ) );
+   }
+
+   @Override
+   public String visitDatatypeConstraint( final DatatypeConstraint constraint ) {
+      return "%s (allowed type: %s)".formatted( constraint.name(), context.shortUri( constraint.allowedTypeUri() ) );
+   }
+
+   @Override
+   public String visitDisjointConstraint( final DisjointConstraint constraint ) {
+      return "%s (disjoint with: %s which has value %s)".formatted( constraint.name(),
+            context.shortUri( constraint.otherProperty().getURI() ), otherPropertyValue( constraint.otherProperty() ) );
+   }
+
+   @Override
+   public String visitEqualsConstraint( final EqualsConstraint constraint ) {
+      return "%s (equal to: %s which has value %s)".formatted( constraint.name(),
+            context.shortUri( constraint.otherProperty().getURI() ), otherPropertyValue( constraint.otherProperty() ) );
+   }
+
+   @Override
+   public String visitHasValueConstraint( final HasValueConstraint constraint ) {
+      return "%s (allowed value: %s)".formatted( constraint.name(), context.value( constraint.allowedValue() ) );
+   }
+
+   @Override
+   public String visitLessThanConstraint( final LessThanConstraint constraint ) {
+      return "%s (less than to: %s which has value %s)".formatted( constraint.name(),
+            context.shortUri( constraint.otherProperty().getURI() ), otherPropertyValue( constraint.otherProperty() ) );
+   }
+
+   @Override
+   public String visitLessThanOrEqualsConstraint( final LessThanOrEqualsConstraint constraint ) {
+      return "%s (less than or equal to: %s which has value %s)".formatted( constraint.name(),
+            context.shortUri( constraint.otherProperty().getURI() ), otherPropertyValue( constraint.otherProperty() ) );
+   }
+
+   @Override
+   public String visitMaxCountConstraint( final MaxCountConstraint constraint ) {
+      return "%s (max occurrences: %d)".formatted( constraint.name(), constraint.maxCount() );
+   }
+
+   @Override
+   public String visitMaxExclusiveConstraint( final MaxExclusiveConstraint constraint ) {
+      return "%s (max value: %s)".formatted( constraint.name(), context.value( constraint.maxValue() ) );
+   }
+
+   @Override
+   public String visitMaxInclusiveConstraint( final MaxInclusiveConstraint constraint ) {
+      return "%s (max value: %s)".formatted( constraint.name(), context.value( constraint.maxValue() ) );
+   }
+
+   @Override
+   public String visitMaxLengthConstraint( final MaxLengthConstraint constraint ) {
+      return "%s (max length: %d)".formatted( constraint.name(), constraint.maxLength() );
+   }
+
+   @Override
+   public String visitMinCountConstraint( final MinCountConstraint constraint ) {
+      return "%s (min occurrences: %d)".formatted( constraint.name(), constraint.minCount() );
+   }
+
+   @Override
+   public String visitMinExclusiveConstraint( final MinExclusiveConstraint constraint ) {
+      return "%s (min value: %s)".formatted( constraint.name(), context.value( constraint.minValue() ) );
+   }
+
+   @Override
+   public String visitMinInclusiveConstraint( final MinInclusiveConstraint constraint ) {
+      return "%s (min value: %s)".formatted( constraint.name(), context.value( constraint.minValue() ) );
+   }
+
+   @Override
+   public String visitMinLengthConstraint( final MinLengthConstraint constraint ) {
+      return "%s (min length: %d)".formatted( constraint.name(), constraint.minLength() );
+   }
+
+   @Override
+   public String visitNodeConstraint( final NodeConstraint constraint ) {
+      return "%s (referenced shape: %s)".formatted( constraint.name(), constraint.targetShape().get().accept( this ) );
+   }
+
+   @Override
+   public String visitNodeKindConstraint( final NodeKindConstraint constraint ) {
+      return "%s (allowed node kind: %s)".formatted( constraint.name(), constraint.allowedNodeKind().humanReadable() );
+   }
+
+   @Override
+   public String visitNotConstraint( final NotConstraint constraint ) {
+      return "%s (negated: %s)".formatted( constraint.name(), constraint.constraint().accept( this ) );
+   }
+
+   @Override
+   public String visitOrConstraint( final OrConstraint constraint ) {
+      return "%s (with referenced shapes: %s)".formatted( constraint.name(),
+            constraint.shapes().stream().map( shape -> shape.accept( this ) ) );
+   }
+
+   @Override
+   public String visitPatternConstraint( final PatternConstraint constraint ) {
+      return "%s (pattern: %s)".formatted( constraint.name(), constraint.pattern() );
+   }
+
+   @Override
+   public String visitXoneConstraint( final XoneConstraint constraint ) {
+      return "%s (with referenced shapes: %s)".formatted( constraint.name(),
+            constraint.shapes().stream().map( shape -> shape.accept( this ) ) );
+   }
+
+   protected String otherPropertyValue( final Property property ) {
+      return context.value( context.element().getProperty( property ).getObject() );
+   }
+}