shacl 0.1.0

data/lib/shacl/algebra/xone.rb

@@ -0,0 +1,65 @@
+module SHACL::Algebra
+  ##
+  class Xone < Operator
+    NAME = :xone
+
+    ##
+    # Specifies the condition that each value node conforms to exactly one of the provided shapes.
+    #
+    # @example
+    #   ex:XoneConstraintExampleShape
+    #   	a sh:NodeShape ;
+    #   	sh:targetClass ex:Person ;
+    #   	sh:xone (
+    #   		[
+    #   			sh:property [
+    #   				sh:path ex:fullName ;
+    #   				sh:minCount 1 ;
+    #   			]
+    #   		]
+    #   		[
+    #   			sh:property [
+    #   				sh:path ex:firstName ;
+    #   				sh:minCount 1 ;
+    #   			] ;
+    #   			sh:property [
+    #   				sh:path ex:lastName ;
+    #   				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)}
+      num_conform = operands.inject(0) do |memo, op|
+        results = op.conforms(node, depth: depth + 1, **options)
+        memo += (results.all?(&:conform?) ? 1 : 0)
+      end
+      case num_conform
+      when 0
+        not_satisfied(focus: node, path: path,
+          value: node,
+          message: "node does not conform to any shape",
+          resultSeverity: options.fetch(:severity),
+          component: RDF::Vocab::SHACL.XoneConstraintComponent,
+          depth: depth, **options)
+      when 1
+        satisfy(focus: node, path: path,
+          value: node,
+          message: "node conforms to a single shape",
+          component: RDF::Vocab::SHACL.XoneConstraintComponent,
+          depth: depth, **options)
+      else
+        not_satisfied(focus: node, path: path,
+          value: node,
+          message: "node conforms to #{num_conform} shapes",
+          resultSeverity: options.fetch(:severity),
+          component: RDF::Vocab::SHACL.XoneConstraintComponent,
+          depth: depth, **options)
+      end
+    end
+  end
+end

data/lib/shacl/context.rb

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
+# This file generated automatically from http://github.com/ruby-rdf/shacl/
+require 'json/ld'
+class JSON::LD::Context
+  add_preloaded("http://github.com/ruby-rdf/shacl/") do
+    new(vocab: "http://www.w3.org/ns/shacl#", processingMode: "json-ld-1.1", term_definitions: {
+      "and" => TermDefinition.new("and", id: "http://www.w3.org/ns/shacl#and", type_mapping: "@id", container_mapping: "@list"),
+      "annotationProperty" => TermDefinition.new("annotationProperty", id: "http://www.w3.org/ns/shacl#annotationProperty", type_mapping: "@id"),
+      "class" => TermDefinition.new("class", id: "http://www.w3.org/ns/shacl#class", type_mapping: "@id"),
+      "comment" => TermDefinition.new("comment", id: "http://www.w3.org/2000/01/rdf-schema#comment", simple: true),
+      "condition" => TermDefinition.new("condition", id: "http://www.w3.org/ns/shacl#condition", type_mapping: "@id"),
+      "datatype" => TermDefinition.new("datatype", id: "http://www.w3.org/ns/shacl#datatype", type_mapping: "@vocab"),
+      "declare" => TermDefinition.new("declare", id: "http://www.w3.org/ns/shacl#declare", type_mapping: "@id"),
+      "disjoint" => TermDefinition.new("disjoint", id: "http://www.w3.org/ns/shacl#disjoint", type_mapping: "@id"),
+      "entailment" => TermDefinition.new("entailment", id: "http://www.w3.org/ns/shacl#entailment", type_mapping: "@id"),
+      "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"),
+      "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"),
+      "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"),
+      "path" => TermDefinition.new("path", id: "http://www.w3.org/ns/shacl#path", type_mapping: "@none"),
+      "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),
+      "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"),
+      "xone" => TermDefinition.new("xone", id: "http://www.w3.org/ns/shacl#xone", type_mapping: "@id", container_mapping: "@list"),
+      "xsd" => TermDefinition.new("xsd", id: "http://www.w3.org/2001/XMLSchema#", simple: true, prefix: true)
+    })
+  end
+end

data/lib/shacl/format.rb

@@ -0,0 +1,88 @@
+require 'rdf/format'
+
+module SHACL
+  ##
+  # SHACL format specification. Note that this format does not define any readers or writers.
+  #
+  # @example Obtaining an ShEx format class
+  #     RDF::Format.for(:shacl)           #=> ShEx::Format
+  class Format < RDF::Format
+    ##
+    # Hash of CLI commands appropriate for this format
+    # @return [Hash{Symbol => Lambda(Array, Hash)}]
+    def self.cli_commands
+      {
+        shacl: {
+          description: "Validate repository given shape",
+          help: %(shacl [--shape URI] [--focus Resource] [--replace]
+
+            Evaluates the repository according the the specified shapes.
+            If no shape file is specified, it will look for one or more
+            shapes graphs using the sh:shapesGraph property found within
+            the repository.
+            ).gsub(/^\s+/, ''),
+          parse: true,
+          lambda: -> (argv, **options) do
+            shacl = case options[:shape]
+            when IO, StringIO
+              SHACL.get_shapes(RDF::Reader.new(options[:shape]), **options)
+            when nil
+              SHACL.from_queryable(RDF::CLI.repository, **options)
+            else SHACL.open(options[:shape], **options)
+            end
+
+            if options[:to_sxp]
+              options[:messages][:shacl] = {}
+              options[:messages][:shacl].merge!({"S-Expression": [SXP::Generator.string(shacl.to_sxp_bin)]})
+            else
+              start = Time.now
+              report = shacl.execute(RDF::CLI.repository, **options)
+              secs = Time.new - start
+              options[:logger].info "SHACL resulted in #{report.conform? ? 'success' : 'failure'} including #{report.count} results."
+              options[:logger].info "Validated in #{secs} seconds."
+              options[:messages][:shacl] = {result: report.conform? ? "Satisfied shape" : "Did not satisfy shape"}
+              if report.conform?
+                options[:messages][:shacl] = {result: ["Satisfied shape"]}
+              else
+                RDF::CLI.repository << report
+                options[:messages][:shacl] = {result: ["Did not satisfy shape: #{report.count} results"]}
+                options[:messages].merge!(report.linter_messages)
+              end
+            end
+            RDF::CLI.repository
+          end,
+          options: [
+            RDF::CLI::Option.new(
+              symbol: :focus,
+              datatype: String,
+              control: :text,
+              on: ["--focus Resource"],
+              description: "Focus node within repository"
+            ) {|v| RDF::URI(v)},
+            RDF::CLI::Option.new(
+              symbol: :replace,
+              datatype: TrueClass,
+              control: :checkbox,
+              on: ["--replace"],
+              description: "Replaces the data graph with the validation report"
+            ) {|v| RDF::URI(v)},
+            RDF::CLI::Option.new(
+              symbol: :shape,
+              datatype: String,
+              control: :url2,
+              on: ["--shape URI"],
+              description: "SHACL shapes graph location"
+            ) {|v| RDF::URI(v)},
+            RDF::CLI::Option.new(
+              symbol: :to_sxp,
+              datatype: String,
+              control: :checkbox,
+              on: ["--to-sxp"],
+              description: "Display parsed shapes as an S-Expression"
+            ),
+          ]
+        }
+      }
+    end
+  end
+end

data/lib/shacl/refinements.rb

@@ -0,0 +1,198 @@
+# Localized refinements to externally defined classes
+module SHACL::Refinements
+  using SHACL::Refinements
+
+  refine Hash do
+    # @!parse
+    #   # Refinements on Hash
+    #   class Hash
+    #     ##
+    #     # Deep merge two hashes folding array values together.
+    #     #
+    #     # @param  [Hash] second
+    #     # @return [Hash]
+    #     def deep_merge(second); end
+    #   end
+    def deep_merge(second)
+      merger = ->(_, v1, v2) {Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : Array === v1 && Array === v2 ? v1 | v2 : v2.nil? ? v1 : v2 }
+      merge(second.to_h, &merger)
+    end
+  end
+
+  refine SPARQL::Algebra::Operator::Alt do
+    # @!parse
+    #   # Refinements on SPARQL::Algebra::Operator::Alt
+    #   class SPARQL::Algebra::Operator::Alt
+    #     ##
+    #     # Retrieve the possibly newly assigned blank node subject to use for representing this operator.
+    #     # @return [RDF::Node]
+    #     attr_accessor :subject
+    #
+    #     ##
+    #     # Generate the SHACL representation of this operator
+    #     # @return [RDF::Node]
+    #     def each_statement(&block); end.
+    #   end
+    attr_accessor :subject
+    def each_statement(&block)
+      @subject = RDF::Node.new
+      elements = operands.map do |op|
+        if op.respond_to?(:each_statement)
+          op.each_statement(&block)
+          op.subject
+        else
+          op
+        end
+      end
+      list = RDF::List(*elements)
+      list.each_statement(&block)
+      block.call(RDF::Statement(@subject, RDF::Vocab::SHACL.alternativePath, list.subject))
+    end
+  end
+
+  refine SPARQL::Algebra::Operator::PathOpt do
+    # @!parse
+    #   # Refinements on SPARQL::Algebra::Operator::PathOpt
+    #   class SPARQL::Algebra::Operator::Alt
+    #     ##
+    #     # Retrieve the possibly newly assigned blank node subject to use for representing this operator.
+    #     # @return [RDF::Node]
+    #     attr_accessor :subject
+    #
+    #     ##
+    #     # Generate the SHACL representation of this operator
+    #     # @return [RDF::Node]
+    #     def each_statement(&block); end.
+    #   end
+    attr_accessor :subject
+    def each_statement(&block)
+      @subject = RDF::Node.new
+      operands.each do |op|
+        obj = if op.respond_to?(:each_statement)
+          op.each_statement(&block)
+          op.subject
+        else
+          op
+        end
+        block.call(RDF::Statement(@subject, RDF::Vocab::SHACL.zeroOrOnePath, obj))
+      end
+    end
+  end
+
+  refine SPARQL::Algebra::Operator::PathPlus do
+    # @!parse
+    #   # Refinements on SPARQL::Algebra::Operator::PathPlus
+    #   class SPARQL::Algebra::Operator::Alt
+    #     ##
+    #     # Retrieve the possibly newly assigned blank node subject to use for representing this operator.
+    #     # @return [RDF::Node]
+    #     attr_accessor :subject
+    #
+    #     ##
+    #     # Generate the SHACL representation of this operator
+    #     # @return [RDF::Node]
+    #     def each_statement(&block); end.
+    #   end
+    attr_accessor :subject
+    def each_statement(&block)
+      @subject = RDF::Node.new
+      operands.each do |op|
+        obj = if op.respond_to?(:each_statement)
+          op.each_statement(&block)
+          op.subject
+        else
+          op
+        end
+        block.call(RDF::Statement(@subject, RDF::Vocab::SHACL.oneOrMorePath, obj))
+      end
+    end
+  end
+
+  refine SPARQL::Algebra::Operator::PathStar do
+    # @!parse
+    #   # Refinements on SPARQL::Algebra::Operator::PathPlus
+    #   class SPARQL::Algebra::Operator::Alt
+    #     ##
+    #     # Retrieve the possibly newly assigned blank node subject to use for representing this operator.
+    #     # @return [RDF::Node]
+    #     attr_accessor :subject
+    #
+    #     ##
+    #     # Generate the SHACL representation of this operator
+    #     # @return [RDF::Node]
+    #     def each_statement(&block); end.
+    #   end
+    attr_accessor :subject
+    def each_statement(&block)
+      @subject = RDF::Node.new
+      operands.each do |op|
+        obj = if op.respond_to?(:each_statement)
+          op.each_statement(&block)
+          op.subject
+        else
+          op
+        end
+        block.call(RDF::Statement(@subject, RDF::Vocab::SHACL.zeroOrMorePath, obj))
+      end
+    end
+  end
+
+  refine SPARQL::Algebra::Operator::Reverse do
+    # @!parse
+    #   # Refinements on SPARQL::Algebra::Operator::Reverse
+    #   class SPARQL::Algebra::Operator::Alt
+    #     ##
+    #     # Retrieve the possibly newly assigned blank node subject to use for representing this operator.
+    #     # @return [RDF::Node]
+    #     attr_accessor :subject
+    #
+    #     ##
+    #     # Generate the SHACL representation of this operator
+    #     # @return [RDF::Node]
+    #     def each_statement(&block); end.
+    #   end
+    attr_accessor :subject
+    def each_statement(&block)
+      @subject = RDF::Node.new
+      operands.each do |op|
+        obj = if op.respond_to?(:each_statement)
+          op.each_statement(&block)
+          op.subject
+        else
+          op
+        end
+        block.call(RDF::Statement(@subject, RDF::Vocab::SHACL.inversePath, obj))
+      end
+    end
+  end
+
+  refine SPARQL::Algebra::Operator::Seq do
+    # @!parse
+    #   # Refinements on SPARQL::Algebra::Operator::Seq
+    #   class SPARQL::Algebra::Operator::Alt
+    #     ##
+    #     # Retrieve the possibly newly assigned blank node subject to use for representing this operator.
+    #     # @return [RDF::Node]
+    #     attr_accessor :subject
+    #
+    #     ##
+    #     # Generate the SHACL representation of this operator
+    #     # @return [RDF::Node]
+    #     def each_statement(&block); end.
+    #   end
+    attr_accessor :subject
+    def each_statement(&block)
+      elements = operands.map do |op|
+        if op.respond_to?(:each_statement)
+          op.each_statement(&block)
+          op.subject
+        else
+          op
+        end
+      end
+      list = RDF::List(*elements)
+      list.each_statement(&block)
+      @subject = list.subject
+    end
+  end
+end

data/lib/shacl/shapes.rb

@@ -0,0 +1,160 @@
+require_relative 'algebra'
+require_relative 'validation_report'
+require_relative 'context'
+require 'json/ld'
+
+module SHACL
+  ##
+  # The set of shapes loaded from a graph.
+  class Shapes < Array
+    include RDF::Util::Logger
+
+    # The graphs which have been loaded as shapes
+    #
+    # @return [Array<RDF::URI>]
+    attr_reader :loaded_graphs
+
+    # The JSON used to instantiate shapes
+    #
+    # @return [Array<Hash>]
+    attr_reader :shape_json
+
+    ##
+    # Initializes the shapes from `graph`loading `owl:imports` until all references are loaded.
+    #
+    # The shapes come from the following:
+    # * Instances of `sh:NodeShape` or `sh:PropertyShape`
+    # * resources that have any of the properties `sh:targetClass`, `sh:targetNode`, `sh:targetObjectsOf`, or `sh:targetSubjectsOf`.
+    #
+    # @param [RDF::Graph] graph
+    # @param [Array<RDF::URI>] loaded_graphs = []
+    # @param [Hash{Symbol => Object}] options
+    # @return [Shapes]
+    # @raise [SHACL::Error]
+    def self.from_graph(graph, loaded_graphs: [], **options)
+      @loded_graphs = loaded_graphs
+
+      import_count = 0
+      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
+          import_count += 1
+        end
+      end
+
+      # Serialize the graph as framed JSON-LD and initialize patterns, recursively.
+      shape_json = JSON::LD::API.fromRdf(graph, useNativeTypes: true) do |expanded|
+        JSON::LD::API.frame(expanded, SHAPES_FRAME, omitGraph: false, embed: '@always', expanded: true)
+      end['@graph']
+
+      # 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
+    end
+
+    ##
+    # Retrieve shapes from a sh:shapesGraph reference within the queryable
+    #
+    # @param [RDF::Queryable] queryable
+    #   The data graph which may contain references to the shapes graph
+    # @param [Hash{Symbol => Object}] options
+    # @return [Shapes]
+    # @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)}
+      end
+      from_graph(graph, loaded_graphs: graphs, **options)
+    end
+
+    ##
+    # Match on schema. Finds appropriate shape for node, and matches that shape.
+    #
+    # @param [RDF::Queryable] graph
+    # @return [Hash{RDF::Term => Array<ValidationResult>}] Returns _ValidationResults_, a hash of focus nodes to the results of their associated shapes
+    # @param [Hash{Symbol => Object}] options
+    # @option options [RDF::Term] :focus
+    #   An explicit focus node, overriding any defined on the top-level shaps.
+    # @return [SHACL::ValidationReport]
+    def execute(graph, depth: 0, **options)
+      self.each do |shape|
+        shape.graph = graph
+        shape.each_descendant do |op|
+          op.graph = graph
+        end
+      end
+
+      # Execute all shapes against their target nodes
+      ValidationReport.new(self.map do |shape|
+        nodes = Array(options.fetch(:focus, shape.targetNodes))
+        nodes.map do |node|
+          shape.conforms(node, depth: depth + 1)
+        end
+      end.flatten)
+    end
+
+    def to_sxp_bin
+      [:shapes, super]
+    end
+
+    def to_sxp
+      to_sxp_bin.to_sxp
+    end
+
+    SHAPES_FRAME = JSON.parse(%({
+      "@context": {
+        "id": "@id",
+        "type": {"@id": "@type", "@container": "@set"},
+        "@vocab": "http://www.w3.org/ns/shacl#",
+        "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"},
+        "annotationProperty": {"@type": "@id"},
+        "class": {"@type": "@id"},
+        "comment": "http://www.w3.org/2000/01/rdf-schema#comment",
+        "condition": {"@type": "@id"},
+        "datatype": {"@type": "@vocab"},
+        "declare": {"@type": "@id"},
+        "disjoint": {"@type": "@id"},
+        "entailment": {"@type": "@id"},
+        "equals": {"@type": "@id"},
+        "ignoredProperties": {"@type": "@id", "@container": "@list"},
+        "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"},
+        "nodeKind": {"@type": "@vocab"},
+        "or": {"@type": "@id", "@container": "@list"},
+        "path": {"@type": "@none"},
+        "property": {"@type": "@id"},
+        "severity": {"@type": "@vocab"},
+        "targetClass": {"@type": "@id"},
+        "targetNode": {"@type": "@none"},
+        "xone": {"@type": "@id", "@container": "@list"}
+      },
+      "and": {},
+      "class": {},
+      "datatype": {},
+      "in": {},
+      "node": {},
+      "nodeKind": {},
+      "not": {},
+      "or": {},
+      "property": {},
+      "targetClass": {},
+      "targetNode": {},
+      "targetObjectsOf": {},
+      "xone": {},
+      "targetSubjectsOf": {}
+    })).freeze
+  end
+end