Examples with NodeShape org.apache.jena.shacl.parser.NodeShape used on opensource projects

Example 1 with NodeShape

use of org.apache.jena.shacl.parser.NodeShape in project jena by apache.

the class VLib method validateShape.

public static void validateShape(ValidationContext vCxt, Graph data, Shape shape, Node focusNode) {
    if (shape.deactivated())
        return;
    if (vCxt.isVerbose())
        out.println("S: " + shape);
    Path path;
    Set<Node> vNodes;
    if (shape instanceof NodeShape) {
        path = null;
        vNodes = null;
    } else if (shape instanceof PropertyShape) {
        PropertyShape propertyShape = (PropertyShape) shape;
        path = propertyShape.getPath();
        vNodes = ShaclPaths.valueNodes(data, focusNode, propertyShape.getPath());
    } else {
        if (vCxt.isVerbose())
            out.println("Z: " + shape);
        return;
    }
    // Constraints of this shape.
    for (Constraint c : shape.getConstraints()) {
        if (vCxt.isVerbose())
            out.println("C: " + c);
        evalConstraint(vCxt, data, shape, focusNode, path, vNodes, c);
    }
    // Reachable shapes.
    // Follow sh:property (sh:node behaves as a constraint).
    validationPropertyShapes(vCxt, data, shape.getPropertyShapes(), focusNode);
    if (vCxt.isVerbose())
        out.println();
}

Example 2 with NodeShape

use of org.apache.jena.shacl.parser.NodeShape in project webofneeds by researchstudio-sat.

the class Shacl2JavaInstanceFactory method instantiate.

/**
 * Creates all instances for the given node / shape combination.
 *
 * @param node may be null, in which case all target nodes of the shape are
 * chosen.
 * @param shape
 * @return the set of nodes reached during instantiation that have not been
 * instantiated yet
 */
private Set<DataNodeAndShapes> instantiate(Node node, Shape shape, boolean forceApplyShape, InstantiationContext ctx) {
    if (shape.getShapeNode().isBlank()) {
        if (node == null) {
            if (logger.isDebugEnabled()) {
                logger.debug("Not instantiating entity for shape {}", shape.getShapeNode().getBlankNodeLabel());
            }
        } else {
            throw new IllegalArgumentException(String.format("Cannot instantiate entity for node %s: shape %s is a blank node", node.getLocalName(), shape.getShapeNode().getBlankNodeLabel()));
        }
    }
    Collection<Node> focusNodes;
    if (node != null) {
        if (!forceApplyShape) {
            if (!isFocusNode(shape, node, ctx.getData())) {
                return Collections.emptySet();
            }
        }
        if (ctx.hasInstanceForFocusNode(node) && !ctx.isNewShapeForFocusNode(node, shape)) {
            return Collections.emptySet();
        }
        if (logger.isDebugEnabled()) {
            logger.debug("processing node {} with shape {}", node, shape);
        }
        focusNodes = Collections.singleton(node);
    } else {
        focusNodes = focusNodes(ctx.getData(), shape);
    }
    if (focusNodes.isEmpty()) {
        return Collections.emptySet();
    }
    final Set<Node> finalFocusNodes = removeNodesInstantiatedInBaseContext(focusNodes).stream().filter(fnode -> {
        // check if focusnode conforms to shape
        ValidationContext vCtx = ctx.newValidationContext();
        VLib.validateShape(vCtx, ctx.getData(), shape, fnode);
        if (vCtx.hasViolation()) {
            if (logger.isDebugEnabled()) {
                logger.debug("skipping node {} as it does not conform to shape {}", fnode, shape.getShapeNode());
            }
            return false;
        } else {
            if (logger.isDebugEnabled()) {
                logger.debug("accepting node {} as it conforms to shape {}", fnode, shape.getShapeNode());
            }
        }
        return true;
    }).collect(Collectors.toSet());
    String shapeURI = shape.getShapeNode().getURI();
    Set<Class<?>> classesForShape = ctx.getClassesForShape(shapeURI);
    if (classesForShape == null) {
        if (logger.isDebugEnabled()) {
            logger.debug("No class found to instantiate for shape {}.", shape.getShapeNode().getLocalName());
            logger.debug("Instantiation context:");
            logger.debug(ctx.getFormattedState());
        }
        throw new IllegalArgumentException(String.format("No class found to instantiate for shape %s, more information is logged on loglevel debug", shape.getShapeNode().getLocalName()));
    }
    Set ret = classesForShape.stream().map(classForShape -> {
        // our shape might reference other shapes via sh:node (maybe through other
        // operators such as sh:or)
        // * we remember them for wiring
        // * we return them as dependencies to instantiate
        Set<Shape> allRelevantShapes = ShapeUtils.getNodeShapes((NodeShape) shape, shapes);
        Map<Path, Set<PropertyShape>> propertyShapesPerPath = getPropertyShapesByPath(allRelevantShapes);
        allRelevantShapes.add(shape);
        return finalFocusNodes.parallelStream().map(focusNode -> {
            try {
                Object instance = null;
                if (logger.isDebugEnabled()) {
                    logger.debug("attempting to instantiate focus node {} with shape {}", focusNode, shape.getShapeNode());
                }
                instance = instantiate(shape, shapeURI, focusNode, classForShape, ctx);
                if (instance == null) {
                    // maybe another shape works better
                    return Collections.emptySet();
                }
                ctx.addInstanceForFocusNode(focusNode, instance);
                ctx.setFocusNodeForInstance(instance, focusNode);
                ctx.setClassForInstance(instance, classForShape);
                ctx.addShapesForFocusNode(focusNode, allRelevantShapes);
            } catch (NoSuchMethodException e) {
                throw new IllegalArgumentException(String.format("Cannot instantiate %s for shape %s", classForShape.getName(), shape.getShapeNode().getLocalName()) + ": no parameterless constructor found", e);
            } catch (IllegalAccessException | InstantiationException | InvocationTargetException e) {
                throw new IllegalArgumentException(String.format("Cannot instantiate %s for shape %s - %s: %s", classForShape.getName(), shape.getShapeNode().getLocalName(), e.getClass().getSimpleName(), e.getMessage()), e);
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Collecting dependencies of focus node {}", focusNode);
            }
            return propertyShapesPerPath.entrySet().parallelStream().map(pathToShapes -> {
                Path path = pathToShapes.getKey();
                Set<PropertyShape> propertyShapes = pathToShapes.getValue();
                if (logger.isDebugEnabled()) {
                    logger.debug("\tcollecting new focus nodes via path {} ", path);
                }
                Set<Node> valueNodes = ShaclPaths.valueNodes(ctx.getData(), focusNode, path);
                if (valueNodes.isEmpty()) {
                    return Collections.emptySet();
                }
                return valueNodes.stream().map(valueNode -> propertyShapes.stream().map(ctx::getNodeShapesForPropertyShape).map(nodeShapeNodes -> new DataNodeAndShapes(valueNode, nodeShapeNodes)).collect(Collectors.toSet())).reduce(CollectionUtils::union).orElse(Collections.emptySet());
            }).reduce(CollectionUtils::union).orElse(Collections.emptySet());
        }).reduce(CollectionUtils::union).orElse(Collections.emptySet());
    }).reduce(CollectionUtils::union).orElse(Collections.emptySet());
    return ret;
}