shacl 0.1.0

data/lib/shacl/algebra/or.rb

@@ -0,0 +1,46 @@
+module SHACL::Algebra
+  ##
+  class Or < Operator
+    NAME = :or
+
+    ##
+    # Specifies the condition that each value node conforms to at least one of the provided shapes. This is comparable to disjunction and the logical "or" operator.
+    #
+    # @example
+    #   ex:OrConstraintExampleShape
+    #   	a sh:NodeShape ;
+    #   	sh:targetNode ex:Bob ;
+    #   	sh:or (
+    #   		[
+    #   			sh:path ex:firstName ;
+    #   			sh:minCount 1 ;
+    #   		]
+    #   		[
+    #   			sh:path ex:givenName ;
+    #   			sh:minCount 1 ;
+    #   		]
+    #   	) .
+    #
+    # @param [RDF::Term] node
+    # @param [Hash{Symbol => Object}] options
+    # @return [Array<SHACL::ValidationResult>]
+    def conforms(node, path: nil, depth: 0, **options)
+      log_debug(NAME, depth: depth) {SXP::Generator.string({node: node}.to_sxp_bin)}
+      operands.each do |op|
+        results = op.conforms(node, depth: depth + 1, **options)
+        next unless results.all?(&:conform?)
+        return satisfy(focus: node, path: path,
+          value: node,
+          message: "node conforms to some shape",
+          component: RDF::Vocab::SHACL.OrConstraintComponent,
+          depth: depth, **options)
+      end
+      return not_satisfied(focus: node, path: path,
+        value: node,
+        message: "node does not conform to any shape",
+        resultSeverity: options.fetch(:severity),
+        component: RDF::Vocab::SHACL.OrConstraintComponent,
+        depth: depth, **options)
+    end
+  end
+end

data/lib/shacl/algebra/property_shape.rb

@@ -0,0 +1,190 @@
+require_relative "shape"
+
+module SHACL::Algebra
+  ##
+  class PropertyShape < Shape
+    NAME = :PropertyShape
+
+    # Validates the specified `property` within `graph`, a list of {ValidationResult}.
+    #
+    # A property conforms the nodes found by evaluating it's `path` all conform.
+    #
+    # @param [RDF::Term] node
+    # @param [Hash{Symbol => Object}] options
+    # @return [Array<SHACL::ValidationResult>]
+    #   Returns a validation result for each value node.
+    def conforms(node, depth: 0, **options)
+      return [] if deactivated?
+      options = id ? options.merge(shape: id) : options
+      options = options.merge(severity: RDF::Vocab::SHACL.Violation)
+
+      # Add some instance options to the argument
+      options = %i{
+        flags
+        qualifiedMinCount
+        qualifiedMaxCount
+        qualifiedValueShapesDisjoint
+        severity
+      }.inject(options) do |memo, sym|
+        @options[sym] ? memo.merge(sym => @options[sym]) : memo
+      end
+
+      path = @options[:path]
+      log_debug(NAME, depth: depth) {SXP::Generator.string({id: id, node: node, path: path}.to_sxp_bin)}
+      log_error(NAME, "no path", depth: depth) unless path
+
+      # Turn the `path` attribute into a SPARQL Property Path and evaluate to find related nodes.
+      value_nodes = if path.is_a?(RDF::URI)
+        graph.query(subject: node, predicate: path).objects
+      elsif path.evaluatable?
+        path.execute(graph,
+          subject: node,
+          object: RDF::Query::Variable.new(:object)).map do
+            |soln| soln[:object]
+        end.compact.uniq
+      else
+        log_error(NAME, "Can't handle path", depth: depth) {path.to_sxp}
+        []
+      end
+
+      # Evaluate against builtins
+      builtin_results = @options.map do |k, v|
+        self.send("builtin_#{k}".to_sym, v, node, path, value_nodes, depth: depth + 1, **options) if self.respond_to?("builtin_#{k}".to_sym)
+      end.flatten.compact
+
+      # Evaluate against operands
+      op_results = operands.map do |op|
+        if op.is_a?(QualifiedValueShape)
+          # All value nodes are passed
+          op.conforms(node, value_nodes: value_nodes, path: path, depth: depth + 1, **options)
+        else
+          value_nodes.map do |n|
+           res = op.conforms(n, path: path, depth: depth + 1, **options)
+           if op.is_a?(NodeShape) && !res.all?(&:conform?)
+             # Special case for embedded NodeShape
+             not_satisfied(focus: node, path: path,
+               value: n,
+               message: "node does not conform to #{op.id}",
+               resultSeverity: options.fetch(:severity),
+               component: RDF::Vocab::SHACL.NodeConstraintComponent,
+               **options)
+           else
+             res
+           end
+         end
+        end
+      end.flatten.compact
+
+      builtin_results + op_results
+    end
+
+    # The path defined on this property shape
+    # @return [RDF::URI, ]
+    def path
+      @options[:path]
+    end
+
+    # Specifies the condition that each value node is smaller than all the objects of the triples that have the focus node as subject and the value of sh:lessThan as predicate.
+    #
+    # @example
+    #   ex:LessThanExampleShape
+    #   	a sh:NodeShape ;
+    #   	sh:property [
+    #   		sh:path ex:startDate ;
+    #   		sh:lessThan ex:endDate ;
+    #   	] .
+    #
+    # @param [RDF::URI] property the property of the focus node whose values must be equal to some value node.
+    # @param [RDF::Term] node the focus node
+    # @param [RDF::URI, SPARQL::Algebra::Expression] path (nil) the property path from the focus node to the value nodes.
+    # @param [Array<RDF::Term>] value_nodes
+    # @return [Array<SHACL::ValidationResult>]
+    def builtin_lessThan(property, node, path, value_nodes, **options)
+      terms = graph.query(subject: node, predicate: property).objects
+      compare(:<, terms, node, path, value_nodes,
+              RDF::Vocab::SHACL.LessThanConstraintComponent, **options)
+    end
+
+    # Specifies the condition that each value node is smaller than or equal to all the objects of the triples that have the focus node as subject and the value of sh:lessThanOrEquals as predicate.
+    #
+    # @param [RDF::URI] property the property of the focus node whose values must be equal to some value node.
+    # @param [RDF::Term] node the focus node
+    # @param [RDF::URI, SPARQL::Algebra::Expression] path (nil) the property path from the focus node to the value nodes.
+    # @param [Array<RDF::Term>] value_nodes
+    # @return [Array<SHACL::ValidationResult>]
+    def builtin_lessThanOrEquals(property, node, path, value_nodes, **options)
+      terms = graph.query(subject: node, predicate: property).objects
+      compare(:<=, terms, node, path, value_nodes,
+              RDF::Vocab::SHACL.LessThanOrEqualsConstraintComponent, **options)
+    end
+
+    ##
+    # Builin evaluators
+    ##
+
+    # Specifies the maximum number of value nodes.
+    #
+    # @param [Integer] count
+    # @param [RDF::Term] node the focus node
+    # @param [RDF::URI, SPARQL::Algebra::Expression] path (nil) the property path from the focus node to the value nodes.
+    # @param [Array<RDF::Term>] value_nodes
+    # @return [Array<SHACL::ValidationResult>]
+    def builtin_maxCount(count, node, path, value_nodes, **options)
+      satisfy(focus: node, path: path,
+        message: "#{value_nodes.count} <= maxCount #{count}",
+        resultSeverity: (options.fetch(:severity) unless value_nodes.count <= count.to_i),
+        component: RDF::Vocab::SHACL.MaxCountConstraintComponent,
+        **options)
+    end
+
+    # Specifies the minimum number of value nodes.
+    #
+    # @example
+    #   ex:MinCountExampleShape
+    #   	a sh:PropertyShape ;
+    #   	sh:targetNode ex:Alice, ex:Bob ;
+    #   	sh:path ex:name ;
+    #   	sh:minCount 1 .
+    #
+    # @param [Integer] count
+    # @param [RDF::Term] node the focus node
+    # @param [RDF::URI, SPARQL::Algebra::Expression] path (nil) the property path from the focus node to the value nodes.
+    # @param [Array<RDF::Term>] value_nodes
+    # @return [Array<SHACL::ValidationResult>]
+    def builtin_minCount(count, node, path, value_nodes, **options)
+      satisfy(focus: node, path: path,
+        message: "#{value_nodes.count} >= minCount #{count}",
+        resultSeverity: (options.fetch(:severity) unless value_nodes.count >= count.to_i),
+        component: RDF::Vocab::SHACL.MinCountConstraintComponent,
+        **options)
+    end
+
+    # The property `sh:uniqueLang` can be set to `true` to specify that no pair of value nodes may use the same language tag.
+    #
+    # @param [Boolean] uniq
+    # @param [RDF::Term] node the focus node
+    # @param [RDF::URI, SPARQL::Algebra::Expression] path (nil) the property path from the focus node to the value nodes.
+    # @param [Array<RDF::Term>] value_nodes
+    # @return [Array<SHACL::ValidationResult>]
+    def builtin_uniqueLang(uniq, node, path, value_nodes, **options)
+      if !value_nodes.all?(&:literal?)
+        not_satisfied(focus: node, path: path,
+          message: "not all values are literals",
+          resultSeverity: options.fetch(:severity),
+          component: RDF::Vocab::SHACL.UniqueLangConstraintComponent,
+          **options)
+      elsif value_nodes.map(&:language).compact.length != value_nodes.map(&:language).compact.uniq.length
+        not_satisfied(focus: node, path: path,
+          message: "not all values have unique language tags",
+          resultSeverity: options.fetch(:severity),
+          component: RDF::Vocab::SHACL.UniqueLangConstraintComponent,
+          **options)
+      else
+        satisfy(focus: node, path: path,
+          message: "all literals have unique language tags",
+          component: RDF::Vocab::SHACL.UniqueLangConstraintComponent,
+          **options)
+      end
+    end
+  end
+end

data/lib/shacl/algebra/qualified_value_shape.rb

@@ -0,0 +1,47 @@
+module SHACL::Algebra
+  ##
+  class QualifiedValueShape < Operator
+    NAME = :qualifiedValueShape
+
+    ##
+    # Specifies the condition that a specified number of value nodes conforms to the given shape. Each `sh:qualifiedValueShape` can have: one value for `sh:qualifiedMinCount`, one value for s`h:qualifiedMaxCount` or, one value for each, at the same subject.
+    #
+    # @param [Array<RDF::Term>] value_nodes
+    # @param [Hash{Symbol => Object}] options
+    # @return [Array<SHACL::ValidationResult>]
+    def conforms(node, path:, value_nodes:, depth: 0, **options)
+      log_debug(NAME, depth: depth) {SXP::Generator.string({node: node, value_nodes: value_nodes}.to_sxp_bin)}
+      max_count = options.fetch(:qualifiedMaxCount, 0).to_i
+      min_count = options.fetch(:qualifiedMinCount, 0).to_i
+      # FIXME: figure this out
+      disjoint = options[:qualifiedValueShapesDisjoint]
+
+      operands.map do |op|
+        results = value_nodes.map do |n|
+          op.conforms(n, depth: depth + 1, **options)
+        end.flatten.compact
+
+        count = results.select(&:conform?).length
+        log_debug(NAME, depth: depth) {"#{count}/#{results} conforming shapes"}
+        if count < min_count
+          not_satisfied(focus: node, path: path,
+            message: "only #{count} conforming values, requires at least #{min_count}",
+            resultSeverity: options.fetch(:severity),
+            component: RDF::Vocab::SHACL.QualifiedMinCountConstraintComponent,
+            depth: depth, **options)
+        elsif count > max_count
+          not_satisfied(focus: node, path: path,
+            message: "#{count} conforming values, requires at most #{max_count}",
+            resultSeverity: options.fetch(:severity),
+            component: RDF::Vocab::SHACL.QualifiedMaxCountConstraintComponent,
+            depth: depth, **options)
+        else
+          satisfy(focus: node, path: path,
+            message: "#{min_count} <= #{count} <= #{max_count} values conform",
+            component: RDF::Vocab::SHACL.QualifiedMinCountConstraintComponent,
+            depth: depth, **options)
+        end
+      end
+    end
+  end
+end

data/lib/shacl/algebra/shape.rb

@@ -0,0 +1,499 @@
+module SHACL::Algebra
+  ##
+  class Shape < Operator
+    NAME = :Shape
+
+    ##
+    # Returns the nodes matching this particular shape, based upon the shape properties:
+    #  * `targetNode`
+    #  * `targetClass`
+    #  * `targetSubjectsOf`
+    #  * `targetObjectsOf`
+    #  * `id` – where `type` includes `rdfs:Class`
+    #
+    # @return [Array<RDF::Term>]
+    def targetNodes
+      (Array(@options[:targetNode]) +
+      Array(@options[:targetClass]).map do |cls|
+        graph.query(predicate: RDF.type, object: cls).subjects
+      end +
+      Array(@options[:targetSubjectsOf]).map do |pred|
+        graph.query(predicate: pred).subjects
+      end +
+      Array(@options[:targetObjectsOf]).map do |pred|
+        graph.query(predicate: pred).objects
+      end + (
+        Array(type).include?(RDF::RDFS.Class) ?
+          graph.query(predicate: RDF.type, object: id).subjects :
+          []
+      )).flatten.uniq
+    end
+
+    ##
+    # Builin evaluators. These evaulators may be used on either NodeShapes or PropertyShapes.
+    ##
+
+    # Specifies that each value node is a SHACL instance of a given type.
+    #
+    # @example
+    #   ex:ClassExampleShape
+    #   	a sh:NodeShape ;
+    #   	sh:targetNode ex:Bob, ex:Alice, ex:Carol ;
+    #   	sh:property [
+    #   		sh:path ex:address ;
+    #   		sh:class ex:PostalAddress ;
+    #   	] .
+    #
+    # @param [Array<RDF::URI>] types The type expected for each value node.
+    # @param [RDF::Term] node the focus node
+    # @param [RDF::URI, SPARQL::Algebra::Expression] path (nil) the property path from the focus node to the value nodes.
+    # @param [Array<RDF::Term>] value_nodes
+    # @return [Array<SHACL::ValidationResult>]
+    def builtin_class(types, node, path, value_nodes, **options)
+      value_nodes.map do |n|
+        has_type = n.resource? && begin
+          objects = graph.query(subject: n, predicate: RDF.type).objects
+          types.all? {|t| objects.include?(t)}
+        end
+        satisfy(focus: node, path: path,
+          value: n,
+          message: "is#{' not' unless has_type} of class #{type.to_sxp}",
+          resultSeverity: (options.fetch(:severity) unless has_type),
+          component: RDF::Vocab::SHACL.ClassConstraintComponent,
+          **options)
+      end.flatten.compact
+    end
+
+    # Specifies a condition to be satisfied with regards to the datatype of each value node.
+    #
+    # @example
+    #   ex:DatatypeExampleShape
+    #   	a sh:NodeShape ;
+    #   	sh:targetNode ex:Alice, ex:Bob, ex:Carol ;
+    #   	sh:property [
+    #   		sh:path ex:age ;
+    #   		sh:datatype xsd:integer ;
+    #   	] .
+    #
+    #
+    # @param [RDF::URI] datatype the expected datatype of each value node.
+    # @param [RDF::Term] node the focus node
+    # @param [RDF::URI, SPARQL::Algebra::Expression] path (nil) the property path from the focus node to the value nodes.
+    # @return [Array<SHACL::ValidationResult>]
+    def builtin_datatype(datatype, node, path, value_nodes, **options)
+      value_nodes.map do |n|
+        has_datatype = n.literal? && n.datatype == datatype && n.valid?
+        satisfy(focus: node, path: path,
+          value: n,
+          message: "is#{' not' unless has_datatype} a valid literal with datatype #{datatype.to_sxp}",
+          resultSeverity: (options.fetch(:severity) unless has_datatype),
+          component: RDF::Vocab::SHACL.DatatypeConstraintComponent,
+          **options)
+      end.flatten.compact
+    end
+
+    # Specifies the condition that the set of value nodes is disjoint with the set of objects of the triples that have the focus node as subject and the value of sh:disjoint as predicate.
+    #
+    # @example
+    #   ex:DisjointExampleShape
+    #   	a sh:NodeShape ;
+    #   	sh:targetNode ex:USA, ex:Germany ;
+    #   	sh:property [
+    #   		sh:path ex:prefLabel ;
+    #   		sh:disjoint ex:altLabel ;
+    #   	] .
+    #
+    # @param [Array<RDF::URI>] properties the properties of the focus node whose values must be disjoint with the value nodes.
+    # @param [RDF::Term] node the focus node
+    # @param [RDF::URI, SPARQL::Algebra::Expression] path (nil) the property path from the focus node to the value nodes.
+    # @param [Array<RDF::Term>] value_nodes
+    # @return [Array<SHACL::ValidationResult>]
+    def builtin_disjoint(properties, node, path, value_nodes, **options)
+      disjoint_nodes = properties.map do |prop|
+        graph.query(subject: node, predicate: prop).objects
+      end.flatten.compact
+      value_nodes.map do |n|
+        has_value = disjoint_nodes.include?(n)
+        satisfy(focus: node, path: path,
+          value: n,
+          message: "is#{' not' unless has_value} disjoint with #{disjoint_nodes.to_sxp}",
+          resultSeverity: (options.fetch(:severity) if has_value),
+          component: RDF::Vocab::SHACL.DisjointConstraintComponent,
+          **options)
+      end.flatten.compact
+    end
+
+    # Specifies the condition that the set of all value nodes is equal to the set of objects of the triples that have the focus node as subject and the value of sh:equals as predicate.
+    #
+    # @example
+    #   ex:EqualExampleShape
+    #   	a sh:NodeShape ;
+    #   	sh:targetNode ex:Bob ;
+    #   	sh:property [
+    #   		sh:path ex:firstName ;
+    #   		sh:equals ex:givenName ;
+    #   	] .
+    #
+    # @param [RDF::URI] property the property of the focus node whose values must be equal to some value node.
+    # @param [RDF::Term] node the focus node
+    # @param [RDF::URI, SPARQL::Algebra::Expression] path (nil) the property path from the focus node to the value nodes.
+    # @param [Array<RDF::Term>] value_nodes
+    # @return [Array<SHACL::ValidationResult>]
+    def builtin_equals(property, node, path, value_nodes, **options)
+      equal_nodes = graph.query(subject: node, predicate: property).objects
+      (value_nodes.map do |n|
+        has_value = equal_nodes.include?(n)
+        satisfy(focus: node, path: path,
+          value: n,
+          message: "is#{' not' unless has_value} a value in #{equal_nodes.to_sxp}",
+          resultSeverity: (options.fetch(:severity) unless has_value),
+          component: RDF::Vocab::SHACL.EqualsConstraintComponent,
+          **options)
+      end +
+      equal_nodes.map do |n|
+        !value_nodes.include?(n) ?
+          not_satisfied(focus: node, path: path,
+            value: n,
+            message: "should have a value in #{value_nodes.to_sxp}",
+            resultSeverity: options.fetch(:severity),
+            component: RDF::Vocab::SHACL.EqualsConstraintComponent,
+            **options) :
+          nil
+      end).flatten.compact
+    end
+
+    # Specifies the condition that at least one value node is equal to the given RDF term.
+    #
+    # @example
+    #   ex:StanfordGraduate
+    #   	a sh:NodeShape ;
+    #   	sh:targetNode ex:Alice ;
+    #   	sh:property [
+    #   		sh:path ex:alumniOf ;
+    #   		sh:hasValue ex:Stanford ;
+    #   	] .
+    #
+    # @param [RDF::URI] term the term that must be a value of a value node.
+    # @param [RDF::Term] node the focus node
+    # @param [RDF::URI, SPARQL::Algebra::Expression] path (nil) the property path from the focus node to the value nodes.
+    # @param [Array<RDF::Term>] value_nodes
+    # @return [Array<SHACL::ValidationResult>]
+    def builtin_hasValue(term, node, path, value_nodes, **options)
+      has_value = value_nodes.include?(term)
+      [satisfy(focus: node, path: path,
+        message: "is#{' not' unless has_value} the value #{term.to_sxp}",
+        resultSeverity: (options.fetch(:severity) unless has_value),
+        component: RDF::Vocab::SHACL.HasValueConstraintComponent,
+        **options)]
+    end
+
+    # Specifies the condition that each value node is a member of a provided SHACL list.
+    #
+    # @example
+    #   ex:InExampleShape
+    #   	a sh:NodeShape ;
+    #   	sh:targetNode ex:RainbowPony ;
+    #   	sh:property [
+    #   		sh:path ex:color ;
+    #   		sh:in ( ex:Pink ex:Purple ) ;
+    #   	] .
+    #
+    # @param [RDF::URI] list the list which must contain the value nodes..
+    # @param [RDF::Term] node the focus node
+    # @param [RDF::URI, SPARQL::Algebra::Expression] path (nil) the property path from the focus node to the value nodes.
+    # @param [Array<RDF::Term>] value_nodes
+    # @return [Array<SHACL::ValidationResult>]
+    def builtin_in(list, node, path, value_nodes, **options)
+      value_nodes.map do |n|
+        has_value = list.include?(n)
+        satisfy(focus: node, path: path,
+          value: n,
+          message: "is#{' not' unless has_value} a value in #{list.to_sxp}",
+          resultSeverity: (options.fetch(:severity) unless has_value),
+          component: RDF::Vocab::SHACL.InConstraintComponent,
+          **options)
+      end.flatten.compact
+    end
+
+    # The condition specified by sh:languageIn is that the allowed language tags for each value node are limited by a given list of language tags.
+    #
+    # @example
+    #   ex:NewZealandLanguagesShape
+    #   	a sh:NodeShape ;
+    #   	sh:targetNode ex:Mountain, ex:Berg ;
+    #   	sh:property [
+    #   		sh:path ex:prefLabel ;
+    #   		sh:languageIn ( "en" "mi" ) ;
+    #   	] .
+    #
+    # @param [Array<RDF::URI>] datatypes the expected datatype of each value node.
+    # @param [RDF::Term] node the focus node
+    # @param [RDF::URI, SPARQL::Algebra::Expression] path (nil) the property path from the focus node to the value nodes.
+    # @return [Array<SHACL::ValidationResult>]
+    def builtin_languageIn(datatypes, node, path, value_nodes, **options)
+      value_nodes.map do |n|
+        has_language = n.literal? && datatypes.any? {|l| n.language.to_s.start_with?(l)}
+        satisfy(focus: node, path: path,
+          value: n,
+          message: "is#{' not' unless has_language} a literal with a language in #{datatypes.to_sxp}",
+          resultSeverity: (options.fetch(:severity) unless has_language),
+          component: RDF::Vocab::SHACL.LanguageInConstraintComponent,
+          **options)
+      end.flatten.compact
+    end
+
+    # Compares value nodes to be < than the specified value.
+    #
+    # @example
+    #   ex:NumericRangeExampleShape
+    #   	a sh:NodeShape ;
+    #   	sh:targetNode ex:Bob, ex:Alice, ex:Ted ;
+    #   	sh:property [
+    #   		sh:path ex:age ;
+    #   		sh:minInclusive 0 ;
+    #   		sh:maxInclusive 150 ;
+    #   	] .
+    #
+    # @param [RDF::URI] term the term is used to compare each value node.
+    # @param [RDF::Term] node the focus node
+    # @param [RDF::URI, SPARQL::Algebra::Expression] path (nil) the property path from the focus node to the value nodes.
+    # @param [Array<RDF::Term>] value_nodes
+    # @return [Array<SHACL::ValidationResult>]
+    def builtin_maxExclusive(term, node, path, value_nodes, **options)
+      compare(:<, [term], node, path, value_nodes,
+              RDF::Vocab::SHACL.MaxExclusiveConstraintComponent, **options)
+    end
+
+    # Compares value nodes to be <= than the specified value.
+    #
+    # @example
+    #   ex:NumericRangeExampleShape
+    #   	a sh:NodeShape ;
+    #   	sh:targetNode ex:Bob, ex:Alice, ex:Ted ;
+    #   	sh:property [
+    #   		sh:path ex:age ;
+    #   		sh:minInclusive 0 ;
+    #   		sh:maxInclusive 150 ;
+    #   	] .
+    #
+    # @param [RDF::URI] term the term is used to compare each value node.
+    # @param [RDF::Term] node the focus node
+    # @param [RDF::URI, SPARQL::Algebra::Expression] path (nil) the property path from the focus node to the value nodes.
+    # @param [Array<RDF::Term>] value_nodes
+    # @return [Array<SHACL::ValidationResult>]
+    def builtin_maxInclusive(term, node, path, value_nodes, **options)
+      compare(:<=, [term], node, path, value_nodes,
+              RDF::Vocab::SHACL.MaxInclusiveConstraintComponent, **options)
+    end
+
+    # Specifies the maximum string length of each value node that satisfies the condition. This can be applied to any literals and IRIs, but not to blank nodes.
+    #
+    # @param [RDF::URI] term the term is used to compare each value node.
+    # @param [RDF::Term] node the focus node
+    # @param [RDF::URI, SPARQL::Algebra::Expression] path (nil) the property path from the focus node to the value nodes.
+    # @param [Array<RDF::Term>] value_nodes
+    # @return [Array<SHACL::ValidationResult>]
+    def builtin_maxLength(term, node, path, value_nodes, **options)
+      value_nodes.map do |n|
+        compares = !n.node? && n.to_s.length <= term.to_i
+        satisfy(focus: node, path: path,
+          value: n,
+          message: "is#{' not' unless compares} a literal at with length <= #{term.to_sxp}",
+          resultSeverity: (options.fetch(:severity) unless compares),
+          component: RDF::Vocab::SHACL.MaxLengthConstraintComponent,
+          **options)
+      end.flatten.compact
+    end
+
+    # Compares value nodes to be > than the specified value.
+    #
+    # @example
+    #   ex:NumericRangeExampleShape
+    #   	a sh:NodeShape ;
+    #   	sh:targetNode ex:Bob, ex:Alice, ex:Ted ;
+    #   	sh:property [
+    #   		sh:path ex:age ;
+    #   		sh:minInclusive 0 ;
+    #   		sh:maxInclusive 150 ;
+    #   	] .
+    #
+    # @param [RDF::URI] term the term is used to compare each value node.
+    # @param [RDF::Term] node the focus node
+    # @param [RDF::URI, SPARQL::Algebra::Expression] path (nil) the property path from the focus node to the value nodes.
+    # @param [Array<RDF::Term>] value_nodes
+    # @return [Array<SHACL::ValidationResult>]
+    def builtin_minExclusive(term, node, path, value_nodes, **options)
+      compare(:>, [term], node, path, value_nodes,
+              RDF::Vocab::SHACL.MinExclusiveConstraintComponent, **options)
+    end
+
+    # Compares value nodes to be >= than the specified value.
+    #
+    # @example
+    #   ex:NumericRangeExampleShape
+    #   	a sh:NodeShape ;
+    #   	sh:targetNode ex:Bob, ex:Alice, ex:Ted ;
+    #   	sh:property [
+    #   		sh:path ex:age ;
+    #   		sh:minInclusive 0 ;
+    #   		sh:maxInclusive 150 ;
+    #   	] .
+    #
+    # @param [RDF::URI] term the term is used to compare each value node.
+    # @param [RDF::Term] node the focus node
+    # @param [RDF::URI, SPARQL::Algebra::Expression] path (nil) the property path from the focus nod to the value nodes.
+    # @param [Array<RDF::Term>] value_nodes
+    # @return [Array<SHACL::ValidationResult>]
+    def builtin_minInclusive(term, node, path, value_nodes, **options)
+      compare(:>=, [term], node, path, value_nodes,
+              RDF::Vocab::SHACL.MinInclusiveConstraintComponent, **options)
+    end
+
+    # Specifies the minimum string length of each value node that satisfies the condition. This can be applied to any literals and IRIs, but not to blank nodes.
+    #
+    # @param [RDF::URI] term the term is used to compare each value node.
+    # @param [RDF::Term] node the focus node
+    # @param [RDF::URI, SPARQL::Algebra::Expression] path (nil) the property path from the focus node to the value nodes.
+    # @param [Array<RDF::Term>] value_nodes
+    # @return [Array<SHACL::ValidationResult>]
+    def builtin_minLength(term, node, path, value_nodes, **options)
+      value_nodes.map do |n|
+        compares = !n.node? && n.to_s.length >= term.to_i
+        satisfy(focus: node, path: path,
+          value: n,
+          message: "is#{' not' unless compares} a literal with length >= #{term.to_sxp}",
+          resultSeverity: (options.fetch(:severity) unless compares),
+          component: RDF::Vocab::SHACL.MinLengthConstraintComponent,
+          **options)
+      end.flatten.compact
+    end
+
+    # The matrix of comparisons of different types of nodes
+    # @return {Hash{Class => RDF::URI}}
+    NODE_KIND_COMPARE = {
+      RDF::URI => [
+        RDF::Vocab::SHACL.IRI,
+        RDF::Vocab::SHACL.BlankNodeOrIRI,
+        RDF::Vocab::SHACL.IRIOrLiteral,
+      ],
+      RDF::Node => [
+        RDF::Vocab::SHACL.BlankNode,
+        RDF::Vocab::SHACL.BlankNodeOrIRI,
+        RDF::Vocab::SHACL.BlankNodeOrLiteral,
+      ],
+      RDF::Literal => [
+        RDF::Vocab::SHACL.Literal,
+        RDF::Vocab::SHACL.IRIOrLiteral,
+        RDF::Vocab::SHACL.BlankNodeOrLiteral,
+      ]
+    }
+
+    # Specifies a condition to be satisfied by the RDF node kind of each value node.
+    #
+    # @example
+    #   ex:NodeKindExampleShape
+    #   	a sh:NodeShape ;
+    #   	sh:targetObjectsOf ex:knows ;
+    #   	sh:nodeKind sh:IRI .
+    #
+    # @param [RDF::URI] term the kind of node to match each value node.
+    # @param [RDF::Term] node the focus node
+    # @param [RDF::URI, SPARQL::Algebra::Expression] path (nil) the property path from the focus node to the to the value nodes.
+    # @param [Array<RDF::Term>] value_nodes
+    # @return [Array<SHACL::ValidationResult>]
+    def builtin_nodeKind(term, node, path, value_nodes, **options)
+      value_nodes.map do |n|
+        compares = NODE_KIND_COMPARE.fetch(n.class, []).include?(term)
+        satisfy(focus: node, path: path,
+          value: n,
+          message: "is#{' not' unless compares} a node kind match of #{term.to_sxp}",
+          resultSeverity: (options.fetch(:severity) unless compares),
+          component: RDF::Vocab::SHACL.NodeKindConstraintComponent,
+          **options)
+      end.flatten.compact
+    end
+
+    # Specifies a regular expression that each value node matches to satisfy the condition.
+    #
+    # @example
+    #   ex:PatternExampleShape
+    #   	a sh:NodeShape ;
+    #   	sh:targetNode ex:Bob, ex:Alice, ex:Carol ;
+    #   	sh:property [
+    #   		sh:path ex:bCode ;
+    #   		sh:pattern "^B" ;    # starts with 'B'
+    #   		sh:flags "i" ;       # Ignore case
+    #   	] .
+    #
+    # @param [RDF::URI] pattern A regular expression that all value nodes need to match.
+    # @param [RDF::Term] node the focus node
+    # @param [RDF::URI, SPARQL::Algebra::Expression] path (nil) the property path from the focus node to the value nodes..
+    # @param [Array<RDF::Term>] value_nodes
+    # @return [Array<SHACL::ValidationResult>]
+    def builtin_pattern(pattern, node, path, value_nodes, **options)
+      flags = options[:flags].to_s
+      regex_opts = 0 |
+      regex_opts |= Regexp::MULTILINE  if flags.include?(?m)
+      regex_opts |= Regexp::IGNORECASE if flags.include?(?i)
+      regex_opts |= Regexp::EXTENDED   if flags.include?(?x)
+      pat = Regexp.new(pattern, regex_opts)
+
+      value_nodes.map do |n|
+        compares = !n.node? && pat.match?(n.to_s)
+        satisfy(focus: node, path: path,
+          value: n,
+          message: "is#{' not' unless compares} a match #{pat.inspect}",
+          resultSeverity: (options.fetch(:severity) unless compares),
+          component: RDF::Vocab::SHACL.PatternConstraintComponent,
+          **options)
+      end.flatten.compact
+    end
+
+  protected
+
+    # Common comparison logic for lessThan, lessThanOrEqual, max/minInclusive/Exclusive
+    def compare(method, terms, node, path, value_nodes, component, **options)
+      value_nodes.map do |left|
+        results = terms.map do |right|
+          case left
+          when RDF::Literal
+            unless right.literal? && (
+              (left.simple? && right.simple?) ||
+              (left.is_a?(RDF::Literal::Numeric) && right.is_a?(RDF::Literal::Numeric)) ||
+              (left.datatype == right.datatype && left.language == right.language))
+              :incomperable
+            else
+              left.send(method, right)
+            end
+          when RDF::URI
+            right.uri? && left.send(method, right)
+          else
+            :incomperable
+          end
+        end
+
+        if results.include?(:incomperable)
+          not_satisfied(focus: node, path: path,
+            value: left,
+            message: "is incomperable with #{terms.to_sxp}",
+            resultSeverity: options.fetch(:severity),
+            component: component,
+            **options)
+        elsif results.include?(false)
+          not_satisfied(focus: node, path: path,
+            value: left,
+            message: "is not #{method} than #{terms.to_sxp}",
+            resultSeverity: options.fetch(:severity),
+            component: component,
+            **options)
+        else
+          satisfy(focus: node, path: path,
+            value: left,
+            message: "is #{method} than #{terms.to_sxp}",
+            component: component,
+            **options)
+        end
+      end.flatten.compact
+    end
+  end
+end