shex 0.1.0

data/lib/shex/algebra/or.rb

@@ -0,0 +1,37 @@
+module ShEx::Algebra
+  ##
+  class Or < Operator
+    include Satisfiable
+    NAME = :or
+
+    def initialize(*args, **options)
+      case
+      when args.length <= 1
+        raise ArgumentError, "wrong number of arguments (given #{args.length}, expected 1..)"
+      end
+      super
+    end
+
+    #
+    # S is a ShapeOr and there is some shape expression se2 in shapeExprs such that satisfies(n, se2, G, m).
+    # @param [RDF::Resource] n
+    # @return [Boolean] `true` if satisfied, `false` if it does not apply
+    # @raise [ShEx::NotSatisfied] if not satisfied
+    def satisfies?(n)
+      any_not_satisfied = false
+      operands.select {|o| o.is_a?(Satisfiable)}.any? do |op|
+        begin
+          op.satisfies?(n)
+          status "satisfied #{n}"
+          return true
+        rescue ShEx::NotSatisfied => e
+          log_recover("or: ignore error: #{e.message}", depth: options.fetch(:depth, 0))
+          any_not_satisfied = e
+          false
+        end
+      end
+
+      not_satisfied "Expected some expression to be satisfied"
+    end
+  end
+end

data/lib/shex/algebra/prefix.rb

@@ -0,0 +1,6 @@
+module ShEx::Algebra
+  ##
+  class Prefix < Operator::Binary
+    NAME = :prefix
+  end
+end

data/lib/shex/algebra/satisfiable.rb

@@ -0,0 +1,44 @@
+require 'sparql/algebra'
+require 'sparql/extensions'
+
+module ShEx::Algebra
+  # Implements `satisfies?` and `not_satisfies?`
+  module Satisfiable
+    ##
+    # Satisfies method
+    # @param [RDF::Resource] n
+    # @return [Boolean] `true` if satisfied, `false` if it does not apply
+    # @raise [ShEx::NotSatisfied] if not satisfied
+    # @see [https://shexspec.github.io/spec/#shape-expression-semantics]
+    def satisfies?(n)
+      raise NotImplementedError, "#satisfies? Not implemented in #{self.class}"
+    end
+
+    ##
+    # Satisfies method
+    # @param [RDF::Resource] n
+    # @return [Boolean] `true` if not satisfied, `false` if it does not apply
+    # @raise [ShEx::NotSatisfied] if satisfied
+    # @see [https://shexspec.github.io/spec/#shape-expression-semantics]
+    def not_satisfies?(n)
+      begin
+        satisfies?(n)
+      rescue ShEx::NotSatisfied => e
+        log_recover(self.class.const_get(:NAME), "ignore error: #{e.message}", depth: options.fetch(:depth, 0))
+        return true  # Expected it to not satisfy
+      end
+      not_satisfied "Expression should not have matched"
+    end
+    alias_method :notSatisfies?, :not_satisfies?
+
+    ##
+    # Included TripleExpressions
+    # @return [Array<TripleExpressions>]
+    def triple_expressions
+      operands.select {|o| o.is_a?(Satisfiable)}.map(&:triple_expressions).flatten.uniq
+    end
+
+    # This operator includes Satisfiable
+    def satisfiable?; true; end
+  end
+end

data/lib/shex/algebra/schema.rb

@@ -0,0 +1,125 @@
+module ShEx::Algebra
+  ##
+  class Schema < Operator
+    include Satisfiable
+    NAME = :schema
+
+    # Graph to validate
+    # @return [RDF::Queryable]
+    attr_accessor :graph
+
+    # Map of nodes to shapes
+    # @return [Hash{RDF::Resource => RDF::Resource}]
+    attr_reader :map
+
+    ##
+    # Match on schema. Finds appropriate shape for node, and matches that shape.
+    #
+    # @param [RDF::Resource] n
+    # @param [RDF::Queryable] g
+    # @param [Hash{RDF::Resource => RDF::Resource}] m
+    # @param [Array<Schema, String>] shapeExterns ([])
+    #   One or more schemas, or paths to ShEx schema resources used for finding external shapes.
+    # @return [Boolean] `true` if satisfied, `false` if it does not apply
+    # @raise [ShEx::NotSatisfied] if not satisfied
+    # FIXME: set of node/shape pairs
+    def satisfies?(n, g, m, shapeExterns: [], **options)
+      @graph = g
+      @external_schemas = shapeExterns
+      # Make sure they're URIs
+      @map = m.inject({}) {|memo, (k,v)| memo.merge(k.to_s => v.to_s)}
+
+      # First, evaluate semantic acts
+      semantic_actions.all? do |op|
+        op.satisfies?([])
+      end
+
+      # Next run any start expression
+      if start
+        status("start") {"expression: #{start.to_sxp}"}
+        start.satisfies?(n)
+      end
+
+      label = @map[n.to_s]
+      if label && !label.empty?
+        shape = shapes[label]
+        structure_error("No shape found for #{label}") unless shape
+
+        # If `n` is a Blank Node, we won't find it through normal matching, find an equivalent node in the graph having the same label
+        if n.is_a?(RDF::Node)
+          nn = graph.enum_term.detect {|t| t.id == n.id}
+          n = nn if nn
+        end
+
+        shape.satisfies?(n)
+      end
+      status "schema satisfied"
+      true
+    end
+
+    ##
+    # Shapes as a hash
+    # @return [Hash{RDF::Resource => Operator}]
+    def shapes
+      @shapes ||= begin
+        shapes = operands.
+        detect {|op| op.is_a?(Array) && op.first == :shapes}
+        shapes = shapes ? shapes.last : {}
+        shapes.inject({}) do |memo, (label, operand)|
+          memo.merge(label.to_s => operand)
+        end
+      end
+    end
+
+    ##
+    # Externally loaded schemas, lazily evaluated
+    # @return [Array<Schema>]
+    def external_schemas
+      @external_schemas = Array(@external_schemas).map do |extern|
+        schema = case extern
+        when Schema then extern
+        else
+          status "Load extern #{extern}"
+          ShEx.open(extern, logger: options[:logger])
+        end
+        schema.graph = graph
+        schema
+      end
+    end
+
+    ##
+    # Enumerate via depth-first recursive descent over operands, yielding each operator
+    # @yield operator
+    # @yieldparam [Object] operator
+    # @return [Enumerator]
+    def each_descendant(depth = 0, &block)
+      if block_given?
+        super(depth + 1, &block)
+        shapes.values.each do |op|
+          op.each_descendant(depth + 1, &block) if op.respond_to?(:each_descendant)
+
+          case block.arity
+          when 1 then block.call(op)
+          else block.call(depth, op)
+          end
+        end
+      end
+      enum_for(:each_descendant)
+    end
+
+    ##
+    # Start action, if any
+    def start
+      @start ||= operands.detect {|op| op.is_a?(Start)}
+    end
+
+    ##
+    # Validate shapes, in addition to other operands
+    # @return [SPARQL::Algebra::Expression] `self`
+    # @raise  [ArgumentError] if the value is invalid
+    def validate!
+      shapes.values.each {|op| op.validate! if op.respond_to?(:validate!)}
+      super
+    end
+  end
+end

data/lib/shex/algebra/semact.rb

@@ -0,0 +1,38 @@
+module ShEx::Algebra
+  ##
+  class SemAct < Operator
+    NAME = :semact
+
+    #
+    # The evaluation semActsSatisfied on a list of SemActs returns success or failure. The evaluation of an individual SemAct is implementation-dependent.
+    # @param [Array<RDF::Statement>] statements
+    # @return [Boolean] `true` if satisfied, `false` if it does not apply
+    # @raise [ShEx::NotSatisfied] if not satisfied
+    def satisfies?(statements)
+      # FIXME: should have a registry
+      case operands.first.to_s
+      when "http://shex.io/extensions/Test/"
+        str = if md = /^ *(fail|print) *\( *(?:(\"(?:[^\\"]|\\")*\")|([spo])) *\) *$/.match(operands[1].to_s)
+          md[2] || case md[3]
+          when 's' then statements.first.subject
+          when 'p' then statements.first.predicate
+          when 'o' then statements.first.object
+          else          statements.first.to_sxp
+          end.to_s
+        else
+          statements.empty? ? 'no statement' : statements.first.to_sxp
+        end
+        $stdout.puts str
+        status str
+        not_satisfied "fail" if md && md[1] == 'fail'
+        true
+      else
+        status("unknown SemAct name #{operands.first}") {"expression: #{self.to_sxp}"}
+        false
+      end
+    end
+
+    # Does This operator is SemAct
+    def semact?; true; end
+  end
+end

data/lib/shex/algebra/shape.rb

@@ -0,0 +1,93 @@
+module ShEx::Algebra
+  ##
+  class Shape < Operator
+    include Satisfiable
+    NAME = :shape
+
+    #
+    # The `satisfies` semantics for a `Shape` depend on a matches function defined below. For a node `n`, shape `S`, graph `G`, and shapeMap `m`, `satisfies(n, S, G, m)`.
+    # @param [RDF::Resource] n
+    # @return [Boolean] `true` if satisfied
+    # @raise [ShEx::NotSatisfied] if not satisfied
+    def satisfies?(n)
+      expression = operands.detect {|op| op.is_a?(TripleExpression)}
+
+      # neigh(G, n) is the neighbourhood of the node n in the graph G.
+      #
+      #    neigh(G, n) = arcsOut(G, n) ∪ arcsIn(G, n)
+      arcs_in = schema.graph.query(object: n).to_a.sort_by(&:to_sxp)
+      arcs_out = schema.graph.query(subject: n).to_a.sort_by(&:to_sxp)
+      neigh = (arcs_in + arcs_out).uniq
+
+      # `matched` is the subset of statements which match `expression`.
+      status("arcsIn: #{arcs_in.count}, arcsOut: #{arcs_out.count}")
+      matched = expression ? expression.matches(neigh) : []
+
+      # `remainder` is the set of unmatched statements
+      remainder = neigh - matched
+
+      # Let `outs` be the `arcsOut` in `remainder`: `outs = remainder ∩ arcsOut(G, n)`.
+      outs = remainder.select {|s| s.subject == n}
+
+      # Let `matchables` be the triples in `outs` whose predicate appears in a `TripleConstraint` in `expression`. If `expression` is absent, `matchables = Ø` (the empty set).
+      predicates = expression ? expression.triple_constraints.map(&:predicate).uniq : []
+      matchables = outs.select {|s| predicates.include?(s.predicate)}
+
+      # No matchable can be matched by any TripleConstraint in expression
+      matchables.each do |statement|
+        expression.triple_constraints.each do |expr|
+          begin
+            status "check matchable #{statement.to_sxp} against #{expr.to_sxp}"
+            if statement.predicate == expr.predicate && expr.matches([statement])
+              not_satisfied "Unmatched statement: #{statement.to_sxp} matched #{expr.to_sxp}"
+            end
+          rescue NotMatched
+            logger.recovering = false
+            # Expected not to match
+          end
+        end
+      end if expression
+
+      # There is no triple in `matchables` which matches a `TripleConstraint` in `expression`.
+      # FIXME: Really run against every TripleConstraint?
+
+      # Let `unmatchables` be the triples in `outs` which are not in `matchables`.
+      unmatchables = outs - matchables
+
+      # There is no triple in matchables whose predicate does not appear in extra.
+      matchables.each do |statement|
+        not_satisfied "Statement remains with predicate #{statement.predicate} not in extra" unless extra.include?(statement.predicate)
+      end
+
+      # closed is false or unmatchables is empty.
+      not_satisfied "Unmatchables remain on a closed shape" unless !closed? || unmatchables.empty?
+
+      # Presumably, to be satisfied, there must be some triples in matches
+
+      semantic_actions.all? do |op|
+        # FIXME: what triples to run against satisfies?
+        op.satisfies?(matched)
+      end unless matched.empty?
+
+      true
+    rescue NotMatched => e
+      logger.recovering = false
+      not_satisfied e.message
+    end
+
+    ##
+    # Included TripleExpressions
+    # @return [Array<TripleExpressions>]
+    def triple_expressions
+      operands.select {|op| op.is_a?(TripleExpression)}
+    end
+
+    private
+    # There may be multiple extra operands
+    def extra
+      operands.select {|op| op.is_a?(Array) && op.first == :extra}.inject([]) do |memo, ary|
+        memo + Array(ary[1..-1])
+      end.uniq
+    end
+  end
+end

data/lib/shex/algebra/shape_ref.rb

@@ -0,0 +1,46 @@
+module ShEx::Algebra
+  ##
+  class ShapeRef < Operator::Unary
+    include Satisfiable
+    NAME = :shapeRef
+
+    def initialize(arg, **options)
+      structure_error("Shape reference must be an IRI or BNode: #{arg}", exception: ArgumentError) unless arg.is_a?(RDF::Resource)
+      super
+    end
+
+    ##
+    # Satisfies method
+    # @param [RDF::Resource] n
+    # @return [Boolean] `true` if satisfied
+    # @raise [ShEx::NotSatisfied] if not satisfied
+    # @see [https://shexspec.github.io/spec/#shape-expression-semantics]
+    def satisfies?(n)
+      status "ref #{operands.first.to_s}"
+      referenced_shape.satisfies?(n)
+      status "ref satisfied"
+      true
+    rescue ShEx::NotSatisfied => e
+      not_satisfied e.message
+      raise
+    end
+
+    ##
+    # Returns the referenced shape
+    #
+    # @return [Shape]
+    def referenced_shape
+      schema.shapes[operands.first.to_s]
+    end
+
+    ##
+    # A ShapeRef is valid if it's ancestor schema has any shape with a lable
+    # the same as it's reference.
+    def validate!
+      structure_error("Missing referenced shape: #{operands.first}") if referenced_shape.nil?
+      # FIXME
+      #raise ShEx::ParseError, "Self referencing shape: #{operands.first}" if referenced_shape == first_ancestor(Shape)
+      super
+    end
+  end
+end

data/lib/shex/algebra/start.rb

@@ -0,0 +1,20 @@
+module ShEx::Algebra
+  ##
+  class Start < Operator::Unary
+    NAME = :start
+
+    #
+    # @param [RDF::Resource] n
+    # @return [Boolean] `true` if satisfied
+    # @raise [ShEx::NotSatisfied] if not satisfied
+    def satisfies?(n)
+      status ""
+      operands.first.satisfies?(n)
+      status("satisfied")
+      true
+    rescue ShEx::NotSatisfied => e
+      not_satisfied e.message
+      raise
+    end
+  end
+end

data/lib/shex/algebra/stem.rb

@@ -0,0 +1,20 @@
+module ShEx::Algebra
+  ##
+  class Stem < Operator::Unary
+    NAME = :stem
+
+    ##
+    # For a node n and constraint value v, nodeSatisfies(n, v) if n matches some valueSetValue vsv in v. A term matches a valueSetValue if:
+    #
+    # * vsv is a Stem with stem st and nodeIn(n, st).
+    def match?(value)
+      if value.start_with?(operands.first)
+        status "matched #{value}"
+        true
+      else
+        status "not matched #{value}"
+        false
+      end
+    end
+  end
+end

data/lib/shex/algebra/stem_range.rb

@@ -0,0 +1,42 @@
+module ShEx::Algebra
+  ##
+  class StemRange < Operator::Binary
+    NAME = :stemRange
+
+    ##
+    # For a node n and constraint value v, nodeSatisfies(n, v) if n matches some valueSetValue vsv in v. A term matches a valueSetValue if:
+    #
+    # * vsv is a StemRange with stem st and exclusions excls and nodeIn(n, st) and there is no x in excls such that nodeIn(n, excl).
+    # * vsv is a Wildcard with exclusions excls and there is no x in excls such that nodeIn(n, excl).
+    def match?(value)
+      initial_match = case operands.first
+      when :wildcard then true
+      when RDF::Value then value.start_with?(operands.first)
+      else false
+      end
+
+      unless initial_match
+        status "#{value} does not match #{operands.first}"
+        return false
+      end
+
+      if exclusions.any? do |exclusion|
+          case exclusion
+          when RDF::Value then value == exclusion
+          when Stem       then exclusion.match?(value)
+          else                 false
+          end
+        end
+        status "#{value} excluded"
+        return false
+      end
+
+      status "matched #{value}"
+      true
+    end
+
+    def exclusions
+      (operands.last.is_a?(Array) && operands.last.first == :exclusions) ? operands.last[1..-1] : []
+    end
+  end
+end