shex 0.2.0 → 0.3.0

data/lib/shex/algebra/shape_ref.rb

@@ -9,19 +9,35 @@ module ShEx::Algebra
       super
     end
 
+    ##
+    # Creates an operator instance from a parsed ShExJ representation
+    # @param (see Operator#from_shexj)
+    # @return [Operator]
+    def self.from_shexj(operator, options = {})
+      raise ArgumentError unless operator.is_a?(Hash) && operator['type'] == "ShapeRef"
+      raise ArgumentError, "missing reference in #{operator.inspect}" unless operator.has_key?('reference')
+      super
+    end
+
     ##
     # Satisfies referenced shape.
     # @param  (see Satisfiable#satisfies?)
     # @return (see Satisfiable#satisfies?)
     # @raise  (see Satisfiable#satisfies?)
     # @see [https://shexspec.github.io/spec/#shape-expression-semantics]
-    def satisfies?(focus)
-      status "ref #{operands.first.to_s}"
-      matched_shape = referenced_shape.satisfies?(focus)
-      satisfy satisfied: matched_shape
+    def satisfies?(focus, depth: 0)
+      status "ref #{operands.first.to_s}", depth: depth
+      schema.enter_shape(operands.first, focus) do |shape|
+        if shape
+          matched_shape = shape.satisfies?(focus, depth: depth + 1)
+          satisfy focus: focus, satisfied: matched_shape, depth: depth
+        else
+          status "Satisfy as #{operands.first} was re-entered for #{focus}", depth: depth
+          satisfy focus: focus, satisfied: referenced_shape, depth: depth
+        end
+      end
     rescue ShEx::NotSatisfied => e
-      not_satisfied e.message, unsatisfied: e.expression
-      raise
+      not_satisfied e.message, focus: focus, unsatisfied: e.expression, depth: depth
     end
 
     ##
@@ -29,17 +45,27 @@ module ShEx::Algebra
     #
     # @return [Shape]
     def referenced_shape
-      schema.shapes[operands.first.to_s]
+      @referenced_shape ||= schema.shapes.detect {|s| s.label == operands.first}
     end
 
     ##
-    # A ShapeRef is valid if it's ancestor schema has any shape with a lable
+    # A ShapeRef is valid if it's ancestor schema has any shape with a label
     # the same as it's reference.
+    # A ref cannot reference itself (via whatever path) without going through a TripleConstraint.
+    # Even when going through TripleConstraints, there can't be a negative 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)
+      raise ShEx::StructureError, "Self referencing shape: #{operands.first}" if referenced_shape == first_ancestor(Satisfiable)
       super
     end
+
+    ##
+    # Returns the binary S-Expression (SXP) representation of this operator.
+    #
+    # @return [Array]
+    # @see    https://en.wikipedia.org/wiki/S-expression
+    def to_sxp_bin
+      ([:shapeRef, ([:label, @label] if @label)].compact + operands).to_sxp_bin
+    end
   end
 end

data/lib/shex/algebra/start.rb

@@ -8,12 +8,12 @@ module ShEx::Algebra
     # @param  (see Satisfiable#satisfies?)
     # @return (see Satisfiable#satisfies?)
     # @raise  (see Satisfiable#satisfies?)
-    def satisfies?(focus)
-      status ""
-      matched_op = operands.first.satisfies?(focus)
-      satisfy satisfied: matched_op
+    def satisfies?(focus, depth: 0)
+      status "", depth: depth
+      matched_op = operands.first.satisfies?(focus, depth: depth + 1)
+      satisfy focus: focus, satisfied: matched_op, depth: depth
     rescue ShEx::NotSatisfied => e
-      not_satisfied e.message, unsatisfied: e.expression
+      not_satisfied e.message, focus: focus, unsatisfied: e.expression, depth: depth
       raise
     end
   end

data/lib/shex/algebra/stem.rb

@@ -3,18 +3,33 @@ module ShEx::Algebra
   class Stem < Operator::Unary
     NAME = :stem
 
+    ##
+    # Creates an operator instance from a parsed ShExJ representation
+    # @param (see Operator#from_shexj)
+    # @return [Operator]
+    def self.from_shexj(operator, options = {})
+      raise ArgumentError unless operator.is_a?(Hash) && operator['type'] == "Stem"
+      raise ArgumentError, "missing stem in #{operator.inspect}" unless operator.has_key?('stem')
+      super
+    end
+
     ##
     # 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)
+    def match?(value, depth: 0)
       if value.start_with?(operands.first)
-        status "matched #{value}"
+        status "matched #{value}", depth: depth
         true
       else
-        status "not matched #{value}"
+        status "not matched #{value}", depth: depth
         false
       end
     end
+
+    def json_type
+      # FIXME: This is funky, due to oddities in normative shexj
+      parent.is_a?(Value) ? 'StemRange' : 'Stem'
+    end
   end
 end

data/lib/shex/algebra/stem_range.rb

@@ -3,12 +3,31 @@ module ShEx::Algebra
   class StemRange < Operator::Binary
     NAME = :stemRange
 
+    ##
+    # Creates an operator instance from a parsed ShExJ representation
+    # @param (see Operator#from_shexj)
+    # @return [Operator]
+    def self.from_shexj(operator, options = {})
+      raise ArgumentError unless operator.is_a?(Hash) && operator['type'] == 'StemRange'
+      raise ArgumentError, "missing stem in #{operator.inspect}" unless operator.has_key?('stem')
+
+      # Normalize wildcard representation
+      operator['stem'] = :wildcard if operator['stem'] =={'type' => 'Wildcard'}
+
+      # Note that the type may be StemRange, but if there's no exclusions, it's really just a Stem
+      if operator.has_key?('exclusions')
+        super
+      else
+        Stem.from_shexj(operator.merge('type' => 'Stem'), options)
+      end
+    end
+
     ##
     # 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)
+    def match?(value, depth: 0)
       initial_match = case operands.first
       when :wildcard then true
       when RDF::Value then value.start_with?(operands.first)
@@ -16,22 +35,22 @@ module ShEx::Algebra
       end
 
       unless initial_match
-        status "#{value} does not match #{operands.first}"
+        status "#{value} does not match #{operands.first}", depth: depth
         return false
       end
 
       if exclusions.any? do |exclusion|
           case exclusion
           when RDF::Value then value == exclusion
-          when Stem       then exclusion.match?(value)
+          when Stem       then exclusion.match?(value, depth: depth + 1)
           else                 false
           end
         end
-        status "#{value} excluded"
+        status "#{value} excluded", depth: depth
         return false
       end
 
-      status "matched #{value}"
+      status "matched #{value}", depth: depth
       true
     end
 

data/lib/shex/algebra/triple_constraint.rb

@@ -4,25 +4,36 @@ module ShEx::Algebra
     include TripleExpression
     NAME = :tripleConstraint
 
+    ##
+    # Creates an operator instance from a parsed ShExJ representation
+    # @param (see Operator#from_shexj)
+    # @return [Operator]
+    def self.from_shexj(operator, options = {})
+      raise ArgumentError unless operator.is_a?(Hash) && operator['type'] == 'TripleConstraint'
+      raise ArgumentError unless operator.has_key?('predicate')
+      super
+    end
+
     ##
     # In this case, we accept an array of statements, and match based on cardinality.
     #
     # @param  (see TripleExpression#matches)
     # @return (see TripleExpression#matches)
     # @raise  (see TripleExpression#matches)
-    def matches(statements)
-      status "predicate #{predicate}"
-      results, satisfied, unsatisfied = [], [], []
+    def matches(arcs_in, arcs_out, depth: 0)
+      status "predicate #{predicate}", depth: depth
+      results, unmatched, satisfied, unsatisfied = [], [], [], []
       num_iters, max = 0, maximum
 
+      statements = inverse? ? arcs_in : arcs_out
       statements.select {|st| st.predicate == predicate}.each do |statement|
         break if num_iters == max # matched enough
 
         value = inverse? ? statement.subject : statement.object
 
         begin
-          shape && (matched_shape = shape.satisfies?(value))
-          status "matched #{statement.to_sxp}"
+          shape && (matched_shape = shape.satisfies?(value, depth: depth + 1))
+          status "matched #{statement.to_sxp}", depth: depth
           if matched_shape
             matched_shape.matched = [statement]
             statement = statement.dup.extend(ReferencedStatement)
@@ -32,9 +43,11 @@ module ShEx::Algebra
           results << statement
           num_iters += 1
         rescue ShEx::NotSatisfied => e
-          status "not satisfied: #{e.message}"
+          status "not satisfied: #{e.message}", depth: depth
+          unsatisfied << e.expression
           statement = statement.dup.extend(ReferencedStatement)
-          unmatched << statement.referenced = shape
+          statement.referenced = shape
+          unmatched << statement
         end
       end
 
@@ -44,22 +57,22 @@ module ShEx::Algebra
       end
 
       # Last, evaluate semantic acts
-      semantic_actions.all? do |op|
-        op.satisfies?(results)
+      semantic_actions.each do |op|
+        op.satisfies?(results, matched: results, depth: depth + 1)
       end unless results.empty?
 
-      satisfy matched: results, satisfied: satisfied, unsatisfied: unsatisfied
+      satisfy matched:   results,   unmatched:   unmatched,
+              satisfied: satisfied, unsatisfied: unsatisfied, depth: depth
     rescue ShEx::NotMatched, ShEx::NotSatisfied => e
       not_matched e.message,
-                  matched:   results,   unmatched:   (statements - results),
-                  satisfied: satisfied, unsatisfied: unsatisfied
+                  matched:   results,   unmatched:   unmatched,
+                  satisfied: satisfied, unsatisfied: unsatisfied, depth: depth
     end
 
     def predicate
       operands.detect {|o| o.is_a?(RDF::URI)}
     end
 
-
     ##
     # Included TripleConstraints
     # @return [Array<TripleConstraints>]

data/lib/shex/algebra/triple_expression.rb

@@ -8,10 +8,11 @@ module ShEx::Algebra
     #
     # Behavior should be overridden in subclasses, which end by calling this through `super`.
     #
-    # @param [Array<RDF::Statement>] statements
+    # @param [Array<RDF::Statement>] arcs_in
+    # @param [Array<RDF::Statement>] arcs_out
     # @return [TripleExpression] with `matched` accessor for matched triples
     # @raise [ShEx::NotMatched] with `expression` accessor to access `matched` and `unmatched` statements along with `satisfied` and `unsatisfied` operations.
-    def matches(statements)
+    def matches(arcs_in, arcs_out, depth: 0)
       raise NotImplementedError, "#matches Not implemented in #{self.class}"
     end
 

data/lib/shex/algebra/value.rb

@@ -10,17 +10,17 @@ module ShEx::Algebra
     # * vsv is a Stem with stem st and nodeIn(n, st).
     # * 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)
-      status ""
+    def match?(value, depth: 0)
+      status "", depth: depth
       if case expr = operands.first
         when RDF::Value then value.eql?(expr)
-        when Stem, StemRange then expr.match?(value)
+        when Stem, StemRange then expr.match?(value, depth: depth + 1)
         else false
         end
-        status "matched #{value}"
+        status "matched #{value}", depth: depth
         true
       else
-        status "not matched #{value}"
+        status "not matched #{value}", depth: depth
         false
       end
     end

data/lib/shex/extensions/extension.rb

@@ -0,0 +1,160 @@
+$:.unshift(File.expand_path("../..", __FILE__))
+require 'sparql/algebra'
+
+##
+# Abstract class of ShEx [Extension](https://shexspec.github.io/spec/#semantic-actions) extensions.
+#
+# Extensions are registered automatically when they are required by subclassing this class.
+#
+# Implementations may provide an initializer which is called once for a given semantic action. Additionally, `enter` and `exit` methods are invoked when beginning any Triple Expression containing this Semantic Action. The `visit` method is invoked once for each matched triple within that Triple Expression.
+#
+# @example Test extension
+#   class Test < ShEx::Extension("http://shex.io/extensions/Test/")
+#
+#     # Called to initialize module before evaluating shape
+#     def initialize(schema: nil, depth: 0, logger: nil, **options)
+#     end
+#
+#     # Called on entry to containing Triple Expression
+#     def enter(code: nil, arcs_in: nil, arcs_out: nil, depth: 0, **options)
+#     end
+#
+#     # Called once for each matched statement
+#     def visit(code: nil, matched: nil, depth: 0, **options)
+#     end
+#
+#     # Called on entry to containing Triple Expression
+#     def exit(code: nil, matched: [], unmatched: [], depth: 0, **options)
+#     end
+#
+#     # Called after shape completes on success or failure
+#     def close(schema: nil, depth: 0, **options)
+#     end
+#
+# Subclasses **must** define at least `visit`.
+#
+# @see https://shexspec.github.io/spec/#semantic-actions
+class ShEx::Extension
+  extend ::Enumerable
+
+  class << self
+    ##
+    # The "name" of this class is a URI used to uniquely identify it.
+    # @return [String]
+    def name
+      @@subclasses.invert[self]
+    end
+
+    ##
+    # Enumerates known Semantic Action classes.
+    #
+    # @yield  [klass]
+    # @yieldparam [Class] klass
+    # @return [Enumerator]
+    def each(&block)
+      if self.equal?(ShEx::Extension)
+        # This is needed since all Semantic Action classes are defined using
+        # Ruby's autoloading facility, meaning that `@@subclasses` will be
+        # empty until each subclass has been touched or require'd.
+        @@subclasses.values.each(&block)
+      else
+        block.call(self)
+      end
+    end
+
+    ##
+    # Return the SemanticAction associated with a URI.
+    #
+    # @param [#to_s] name
+    # @return [SemanticAction]
+    def find(name)
+      @@subclasses.fetch(name.to_s, nil)
+    end
+
+  private
+    @@subclasses = {} # @private
+    @@uri        = nil     # @private
+
+    def create(uri) # @private
+      @@uri = uri
+      self
+    end
+
+    def inherited(subclass) # @private
+      unless @@uri.nil?
+        @@subclasses[@@uri.to_s] = subclass
+        @@uri = nil
+      end
+      super
+    end
+
+    ShEx::EXTENSIONS.each { |v| require "shex/extensions/#{v}" }
+  end
+
+  ##
+  # Initializer for a given instance. Implementations _may_ define this for instance and/or class 
+  # @param [ShEx::Algebra::Schema] schema top level of the shape expression
+  # @param [RDF::Util::Logger] logger
+  # @param [Integer] depth for logging
+  # @param [Hash{Symbol => Object}] options from shape initialization
+  # @return [self]
+  def initialize(schema: nil, logger: nil, depth: 0, **options)
+    @logger = logger
+    @options = options
+    self
+  end
+
+  ##
+  # Called on entry to containing {ShEx::TripleExpression}
+  #
+  # @param [String] code
+  # @param [Array<RDF::Statement>] arcs_in available statements to be matched
+  # @param [Array<RDF::Statement>] arcs_out available statements to be matched
+  # @param [ShEx::Algebra::TripleExpression] expression containing this semantic act
+  # @param [Integer] depth for logging
+  # @param [Hash{Symbol => Object}] options
+  #   Other, operand-specific options
+  # @return [Boolean] Returning `false` results in {ShEx::NotSatisfied} exception
+  def enter(code: nil, arcs_in: nil, arcs_out: nil, expression: nil, depth: 0, **options)
+    true
+  end
+
+  ##
+  # Called after a {ShEx::TripleExpression} has matched zero or more statements
+  #
+  # @param [String] code
+  # @param [RDF::Statement] matched statement
+  # @param [Integer] depth for logging
+  # @param [ShEx::Algebra::TripleExpression] expression containing this semantic act
+  # @param [Hash{Symbol => Object}] options
+  #   Other, operand-specific options
+  # @return [Boolean] Returning `false` results in {ShEx::NotSatisfied}
+  def visit(code: nil, matched: nil, expression: nil, depth: 0, **options)
+    raise NotImplementedError
+  end
+
+  ##
+  # Called on exit from containing {ShEx::TripleExpression}
+  #
+  # @param [String] code
+  # @param [Array<RDF::Statement>] matched statements matched by this expression
+  # @param [Array<RDF::Statement>] unmatched statements considered, but not matched by this expression
+  # @param [ShEx::Algebra::TripleExpression] expression containing this semantic act
+  # @param [Integer] depth for logging
+  # @param [Hash{Symbol => Object}] options
+  #   Other, operand-specific options
+  # @return [self]
+  def exit(code: nil, matched: [], unmatched: [], expression: nil, depth: 0, **options)
+    self
+  end
+
+  # Called after shape completes on success or failure
+  # @param [ShEx::Algebra::Schema] schema top level of the shape expression
+  # @param [Integer] depth for logging
+  # @param [Hash{Symbol => Object}] options
+  #   Other, operand-specific options
+  # @return [self]
+  def close(schema: nil, depth: 0, **options)
+    self
+  end
+end