shacl 0.2.1 → 0.4.0

data/lib/shacl/algebra/and.rb

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

data/lib/shacl/algebra/constraint_component.rb

@@ -0,0 +1,67 @@
+require_relative "operator"
+
+module SHACL::Algebra
+  ##
+  # Constraint Components define basic constraint behaivor through _mandatory_ and _optional_ parameters. Constraints are accessed through their parameters.
+  #
+  class ConstraintComponent < Operator
+
+    # Class Methods
+    class << self
+      ##
+      # Creates an operator instance from a parsed SHACL representation.
+      #
+      # Special case for SPARQL ConstraintComponents.
+      #
+      # @param [Hash] operator
+      # @param [Hash] options ({})
+      # @option options [Hash{String => RDF::URI}] :prefixes
+      # @return [Operator]
+      def from_json(operator, **options)
+        operands = []
+
+        # Component is known by its subject IRI
+        id = operator.fetch('id')
+
+        # Component class (for instantiation) is based on the _local name_ of the component IRI
+        class_name = ncname(id)
+
+        parameters = operator.fetch('parameter', []).inject({}) do |memo, param|
+          # Symbolize keys
+          param = param.inject({}) {|memo, (k,v)| memo.merge(k.to_sym => v)}
+
+          plc = ncname(param[:path])
+
+          # Add class and local name
+          param = param.merge(class: class_name, local_name: plc)
+          memo.merge(param[:path] => param)
+        end
+
+        # Add parameters to operator lookup
+        add_component(class_name, parameters)
+
+        # Add parameter identifiers to operands
+        operands << [:parameters, parameters.keys]
+
+        # FIXME: labelTemplate
+
+        validator = %w(validator nodeValidator propertyValidator).inject(nil) do |memo, p|
+          memo || (SPARQLConstraintComponent.from_json(operator[p]) if operator.key?(p))
+        end
+        raise SHACL::Error, "Constraint Component has no validator" unless validator
+
+        operands << [:validator, validator]
+
+        new(*operands, **options)
+      end
+
+      # Extract the NCName tail of an IRI as a symbol.
+      #
+      # @param [RDF::URI] uri
+      # @return [Symbol]
+      def ncname(uri)
+        uri.to_s.match(/(\w+)$/).to_s.to_sym
+      end
+    end
+  end
+end

data/lib/shacl/algebra/node_shape.rb

@@ -9,30 +9,22 @@ module SHACL::Algebra
     #
     # A node conforms if it is not deactivated and all of its operands conform.
     #
-    # @param [RDF::Term] node
+    # @param [RDF::Term] node focus node
     # @param [Hash{Symbol => Object}] options
     # @return [Array<SHACL::ValidationResult>]
     #   Returns one or more validation results for each operand.
     def conforms(node, depth: 0, **options)
       return [] if deactivated?
       options = id ? options.merge(shape: id) : options
-      options = options.merge(severity: RDF::Vocab::SHACL.Violation)
+      options[:severity] = @options[:severity] if @options[:severity]
+      options[:severity] ||= RDF::Vocab::SHACL.Violation
       log_debug(NAME, depth: depth) {SXP::Generator.string({id: id, node: node}.to_sxp_bin)}
 
-      # 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
-
       # Evaluate against builtins
       builtin_results = @options.map do |k, v|
-        self.send("builtin_#{k}".to_sym, v, node, nil, [node], depth: depth + 1, **options) if self.respond_to?("builtin_#{k}".to_sym)
+        self.send("builtin_#{k}".to_sym, v, node, nil, [node],
+                  depth: depth + 1,
+                  **options) if self.respond_to?("builtin_#{k}".to_sym)
       end.flatten.compact
 
       # Handle closed shapes
@@ -49,10 +41,12 @@ module SHACL::Algebra
             value: statement.object,
             path: statement.predicate,
             message: "closed node has extra property",
-            resultSeverity: options.fetch(:severity),
+            resultSeverity: options[:severity],
             component: RDF::Vocab::SHACL.ClosedConstraintComponent,
             **options)
         end.compact
+      elsif @options[:ignoredProperties]
+        raise SHACL::Error, "shape has ignoredProperties without being closed"
       end
 
       # Evaluate against operands
@@ -66,7 +60,7 @@ module SHACL::Algebra
           not_satisfied(focus: node,
             value: node,
             message: "node does not conform to #{op.id}",
-            resultSeverity: options.fetch(:severity),
+            resultSeverity: options[:severity],
             component: RDF::Vocab::SHACL.NodeConstraintComponent,
             **options)
         else

data/lib/shacl/algebra/not.rb

@@ -1,12 +1,13 @@
 module SHACL::Algebra
   ##
-  class Not < Operator
+  class NotConstraintComponent < ConstraintComponent
     NAME = :not
 
     ##
     # Specifies the condition that each value node cannot conform to a given shape. This is comparable to negation and the logical "not" operator.
     #
-    # @param [RDF::Term] node
+    # @param [RDF::Term] node focus node
+    # @param [RDF::URI, SPARQL::Algebra::Expression] path (nil) the property path from the focus node to the value nodes.
     # @param [Hash{Symbol => Object}] options
     # @return [Array<SHACL::ValidationResult>]
     def conforms(node, path: nil, depth: 0, **options)

data/lib/shacl/algebra/operator.rb

@@ -15,28 +15,204 @@ module SHACL::Algebra
     # All keys associated with shapes which are set in options
     #
     # @return [Array<Symbol>]
-    ALL_KEYS = %i(
+    BUILTIN_KEYS = %i(
       id type label name comment description deactivated severity
+      message
       order group defaultValue path
       targetNode targetClass targetSubjectsOf targetObjectsOf
       class datatype nodeKind
       minCount maxCount
       minExclusive minInclusive maxExclusive maxInclusive
       minLength maxLength
-      pattern flags languageIn uniqueLang
-      qualifiedValueShapesDisjoint qualifiedMinCount qualifiedMaxCount
+      languageIn uniqueLang
       equals disjoint lessThan lessThanOrEquals
       closed ignoredProperties hasValue in
+      declare namespace prefix
     ).freeze
 
     # Initialization options
     attr_accessor :options
 
-    # Graph against which shapes are validaed
+    # Graph against which shapes are validated.
+    # @return [RDF::Queryable]
     attr_accessor :graph
 
+    # Graph from which original shapes were loaded.
+    # @return [RDF::Graph]
+    attr_accessor :shapes_graph
+
+    # Parameters to components.
+    PARAMETERS = {
+      and: {class: :AndConstraintComponent},
+      class: {
+        class: :ClassConstraintComponent,
+        nodeKind: :IRI,
+      },
+      closed: {
+        class: :ClosedConstraintComponent,
+        datatype: RDF::XSD.boolean,
+      },
+      datatype: {
+        class: :DatatypeConstraintComponent,
+        nodeKind: :IRI,
+        maxCount: 1,
+      },
+      disjoint: {
+        class: :DisjointConstraintComponent,
+        nodeKind: :IRI,
+      },
+      equals: {
+        class: :EqualsConstraintComponent,
+        nodeKind: :IRI,
+      },
+      expression: {class: :ExpressionConstraintComponent},
+      flags: {
+        class: :PatternConstraintComponent,
+        datatype: RDF::XSD.string,
+        optional: true
+      },
+      hasValue: {
+        class: :HasValueConstraintComponent,
+        nodeKind: :IRIOrLiteral,
+      },
+      ignoredProperties: {
+        class: :ClosedConstraintComponent,
+        nodeKind: :IRI, # Added
+        optional: true,
+      },
+      in: {
+        class: :InConstraintComponent,
+        nodeKind: :IRIOrLiteral,
+        #maxCount: 1, # List internalized
+      },
+      languageIn: {
+        class: :LanguageInConstraintComponent,
+        datatype: RDF::XSD.string,  # Added
+        #maxCount: 1, # List internalized
+      },
+      lessThan: {
+        class: :LessThanConstraintComponent,
+        nodeKind: :IRI,
+      },
+      lessThanOrEquals: {
+        class: :LessThanOrEqualsConstraintComponent,
+        nodeKind: :IRI,
+      },
+      maxCount: {
+        class: :MaxCountConstraintComponent,
+        datatype: RDF::XSD.integer,
+        maxCount: 1,
+      },
+      maxExclusive: {
+        class: :MaxExclusiveConstraintComponent,
+        maxCount: 1,
+        nodeKind: :Literal,
+      },
+      maxInclusive: {
+        class: :MaxInclusiveConstraintComponent,
+        maxCount: 1,
+        nodeKind: :Literal,
+      },
+      maxLength: {
+        class: :MaxLengthConstraintComponent,
+        datatype: RDF::XSD.integer,
+        maxCount: 1,
+      },
+      minCount: {
+        class: :MinCountConstraintComponent,
+        datatype: RDF::XSD.integer,
+        maxCount: 1,
+      },
+      minExclusive: {
+        class: :MinExclusiveConstraintComponent,
+        maxCount: 1,
+        nodeKind: :Literal,
+      },
+      minInclusive: {
+        class: :MinInclusiveConstraintComponent,
+        maxCount: 1,
+        nodeKind: :Literal,
+      },
+      minLength: {
+        class: :MinLengthConstraintComponent,
+        datatype: RDF::XSD.integer,
+        maxCount: 1,
+      },
+      node: {class: :NodeConstraintComponent},
+      nodeKind: {
+        class: :NodeKindConstraintComponent,
+        in: %i(BlankNode IRI Literal BlankNodeOrIRI BlankNodeOrLiteral IRIOrLiteral),
+        maxCount: 1,
+      },
+      not: {class: :NotConstraintComponent},
+      or: {class: :OrConstraintComponent},
+      pattern: {
+        class: :PatternConstraintComponent,
+        datatype: RDF::XSD.string,
+      },
+      property: {class: :PropertyConstraintComponent},
+      qualifiedMaxCount: {
+        class: :QualifiedValueConstraintComponent,
+        datatype: RDF::XSD.integer,
+      },
+      qualifiedValueShape: {
+        class: :QualifiedValueConstraintComponent,
+      },
+      qualifiedValueShapesDisjoint: {
+        class: :QualifiedValueConstraintComponent,
+        datatype: RDF::XSD.boolean,
+        optional: true,
+      },
+      qualifiedMinCount: {
+        class: :QualifiedValueConstraintComponent,
+        datatype: RDF::XSD.integer
+      },
+      sparql: {class: :SPARQLConstraintComponent},
+      uniqueLang: {
+        class: :UniqueLangConstraintComponent,
+        datatype: RDF::XSD.boolean,
+        maxCount: 1,
+      },
+      xone: {class: :XoneConstraintComponent},
+    }
+
     ## Class methods
     class << self
+      # Add parameters and class def from a SPARQL-based Constraint Component
+      #
+      # @param [RDF::URI] cls The URI of the constraint component.
+      # @param [Hash{Symbol => Hash}] parameters Definitions of mandatory and optional parameters for this component.
+      def add_component(cls, parameters)
+        # Remember added paraemters.
+        # FIXME: should merge parameters
+        @added_parameters = (@added_parameters || {}).merge(parameters)
+        # Rebuild
+        @params = @component_params = nil
+      end
+
+      # Defined parameters for components, which may be supplemented by SPARQL-based Constraint Components. A parameter may be mapped to more than one component class.
+      #
+      # @return [Hash{Symbol => Hash}] Returns each parameter referencing the component classes it is used in, and the property validators for values of that parameter.
+      def params
+        @params ||= PARAMETERS.merge(@added_parameters || {})
+      end
+
+      # Constraint Component classes indexed to their mandatory and optional parameters, which may be supplemented by SPARQL-based Constraint Components.
+      #
+      # @return [Hash{Symbol => Hash}]
+      #   Returns a hash relating each component URI to its optional and mandatory parameters.
+      def component_params
+        @component_params ||= params.inject({}) do |memo, (param, properties)|
+          memo.merge(Array(properties[:class]).inject(memo) do |mem, cls|
+            entry = mem.fetch(cls, {})
+            param_type = properties[:optional] ? :optional : :mandatory
+            entry[param_type] ||= []
+            entry[param_type] << param
+            mem.merge(cls => entry)
+          end)
+        end
+      end
+
       ##
       # Creates an operator instance from a parsed SHACL representation
       # @param [Hash] operator
@@ -45,52 +221,143 @@ module SHACL::Algebra
       # @return [Operator]
       def from_json(operator, **options)
         operands = []
+
+        # Node options used to instantiate the relevant class instance.
         node_opts = options.dup
+
+        # Node Options and operands on shape or node, which are not Constraint Component Parameters
         operator.each do |k, v|
-          next if v.nil?
+          k = k.to_sym
+          next if v.nil? || params.include?(k)
           case k
           # List properties
-          when 'and'
-            elements = as_array(v).map {|vv| SHACL::Algebra.from_json(vv, **options)}
-            operands << And.new(*elements, **options.dup)
-          when 'class'              then node_opts[:class] = as_array(v).map {|vv| iri(vv, **options)} if v
-          when 'datatype'           then node_opts[:datatype] = iri(v, **options)
-          when 'disjoint'           then node_opts[:disjoint] = as_array(v).map {|vv| iri(vv, **options)} if v
-          when 'equals'             then node_opts[:equals] = iri(v, **options)
-          when 'id'                 then node_opts[:id] = iri(v, vocab: false, **options)
-          when 'ignoredProperties'  then node_opts[:ignoredProperties] = as_array(v).map {|vv| iri(vv, **options)} if v
-          when 'lessThan'           then node_opts[:lessThan] = iri(v, **options)
-          when 'lessThanOrEquals'   then node_opts[:lessThanOrEquals] = iri(v, **options)
-          when 'node'
-            operands.push(*as_array(v).map {|vv| NodeShape.from_json(vv, **options)})
-          when 'nodeKind'           then node_opts[:nodeKind] = iri(v, **options)
-          when 'not'
-            elements = as_array(v).map {|vv| SHACL::Algebra.from_json(vv, **options)}
-            operands << Not.new(*elements, **options.dup)
-          when 'or'
-            elements = as_array(v).map {|vv| SHACL::Algebra.from_json(vv, **options)}
-            operands << Or.new(*elements, **options.dup)
-          when 'path'               then node_opts[:path] = parse_path(v, **options)
-          when 'property'
+          when :id                 then node_opts[:id] = iri(v, vocab: false, **options)
+          when :path               then node_opts[:path] = parse_path(v, **options)
+          when :property
             operands.push(*as_array(v).map {|vv| PropertyShape.from_json(vv, **options)})
-          when 'qualifiedValueShape'
-            elements = as_array(v).map {|vv| SHACL::Algebra.from_json(vv, **options)}
-            operands << QualifiedValueShape.new(*elements, **options.dup)
-          when 'severity'           then node_opts[:severity] = iri(v, **options)
-          when 'targetClass'        then node_opts[:targetClass] = as_array(v).map {|vv| iri(vv, **options)} if v
-          when 'targetNode'
+          when :severity           then node_opts[:severity] = iri(v, **options)
+          when :targetClass        then node_opts[:targetClass] = as_array(v).map {|vv| iri(vv, **options)}
+          when :targetNode
             node_opts[:targetNode] = as_array(v).map do |vv|
               from_expanded_value(vv, **options)
-            end if v
-          when 'targetObjectsOf'    then node_opts[:targetObjectsOf] = as_array(v).map {|vv| iri(vv, **options)} if v
-          when 'targetSubjectsOf'   then node_opts[:targetSubjectsOf] = as_array(v).map {|vv| iri(vv, **options)} if v
-          when 'type'               then node_opts[:type] = as_array(v).map {|vv| iri(vv, **options)} if v
-          when 'xone'
-            elements = as_array(v).map {|vv| SHACL::Algebra.from_json(vv, **options)}
-            operands << Xone.new(*elements, **options.dup)
+            end
+          when :targetObjectsOf    then node_opts[:targetObjectsOf] = as_array(v).map {|vv| iri(vv, **options)}
+          when :targetSubjectsOf   then node_opts[:targetSubjectsOf] = as_array(v).map {|vv| iri(vv, **options)}
+          when :type               then node_opts[:type] = as_array(v).map {|vv| iri(vv, **options)}
           else
-            # Add as a plain option if it is recognized
-            node_opts[k.to_sym] = to_rdf(k.to_sym, v, **options) if ALL_KEYS.include?(k.to_sym)
+            if BUILTIN_KEYS.include?(k)
+              # Add as a plain option otherwise
+              node_opts[k] = to_rdf(k, v, **options)
+            end
+          end
+        end
+
+        # Node Options and operands on shape or node, which are Constraint Component Parameters.
+        # For constraints with a defined Ruby class, the primary parameter is the NAME from the constraint class. Other parameters are added as named operands to the component operator.
+        used_components = {}
+        operator.each do |k, v|
+          k = k.to_sym
+          next if v.nil? || !params.include?(k)
+          param_props = params[k]
+          param_classes = Array(param_props[:class])
+
+          # Keep track of components which have been used.
+          param_classes.each {|cls| used_components[cls] ||= {}}
+
+          # Check parameter constraints
+          v = as_array(v)
+          if param_props[:maxCount] && v.length > param_props[:maxCount]
+            raise SHACL::Error, "Property #{k} on #{self.const_get(:NAME)} has too many values: #{v.inspect}"
+          end
+
+          # If an optional parameter exists without corresponding mandatory parameters on a given shape, raise a SHACL::Error.
+          #
+          # Records any instances of components which are created to re-attach non-primary parameters after all operators are processed.
+          instances = case k
+          # List properties
+          when :node
+            as_array(v).map {|vv| NodeShape.from_json(vv, **options)}
+          when :property
+            as_array(v).map {|vv| PropertyShape.from_json(vv, **options)}
+          when :sparql
+            as_array(v).map {|vv| SPARQLConstraintComponent.from_json(vv, **options)}
+          else
+            # Process parameter values based on nodeKind, in, and datatype.
+            elements = if param_props[:nodeKind]
+              case param_props[:nodeKind]
+              when :IRI
+                v.map {|vv| iri(vv, **options)}
+              when :Literal
+                v.map do |vv|
+                  vv.is_a?(Hash) ?
+                    from_expanded_value(vv, **options) :
+                    RDF::Literal(vv)
+                end
+              when :IRIOrLiteral
+                to_rdf(k, v, **options)
+              end
+            elsif param_props[:in]
+              v.map do |vv|
+                iri(vv, **options) if param_props[:in].include?(vv.to_sym)
+              end
+            elsif param_props[:datatype]
+              v.map {|vv| RDF::Literal(vv, datatype: param_props[:datatype])}
+            else
+              v.map {|vv| SHACL::Algebra.from_json(vv, **options)}
+            end
+
+            # Builtins are added as options to the operator, otherwise, they are class instances of constraint components added as operators.
+            if BUILTIN_KEYS.include?(k)
+              node_opts[k] = elements
+              [] # No instances created
+            else
+              klass = SHACL::Algebra.const_get(Array(param_props[:class]).first)
+
+              name = klass.const_get(:NAME)
+              # If the key `k` is the same as the NAME of the class, create the instance with the defined element values.
+              if name == k
+                param_classes.each do |cls|
+                  # Add `k` as a mandatory parameter fulfilled
+                  (used_components[cls][:mandatory_parameters] ||= []) << k
+                end
+
+                # Instantiate the compoent
+                elements.map {|e| klass.new(*e, **options.dup)}
+              else
+                # Add non-primary parameters for subsequent insertion
+                param_classes.each do |cls|
+                  # Add `k` as a mandatory parameter fulfilled if it is so defined
+                  (used_components[cls][:mandatory_parameters] ||= []) << k unless
+                    params[k][:optional]
+
+                  # Add parameter as S-Expression operand
+                  (used_components[cls][:parameters] ||= []) << elements.unshift(k)
+                end
+                [] # No instances created
+              end
+            end
+          end
+
+          # Record the instances created by class and its operands
+          param_classes.each do |cls|
+            used_components[cls][:instances] = instances
+          end
+
+          # FIXME: Only add instances when all mandatory parameters are present.
+          operands.push(*instances)
+        end
+
+        # Append any parameters to the used components
+        used_components.each do |cls, props|
+          instances = props[:instances]
+          next unless instances # BUILTINs
+
+          parameters = props.fetch(:parameters, [])
+          instances.each do |op|
+            parameters.each do |param|
+              # Note the potential that the parameter gets added twice, if there are multiple classes for both the primary and secondary paramters.
+              op.operands << param
+            end
           end
         end
 
@@ -189,7 +456,7 @@ module SHACL::Algebra
       end
 
       ##
-      # Parse the "patH" attribute into a SPARQL Property Path and evaluate to find related nodes.
+      # Parse the "path" attribute into a SPARQL Property Path and evaluate to find related nodes.
       #
       # @param [Object] path
       # @return [RDF::URI, SPARQL::Algebra::Expression]
@@ -282,8 +549,9 @@ module SHACL::Algebra
       raise NotImplemented
     end
 
+    # Create structure for serializing this component/shape, beginning with its cononical name.
     def to_sxp_bin
-      expressions = ALL_KEYS.inject([self.class.const_get(:NAME)]) do |memo, sym|
+      expressions = BUILTIN_KEYS.inject([self.class.const_get(:NAME)]) do |memo, sym|
         @options[sym] ? memo.push([sym, *@options[sym]]) : memo
       end + operands
 

data/lib/shacl/algebra/or.rb

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

data/lib/shacl/algebra/pattern.rb

@@ -0,0 +1,43 @@
+module SHACL::Algebra
+  ##
+  class PatternConstraintComponent < ConstraintComponent
+    NAME = :pattern
+
+    ##
+    # 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::Term] node focus node
+    # @param [RDF::URI, SPARQL::Algebra::Expression] path (nil) the property path from the focus node to the value nodes.
+    # @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)}
+      pattern = Array(operands.first).first
+      flags = operands.last.last if operands.last.is_a?(Array) && operands.last.first == :flags
+      flags = 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)
+
+      compares = !node.node? && pat.match?(node.to_s)
+      satisfy(focus: node, path: path,
+        value: node,
+        message: "is#{' not' unless compares} a match #{pat.inspect}",
+        resultSeverity: (options.fetch(:severity) unless compares),
+        component: RDF::Vocab::SHACL.PatternConstraintComponent,
+        **options)
+    end
+  end
+end