shacl 0.2.1 → 0.4.0

data/lib/shacl/algebra/property_shape.rb

@@ -9,25 +9,15 @@ module SHACL::Algebra
     #
     # A property conforms the nodes found by evaluating it's `path` all conform.
     #
-    # @param [RDF::Term] node
+    # @param [RDF::Term] node focus 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
+      options[:severity] = @options[:severity] if @options[:severity]
+      options[:severity] ||= RDF::Vocab::SHACL.Violation
 
       path = @options[:path]
       log_debug(NAME, depth: depth) {SXP::Generator.string({id: id, node: node, path: path}.to_sxp_bin)}
@@ -54,9 +44,9 @@ module SHACL::Algebra
 
       # Evaluate against operands
       op_results = operands.map do |op|
-        if op.is_a?(QualifiedValueShape)
+        if op.is_a?(QualifiedValueConstraintComponent) || op.is_a?(SPARQLConstraintComponent)
           # All value nodes are passed
-          op.conforms(node, value_nodes: value_nodes, path: path, depth: depth + 1, **options)
+          op.conforms(node, path: path, value_nodes: value_nodes, depth: depth + 1, **options)
         else
           value_nodes.map do |n|
            res = op.conforms(n, path: path, depth: depth + 1, **options)
@@ -79,7 +69,7 @@ module SHACL::Algebra
     end
 
     # The path defined on this property shape
-    # @return [RDF::URI, ]
+    # @return [RDF::URI, SPARQL::Algebra::Expression]
     def path
       @options[:path]
     end
@@ -100,6 +90,7 @@ module SHACL::Algebra
     # @param [Array<RDF::Term>] value_nodes
     # @return [Array<SHACL::ValidationResult>]
     def builtin_lessThan(property, node, path, value_nodes, **options)
+      property = property.first if property.is_a?(Array)
       terms = graph.query({subject: node, predicate: property}).objects
       compare(:<, terms, node, path, value_nodes,
               RDF::Vocab::SHACL.LessThanConstraintComponent, **options)
@@ -113,6 +104,7 @@ module SHACL::Algebra
     # @param [Array<RDF::Term>] value_nodes
     # @return [Array<SHACL::ValidationResult>]
     def builtin_lessThanOrEquals(property, node, path, value_nodes, **options)
+      property = property.first if property.is_a?(Array)
       terms = graph.query({subject: node, predicate: property}).objects
       compare(:<=, terms, node, path, value_nodes,
               RDF::Vocab::SHACL.LessThanOrEqualsConstraintComponent, **options)
@@ -130,6 +122,7 @@ module SHACL::Algebra
     # @param [Array<RDF::Term>] value_nodes
     # @return [Array<SHACL::ValidationResult>]
     def builtin_maxCount(count, node, path, value_nodes, **options)
+      count = count.first if count.is_a?(Array)
       satisfy(focus: node, path: path,
         message: "#{value_nodes.count} <= maxCount #{count}",
         resultSeverity: (options.fetch(:severity) unless value_nodes.count <= count.to_i),
@@ -152,6 +145,7 @@ module SHACL::Algebra
     # @param [Array<RDF::Term>] value_nodes
     # @return [Array<SHACL::ValidationResult>]
     def builtin_minCount(count, node, path, value_nodes, **options)
+      count = count.first if count.is_a?(Array)
       satisfy(focus: node, path: path,
         message: "#{value_nodes.count} >= minCount #{count}",
         resultSeverity: (options.fetch(:severity) unless value_nodes.count >= count.to_i),
@@ -167,6 +161,7 @@ module SHACL::Algebra
     # @param [Array<RDF::Term>] value_nodes
     # @return [Array<SHACL::ValidationResult>]
     def builtin_uniqueLang(uniq, node, path, value_nodes, **options)
+      uniq = uniq.first if uniq.is_a?(Array)
       if !value_nodes.all?(&:literal?)
         not_satisfied(focus: node, path: path,
           message: "not all values are literals",

data/lib/shacl/algebra/{qualified_value_shape.rb → qualified_value.rb}

@@ -1,35 +1,41 @@
 module SHACL::Algebra
   ##
-  class QualifiedValueShape < Operator
+  class QualifiedValueConstraintComponent < 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 [RDF::Term] node focus node
+    # @param [RDF::URI, SPARQL::Algebra::Expression] path the property path from the focus node to the value nodes.
     # @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
+      # Separate operands into operators and parameters
+      params, ops = operands.partition {|o| o.is_a?(Array) && o.first.is_a?(Symbol)}
+      params = params.inject({}) {|memo, a| memo.merge(a.first => a.last)}
+
+      max_count = params[:qualifiedMinCount]
+      min_count = params[:qualifiedMinCount]
       # FIXME: figure this out
-      disjoint = options[:qualifiedValueShapesDisjoint]
+      disjoint = !!params[:qualifiedValueShapesDisjoint]
 
-      operands.map do |op|
+      ops.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
+        if min_count && count < min_count.to_i
           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
+        elsif max_count && count > max_count.to_i
           not_satisfied(focus: node, path: path,
             message: "#{count} conforming values, requires at most #{max_count}",
             resultSeverity: options.fetch(:severity),
@@ -37,7 +43,7 @@ module SHACL::Algebra
             depth: depth, **options)
         else
           satisfy(focus: node, path: path,
-            message: "#{min_count} <= #{count} <= #{max_count} values conform",
+            message: "#{min_count.to_i} <= #{count} <= #{max_count || 'inf'} values conform",
             component: RDF::Vocab::SHACL.QualifiedMinCountConstraintComponent,
             depth: depth, **options)
         end

data/lib/shacl/algebra/shape.rb

@@ -81,6 +81,7 @@ module SHACL::Algebra
     # @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)
+      datatype = datatype.first if datatype.is_a?(Array)
       value_nodes.map do |n|
         has_datatype = n.literal? && n.datatype == datatype && n.valid?
         satisfy(focus: node, path: path,
@@ -140,6 +141,7 @@ module SHACL::Algebra
     # @param [Array<RDF::Term>] value_nodes
     # @return [Array<SHACL::ValidationResult>]
     def builtin_equals(property, node, path, value_nodes, **options)
+      property = property.first if property.is_a?(Array)
       equal_nodes = graph.query({subject: node, predicate: property}).objects
       (value_nodes.map do |n|
         has_value = equal_nodes.include?(n)
@@ -179,6 +181,7 @@ module SHACL::Algebra
     # @param [Array<RDF::Term>] value_nodes
     # @return [Array<SHACL::ValidationResult>]
     def builtin_hasValue(term, node, path, value_nodes, **options)
+      term = term.first if term.is_a?(Array)
       has_value = value_nodes.include?(term)
       [satisfy(focus: node, path: path,
         message: "is#{' not' unless has_value} the value #{term.to_sxp}",
@@ -260,7 +263,7 @@ module SHACL::Algebra
     # @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,
+      compare(:<, term, node, path, value_nodes,
               RDF::Vocab::SHACL.MaxExclusiveConstraintComponent, **options)
     end
 
@@ -282,7 +285,7 @@ module SHACL::Algebra
     # @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,
+      compare(:<=, term, node, path, value_nodes,
               RDF::Vocab::SHACL.MaxInclusiveConstraintComponent, **options)
     end
 
@@ -294,6 +297,7 @@ module SHACL::Algebra
     # @param [Array<RDF::Term>] value_nodes
     # @return [Array<SHACL::ValidationResult>]
     def builtin_maxLength(term, node, path, value_nodes, **options)
+      term = term.first if term.is_a?(Array)
       value_nodes.map do |n|
         compares = !n.node? && n.to_s.length <= term.to_i
         satisfy(focus: node, path: path,
@@ -323,7 +327,7 @@ module SHACL::Algebra
     # @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,
+      compare(:>, term, node, path, value_nodes,
               RDF::Vocab::SHACL.MinExclusiveConstraintComponent, **options)
     end
 
@@ -341,11 +345,11 @@ module SHACL::Algebra
     #
     # @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 [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_minInclusive(term, node, path, value_nodes, **options)
-      compare(:>=, [term], node, path, value_nodes,
+      compare(:>=, term, node, path, value_nodes,
               RDF::Vocab::SHACL.MinInclusiveConstraintComponent, **options)
     end
 
@@ -357,6 +361,7 @@ module SHACL::Algebra
     # @param [Array<RDF::Term>] value_nodes
     # @return [Array<SHACL::ValidationResult>]
     def builtin_minLength(term, node, path, value_nodes, **options)
+      term = term.first if term.is_a?(Array)
       value_nodes.map do |n|
         compares = !n.node? && n.to_s.length >= term.to_i
         satisfy(focus: node, path: path,
@@ -402,6 +407,7 @@ module SHACL::Algebra
     # @param [Array<RDF::Term>] value_nodes
     # @return [Array<SHACL::ValidationResult>]
     def builtin_nodeKind(term, node, path, value_nodes, **options)
+      term = term.first if term.is_a?(Array)
       value_nodes.map do |n|
         compares = NODE_KIND_COMPARE.fetch(n.class, []).include?(term)
         satisfy(focus: node, path: path,
@@ -413,46 +419,11 @@ module SHACL::Algebra
       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)
+      terms = [terms] unless terms.is_a?(Array)
       value_nodes.map do |left|
         results = terms.map do |right|
           case left

data/lib/shacl/algebra/sparql_constraint.rb

@@ -0,0 +1,160 @@
+require_relative "shape"
+require 'sparql'
+require 'rdf/aggregate_repo'
+
+module SHACL::Algebra
+  ##
+  class SPARQLConstraintComponent < ConstraintComponent
+    NAME = :sparql
+
+    # SPARQL Operators prohibited from being used in expression.
+    UNSUPPORTED_SPARQL_OPERATORS = [
+      SPARQL::Algebra::Operator::Minus,
+      SPARQL::Algebra::Operator::Service,
+      SPARQL::Algebra::Operator::Table,
+    ]
+
+    # Potentially pre-bound variables.
+    PRE_BOUND = %i(currentShape shapesGraph PATH this value)
+
+    # Validates the specified `property` within `graph`, a list of {ValidationResult}.
+    #
+    # A property conforms the nodes found by evaluating it's `path` all conform.
+    #
+    # Last operand is the parsed query. Bound variables are added as a table entry joined to the query.
+    #
+    # @param [RDF::Term] node focus node
+    # @param [RDF::URI, SPARQL::Algebra::Expression] path the property path from the focus node to the value nodes.
+    # @param [Hash{Symbol => Object}] options
+    # @return [Array<SHACL::ValidationResult>]
+    #   Returns a validation result for each value node.
+    def conforms(node, path: nil, depth: 0, **options)
+      return [] if deactivated?
+      options = {severity: RDF::Vocab::SHACL.Violation}.merge(options)
+      log_debug(NAME, depth: depth) {SXP::Generator.string({node: node}.to_sxp_bin)}
+
+      # Aggregate repo containing both data-graph (as the default) and shapes-graph, named by it's IRI
+      aggregate = RDF::AggregateRepo.new(graph.data, shapes_graph.data) do |ag|
+        ag.default false
+        ag.named shapes_graph.graph_name if shapes_graph.graph_name
+      end
+
+      aggregate.default_graph
+      bindings = RDF::Query::Solution.new({
+        currentShape: options[:shape],
+        shapesGraph: shapes_graph.graph_name,
+        PATH: path,
+        this: node,
+      }.compact)
+      solutions = operands.last.execute(aggregate,
+        bindings: bindings,
+        depth: depth + 1,
+        logger: (@logger || @options[:logger]),
+        **options)
+      if solutions.empty?
+        satisfy(focus: node, path: path,
+          message: @options.fetch(:message, "node conforms to SPARQL component"),
+          component: RDF::Vocab::SHACL.SPARQLConstraintComponent,
+          depth: depth, **options)
+      else
+        solutions.map do |solution|
+          not_satisfied(focus: node, path: (path || solution[:path]),
+            value: (solution[:value] || node),
+            message: @options.fetch(:message, "node does not coform to SPARQL component"),
+            resultSeverity: options.fetch(:severity),
+            component: RDF::Vocab::SHACL.SPARQLConstraintComponent,
+            depth: depth, **options)
+        end
+      end
+    end
+
+    # All keys associated with shapes which are set in options
+    #
+    # @return [Array<Symbol>]
+    BUILTIN_KEYS = %i(
+      type label name comment description deactivated severity
+      message path
+      ask select
+      declare namespace prefix prefixes select ask
+    ).freeze
+
+    # Class Methods
+    class << self
+      ##
+      # Creates an operator instance from a parsed SHACL representation.
+      #
+      # Special case for SPARQLComponenet due to general recursion.
+      #
+      # @param [Hash] operator
+      # @param [Hash] options ({})
+      # @option options [Hash{String => RDF::URI}] :prefixes
+      # @return [Operator]
+      def from_json(operator, **options)
+        prefixes, query = [], ""
+        operands = []
+        node_opts = options.dup
+        operator.each do |k, v|
+          next if v.nil?
+          case k
+          # List properties
+          when 'path'               then node_opts[:path] = parse_path(v, **options)
+          when 'prefixes'
+            prefixes = extract_prefixes(v)
+          when 'severity'           then node_opts[:severity] = iri(v, **options)
+          when 'type'               then node_opts[:type] = as_array(v).map {|vv| iri(vv, **options)} if v
+          else
+            node_opts[k.to_sym] = to_rdf(k.to_sym, v, **options) if BUILTIN_KEYS.include?(k.to_sym)
+          end
+        end
+
+        query_string = prefixes.join("\n") + node_opts[:select] || node_opts[:ask]
+        query = SPARQL.parse(query_string)
+
+        options[:logger].info("#{NAME} SXP: #{query.to_sxp}") if options[:logger]
+
+        # Queries have restrictions
+        operators = query.descendants.to_a.unshift(query)
+
+        if node_opts[:ask] && !operators.any? {|op| op.is_a?(SPARQL::Algebra::Operator::Ask)}
+          raise SHACL::Error, "Ask query must have ask operator"
+        elsif node_opts[:select] && !operators.any? {|op| op.is_a?(SPARQL::Algebra::Operator::Project)}
+          raise SHACL::Error, "Select query must have project operator"
+        end
+
+        uh_oh = (operators.map(&:class) & UNSUPPORTED_SPARQL_OPERATORS).map {|c| c.const_get(:NAME)}
+
+        unless uh_oh.empty?
+          raise SHACL::Error, "Query must not include operators #{uh_oh.to_sxp}: #{query_string}"
+        end
+
+        # Additionally, queries must not bind to special variables
+        operators.select {|op| op.is_a?(SPARQL::Algebra::Operator::Extend)}.each do |extend|
+          if extend.operands.first.any? {|v, e| PRE_BOUND.include?(v.to_sym)}
+            raise SHACL::Error, "Query must not bind pre-bound variables: #{query_string}"
+          end
+        end
+
+        operands << query
+        new(*operands, **node_opts)
+      end
+    end
+
+  private
+  
+    # Returns an array of prefix definitions
+    def self.extract_prefixes(value)
+      case value
+      when Hash
+        ret = []
+        # Recursively extract decllarations
+        extract_prefixes(value.fetch('imports', nil)) +
+        as_array(value.fetch('declare', [])).map do |decl|
+          pfx, ns = decl['prefix'], decl['namespace']
+          "PREFIX #{pfx}: <#{ns}>"
+        end
+      when Array then value.map {|v| extract_prefixes(v)}.flatten
+      else []
+      end
+    end
+  end
+end

data/lib/shacl/algebra/xone.rb

@@ -1,6 +1,6 @@
 module SHACL::Algebra
   ##
-  class Xone < Operator
+  class XoneConstraintComponent < ConstraintComponent
     NAME = :xone
 
     ##
@@ -29,7 +29,8 @@ module SHACL::Algebra
     #   		]
     #   	) .
     #
-    # @param [RDF::Term] node
+    # @param [RDF::Term] node focus node
+    # @param [RDF::URI, SPARQL::Algebra::Expression] path (nil) the property   
     # @param [Hash{Symbol => Object}] options
     # @return [Array<SHACL::ValidationResult>]
     def conforms(node, path: nil, depth: 0, **options)

data/lib/shacl/algebra.rb

@@ -1,29 +1,46 @@
 $:.unshift(File.expand_path("../..", __FILE__))
 require 'sxp'
 require_relative "algebra/operator"
+require_relative "algebra/constraint_component"
 
 module SHACL
   # Based on the SPARQL Algebra, operators for executing a patch
   module Algebra
-    autoload :And,                  'shacl/algebra/and.rb'
-    autoload :Datatype,             'shacl/algebra/datatype.rb'
-    autoload :Klass,                'shacl/algebra/klass.rb'
-    autoload :NodeShape,            'shacl/algebra/node_shape.rb'
-    autoload :Not,                  'shacl/algebra/not.rb'
-    autoload :Or,                   'shacl/algebra/or.rb'
-    autoload :PropertyShape,        'shacl/algebra/property_shape.rb'
-    autoload :QualifiedValueShape,  'shacl/algebra/qualified_value_shape.rb'
-    autoload :Shape,                'shacl/algebra/shape.rb'
-    autoload :Xone,                 'shacl/algebra/xone.rb'
+    autoload :AndConstraintComponent,               'shacl/algebra/and.rb'
+    autoload :NodeShape,                            'shacl/algebra/node_shape.rb'
+    autoload :NotConstraintComponent,               'shacl/algebra/not.rb'
+    autoload :OrConstraintComponent,                'shacl/algebra/or.rb'
+    autoload :PatternConstraintComponent,           'shacl/algebra/pattern.rb'
+    autoload :PropertyShape,                        'shacl/algebra/property_shape.rb'
+    autoload :QualifiedMaxCountConstraintComponent, 'shacl/algebra/qualified_value.rb'
+    autoload :QualifiedMinCountConstraintComponent, 'shacl/algebra/qualified_value.rb'
+    autoload :QualifiedValueConstraintComponent,    'shacl/algebra/qualified_value.rb'
+    autoload :Shape,                                'shacl/algebra/shape.rb'
+    autoload :SPARQLConstraintComponent,            'shacl/algebra/sparql_constraint.rb'
+    autoload :XoneConstraintComponent,              'shacl/algebra/xone.rb'
 
     def self.from_json(operator, **options)
-      raise ArgumentError, "from_json: operator not a Hash: #{operator.inspect}" unless operator.is_a?(Hash)
+      raise SHACL::Error, "from_json: operator not a Hash: #{operator.inspect}" unless operator.is_a?(Hash)
+
+      # If operator is a hash containing @list, it is a single array value.
+      # Note: context does not use @container: @list on this terms to preserve cardinality expectations
+      return operator['@list'].map {|e| from_json(e, **options)} if operator.key?('@list')
+
       type = operator.fetch('type', [])
-      type << (operator["path"] ? 'PropertyShape' : 'NodeShape') if type.empty?
+      if type.empty?
+        type << if operator["path"]
+          'PropertyShape'
+        elsif operator['nodeValidator'] || operator['propertyValidator'] || operator['validator']
+          'ConstraintComponent'
+        else
+          'NodeShape'
+        end
+      end
       klass = case
       when type.include?('NodeShape') then NodeShape
       when type.include?('PropertyShape') then PropertyShape
-      else raise ArgumentError, "from_json: unknown type #{type.inspect}"
+      when type.include?('ConstraintComponent') then ConstraintComponent
+      else raise SHACL::Error, "from_json: unknown type #{type.inspect}"
       end
 
       klass.from_json(operator, **options)

data/lib/shacl/context.rb

@@ -17,20 +17,25 @@ class JSON::LD::Context
       "equals" => TermDefinition.new("equals", id: "http://www.w3.org/ns/shacl#equals", type_mapping: "@id"),
       "id" => TermDefinition.new("id", id: "@id", simple: true),
       "ignoredProperties" => TermDefinition.new("ignoredProperties", id: "http://www.w3.org/ns/shacl#ignoredProperties", type_mapping: "@id", container_mapping: "@list"),
+      "imports" => TermDefinition.new("imports", id: "http://www.w3.org/2002/07/owl#imports", type_mapping: "@id"),
       "in" => TermDefinition.new("in", id: "http://www.w3.org/ns/shacl#in", type_mapping: "@none", container_mapping: "@list"),
       "inversePath" => TermDefinition.new("inversePath", id: "http://www.w3.org/ns/shacl#inversePath", type_mapping: "@id"),
       "label" => TermDefinition.new("label", id: "http://www.w3.org/2000/01/rdf-schema#label", simple: true),
       "languageIn" => TermDefinition.new("languageIn", id: "http://www.w3.org/ns/shacl#languageIn", container_mapping: "@list"),
       "lessThan" => TermDefinition.new("lessThan", id: "http://www.w3.org/ns/shacl#lessThan", type_mapping: "@id"),
       "lessThanOrEquals" => TermDefinition.new("lessThanOrEquals", id: "http://www.w3.org/ns/shacl#lessThanOrEquals", type_mapping: "@id"),
+      "namespace" => TermDefinition.new("namespace", id: "http://www.w3.org/ns/shacl#namespace", type_mapping: "http://www.w3.org/2001/XMLSchema#anyURI"),
       "nodeKind" => TermDefinition.new("nodeKind", id: "http://www.w3.org/ns/shacl#nodeKind", type_mapping: "@vocab"),
       "or" => TermDefinition.new("or", id: "http://www.w3.org/ns/shacl#or", type_mapping: "@id", container_mapping: "@list"),
+      "owl" => TermDefinition.new("owl", id: "http://www.w3.org/2002/07/owl#", simple: true, prefix: true),
       "path" => TermDefinition.new("path", id: "http://www.w3.org/ns/shacl#path", type_mapping: "@none"),
+      "prefixes" => TermDefinition.new("prefixes", id: "http://www.w3.org/ns/shacl#prefixes", type_mapping: "@id"),
       "property" => TermDefinition.new("property", id: "http://www.w3.org/ns/shacl#property", type_mapping: "@id"),
       "rdfs" => TermDefinition.new("rdfs", id: "http://www.w3.org/2000/01/rdf-schema#", simple: true, prefix: true),
       "severity" => TermDefinition.new("severity", id: "http://www.w3.org/ns/shacl#severity", type_mapping: "@vocab"),
       "sh" => TermDefinition.new("sh", id: "http://www.w3.org/ns/shacl#", simple: true, prefix: true),
       "shacl" => TermDefinition.new("shacl", id: "http://www.w3.org/ns/shacl#", simple: true, prefix: true),
+      "sparql" => TermDefinition.new("sparql", id: "http://www.w3.org/ns/shacl#sparql", type_mapping: "@id"),
       "targetClass" => TermDefinition.new("targetClass", id: "http://www.w3.org/ns/shacl#targetClass", type_mapping: "@id"),
       "targetNode" => TermDefinition.new("targetNode", id: "http://www.w3.org/ns/shacl#targetNode", type_mapping: "@none"),
       "type" => TermDefinition.new("type", id: "@type", container_mapping: "@set"),