shacl 0.1.1 → 0.3.0

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,37 @@
 $:.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?
       klass = case
       when type.include?('NodeShape') then NodeShape
       when type.include?('PropertyShape') then PropertyShape
-      else raise ArgumentError, "from_json: unknown type #{type.inspect}"
+      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"),

data/lib/shacl/shapes.rb

@@ -9,6 +9,12 @@ module SHACL
   class Shapes < Array
     include RDF::Util::Logger
 
+    # The original shapes graph
+    #
+    # @return [RDF::Graph]
+    attr_reader :shapes_graph
+
+
     # The graphs which have been loaded as shapes
     #
     # @return [Array<RDF::URI>]
@@ -28,6 +34,7 @@ module SHACL
     #
     # @param [RDF::Graph] graph
     # @param [Array<RDF::URI>] loaded_graphs = []
+    #   The graphs which have been loaded as shapes
     # @param [Hash{Symbol => Object}] options
     # @return [Shapes]
     # @raise [SHACL::Error]
@@ -38,8 +45,17 @@ module SHACL
       while (imports = graph.query({predicate: RDF::OWL.imports}).map(&:object)).count > import_count
         # Load each imported graph
         imports.each do |ref|
-          graph.load(imports)
-          loaded_graphs << ref
+          # Don't try import if the import subject is already in the graph
+          unless graph.subject?(ref)
+            begin
+              options[:logger].info('Shapes') {"load import #{ref}"} if options[:logger].respond_to?(:info)
+              graph.load(ref)
+              loaded_graphs << ref
+            rescue IOError => e
+              # Skip import
+              options[:logger].warn('Shapes') {"load import #{ref}"} if options[:logger].respond_to?(:warn)
+            end
+          end
           import_count += 1
         end
       end
@@ -52,6 +68,7 @@ module SHACL
       # Create an array of the framed shapes
       shapes = self.new(shape_json.map {|o| Algebra.from_json(o, **options)})
       shapes.instance_variable_set(:@shape_json, shape_json)
+      shapes.instance_variable_set(:@shapes_graph, graph)
       shapes
     end
 
@@ -65,11 +82,11 @@ module SHACL
     # @raise [SHACL::Error]
     def self.from_queryable(queryable, **options)
       # Query queryable to find one ore more shapes graphs
-      graphs = queryable.query({predicate: RDF::Vocab::SHACL.shapesGraph}).objects
-      graph = RDF::Graph.new do |g|
-        graphs.each {|iri| g.load(iri)}
+      graph_names = queryable.query({predicate: RDF::Vocab::SHACL.shapesGraph}).objects
+      graph = RDF::Graph.new(graph_name: graph_names.first, data: RDF::Repository.new) do |g|
+        graph_names.each {|iri| g.load(iri, graph_name: graph_names.first)}
       end
-      from_graph(graph, loaded_graphs: graphs, **options)
+      from_graph(graph, loaded_graphs: graph_names, **options)
     end
 
     ##
@@ -80,12 +97,18 @@ module SHACL
     # @param [Hash{Symbol => Object}] options
     # @option options [RDF::Term] :focus
     #   An explicit focus node, overriding any defined on the top-level shaps.
+    # @option options [Logger, #write, #<<] :logger
+    #   Record error/info/debug output
     # @return [SHACL::ValidationReport]
     def execute(graph, depth: 0, **options)
       self.each do |shape|
         shape.graph = graph
+        shape.shapes_graph = shapes_graph
         shape.each_descendant do |op|
-          op.graph = graph
+          op.instance_variable_set(:@logger, options[:logger]) if
+            options[:logger] && op.respond_to?(:execute)
+          op.graph = graph if op.respond_to?(:graph=)
+          op.shapes_graph = shapes_graph if op.respond_to?(:shapes_graph=)
         end
       end
 
@@ -102,8 +125,12 @@ module SHACL
       [:shapes, super]
     end
 
-    def to_sxp
-      to_sxp_bin.to_sxp
+    ##
+    # Transform Shapes into an SXP.
+    #
+    # @return [String]
+    def to_sxp(**options)
+      to_sxp_bin.to_sxp(**options)
     end
 
     SHAPES_FRAME = JSON.parse(%({
@@ -111,11 +138,12 @@ module SHACL
         "id": "@id",
         "type": {"@id": "@type", "@container": "@set"},
         "@vocab": "http://www.w3.org/ns/shacl#",
+        "owl": "http://www.w3.org/2002/07/owl#",
         "rdfs": "http://www.w3.org/2000/01/rdf-schema#",
         "shacl": "http://www.w3.org/ns/shacl#",
         "sh": "http://www.w3.org/ns/shacl#",
         "xsd": "http://www.w3.org/2001/XMLSchema#",
-        "and": {"@type": "@id", "@container": "@list"},
+        "and": {"@type": "@id"},
         "annotationProperty": {"@type": "@id"},
         "class": {"@type": "@id"},
         "comment": "http://www.w3.org/2000/01/rdf-schema#comment",
@@ -126,30 +154,35 @@ module SHACL
         "entailment": {"@type": "@id"},
         "equals": {"@type": "@id"},
         "ignoredProperties": {"@type": "@id", "@container": "@list"},
+        "imports": {"@id": "owl:imports", "@type": "@id"},
         "in": {"@type": "@none", "@container": "@list"},
         "inversePath": {"@type": "@id"},
         "label": "http://www.w3.org/2000/01/rdf-schema#label",
         "languageIn": {"@container": "@list"},
         "lessThan": {"@type": "@id"},
         "lessThanOrEquals": {"@type": "@id"},
+        "namespace": {"@type": "xsd:anyURI"},
         "nodeKind": {"@type": "@vocab"},
-        "or": {"@type": "@id", "@container": "@list"},
+        "or": {"@type": "@id"},
         "path": {"@type": "@none"},
+        "prefixes": {"@type": "@id"},
         "property": {"@type": "@id"},
         "severity": {"@type": "@vocab"},
+        "sparql": {"@type": "@id"},
         "targetClass": {"@type": "@id"},
         "targetNode": {"@type": "@none"},
-        "xone": {"@type": "@id", "@container": "@list"}
+        "xone": {"@type": "@id"}
       },
       "and": {},
       "class": {},
       "datatype": {},
-      "in": {},
+      "in": {"@embed": "@never"},
       "node": {},
       "nodeKind": {},
       "not": {},
       "or": {},
       "property": {},
+      "sparql": {},
       "targetClass": {},
       "targetNode": {},
       "targetObjectsOf": {},

data/lib/shacl/validation_report.rb

@@ -59,8 +59,12 @@ module SHACL
       [:ValidationReport, conform?, results].to_sxp_bin
     end
 
-    def to_sxp
-      self.to_sxp_bin.to_sxp
+    ##
+    # Transform Report to SXP
+    #
+    # @return [String]
+    def to_sxp(**options)
+      self.to_sxp_bin.to_sxp(**options)
     end
 
     def to_s

data/lib/shacl/validation_result.rb

@@ -50,8 +50,12 @@ module SHACL
       end.to_sxp_bin
     end
 
-    def to_sxp
-      self.to_sxp_bin.to_sxp
+    ##
+    # Transform ValidationResult to SXP
+    #
+    # @return [String]
+    def to_sxp(**options)
+      self.to_sxp_bin.to_sxp(**options)
     end
 
     ##
@@ -111,26 +115,29 @@ module SHACL
       block.call(RDF::Statement(subject, RDF::Vocab::SHACL.resultMessage, RDF::Literal(message))) if message
     end
 
-    # Transform a JSON representation of a result, into a native representation
-    # @param [Hash] input
-    # @return [ValidationResult]
-    def self.from_json(input, **options)
-      input = JSON.parse(input) if input.is_a?(String)
-      input = JSON::LD::API.compact(input,
-                "http://github.com/ruby-rdf/shacl/",
-                expandContext: "http://github.com/ruby-rdf/shacl/")
-      raise ArgumentError, "Expect report to be a hash" unless input.is_a?(Hash)
-      result = self.new
+    # Class Methods
+    class << self
+      # Transform a JSON representation of a result, into a native representation
+      # @param [Hash] input
+      # @return [ValidationResult]
+      def from_json(input, **options)
+        input = JSON.parse(input) if input.is_a?(String)
+        input = JSON::LD::API.compact(input,
+                  "http://github.com/ruby-rdf/shacl/",
+                  expandContext: "http://github.com/ruby-rdf/shacl/")
+        raise ArgumentError, "Expect report to be a hash" unless input.is_a?(Hash)
+        result = self.new
 
-      result.focus = Algebra::Operator.to_rdf(:focus, input['focusNode'], base: nil, vocab: false) if input['focusNode']
-      result.path = Algebra::Operator.parse_path(input['resultPath'], **options) if input['resultPath']
-      result.resultSeverity = Algebra::Operator.iri(input['resultSeverity'], **options) if input['resultSeverity']
-      result.component = Algebra::Operator.iri(input['sourceConstraintComponent'], **options) if input['sourceConstraintComponent']
-      result.shape = Algebra::Operator.iri(input['sourceShape'], **options) if input['sourceShape']
-      result.value = Algebra::Operator.to_rdf(:value, input['value'], **options) if input['value']
-      result.details = Algebra::Operator.to_rdf(:details, input['details'], **options) if input['details']
-      result.message = Algebra::Operator.to_rdf(:message, input['message'], **options) if input['message']
-      result
+        result.focus = Algebra::Operator.to_rdf(:focus, input['focusNode'], base: nil, vocab: false) if input['focusNode']
+        result.path = Algebra::Operator.parse_path(input['resultPath'], **options) if input['resultPath']
+        result.resultSeverity = Algebra::Operator.iri(input['resultSeverity'], **options) if input['resultSeverity']
+        result.component = Algebra::Operator.iri(input['sourceConstraintComponent'], **options) if input['sourceConstraintComponent']
+        result.shape = Algebra::Operator.iri(input['sourceShape'], **options) if input['sourceShape']
+        result.value = Algebra::Operator.to_rdf(:value, input['value'], **options) if input['value']
+        result.details = Algebra::Operator.to_rdf(:details, input['details'], **options) if input['details']
+        result.message = Algebra::Operator.to_rdf(:message, input['message'], **options) if input['message']
+        result
+      end
     end
 
     # To results are eql? if their overlapping properties are equal

data/lib/shacl.rb

@@ -21,8 +21,8 @@ module SHACL
   # @option (see Shapes#from_graph)
   # @return (see Shapes#from_graph)
   # @raise  (see Shapes#from_graph)
-  def self.get_shapes(shape_graph, **options)
-    Shapes.from_graph(shape_graph, **options)
+  def self.get_shapes(shapes_graph, **options)
+    Shapes.from_graph(shapes_graph, **options)
   end
 
   ##
@@ -33,8 +33,13 @@ module SHACL
   # @return (see Shapes#from_graph)
   # @raise  (see Shapes#from_graph)
   def self.open(input, **options)
-    graph = RDF::Graph.load(input, **options)
-    self.get_shapes(graph, loaded_graphs: [RDF::URI(input, canonicalize: true)], **options)
+    # Create graph backed by repo to allow a graph_name
+    graph = RDF::Graph.load(input,
+                            graph_name: RDF::URI(input),
+                            data: RDF::Repository.new)
+    self.get_shapes(graph,
+      loaded_graphs: [RDF::URI(input, canonicalize: true)],
+      **options)
   end
 
   ##
@@ -77,7 +82,7 @@ module SHACL
     attr_reader :code
 
     ##
-    # Initializes a new patch error instance.
+    # Initializes a new error instance.
     #
     # @param  [String, #to_s]          message
     # @param  [Hash{Symbol => Object}] options