shex 0.2.0 → 0.3.0

data/lib/shex/algebra/or.rb

@@ -6,9 +6,22 @@ module ShEx::Algebra
 
     def initialize(*args, **options)
       case
-      when args.length <= 1
-        raise ArgumentError, "wrong number of arguments (given #{args.length}, expected 1..)"
+      when args.length < 2
+        raise ArgumentError, "wrong number of arguments (given #{args.length}, expected 2..)"
       end
+
+      # All arguments must be Satisfiable
+      raise ArgumentError, "All operands must be Shape operands" unless args.all? {|o| o.is_a?(Satisfiable)}
+      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'] == 'ShapeOr'
+      raise ArgumentError, "missing shapeExprs in #{operator.inspect}" unless operator.is_a?(Hash) && operator.has_key?('shapeExprs')
       super
     end
 
@@ -17,27 +30,31 @@ module ShEx::Algebra
     # @param  (see Satisfiable#satisfies?)
     # @return (see Satisfiable#satisfies?)
     # @raise  (see Satisfiable#satisfies?)
-    def satisfies?(focus)
-      status ""
+    def satisfies?(focus, depth: 0)
+      status "", depth: depth
       expressions = operands.select {|o| o.is_a?(Satisfiable)}
       unsatisfied = []
       expressions.any? do |op|
         begin
-          matched_op = op.satisfies?(focus)
-          return satisfy satisfied: matched_op, unsatisfied: unsatisfied
+          matched_op = op.satisfies?(focus, depth: depth + 1)
+          return satisfy focus: focus, satisfied: matched_op, depth: depth
         rescue ShEx::NotSatisfied => e
-          status "unsatisfied #{focus}"
+          status "unsatisfied #{focus}", depth: depth
           op = op.dup
           op.satisfied = e.expression.satisfied
           op.unsatisfied = e.expression.unsatisfied
           unsatisfied << op
-          status("unsatisfied: #{e.message}")
+          status "unsatisfied: #{e.message}", depth: depth
           false
         end
       end
 
       not_satisfied "Expected some expression to be satisfied",
-                    unsatisfied: unsatisfied
+                    focus: focus, unsatisfied: unsatisfied, depth: depth
+    end
+
+    def json_type
+      "ShapeOr"
     end
   end
 end

data/lib/shex/algebra/satisfiable.rb

@@ -6,20 +6,16 @@ module ShEx::Algebra
     ##
     # Satisfies method
     # @param [RDF::Resource] focus
-    # @return [TripleExpression] with `matched` and `satisfied` accessors for matched triples and sub-expressions
+    # @param [Integer] depth for logging
+    # @param [Hash{Symbol => Object}] options
+    #   Other, operand-specific options
+    # @return [Operator] with `matched` and `satisfied` accessors for matched triples and sub-expressions
     # @raise [ShEx::NotMatched] with `expression` accessor to access `matched` and `unmatched` statements along with `satisfied` and `unsatisfied` operations.
     # @see [https://shexspec.github.io/spec/#shape-expression-semantics]
-    def satisfies?(focus)
+    def satisfies?(focus, depth: 0, **options)
       raise NotImplementedError, "#satisfies? Not implemented in #{self.class}"
     end
 
-    ##
-    # 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

data/lib/shex/algebra/schema.rb

@@ -11,55 +11,95 @@ module ShEx::Algebra
     # @return [Hash{RDF::Resource => RDF::Resource}]
     attr_reader :map
 
+    # Map of Semantic Action instances
+    # @return [Hash{String => ShEx::Extension}]
+    attr_reader :extensions
+
+    ##
+    # 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'] == "Schema"
+      super
+    end
+
+    # (see Operator#initialize)
+    def initialize(*operands)
+      super
+      each_descendant do |op|
+        # Set schema everywhere
+        op.schema = self
+      end
+    end
+
     ##
     # Match on schema. Finds appropriate shape for node, and matches that shape.
     #
-    # @param [RDF::Resource] focus
+    # @param [RDF::Term] focus
     # @param [RDF::Queryable] graph
     # @param [Hash{RDF::Resource => RDF::Resource}] map
     # @param [Array<Schema, String>] shapeExterns ([])
     #   One or more schemas, or paths to ShEx schema resources used for finding external shapes.
     # @return [Operand] Returns operand graph annotated with satisfied and unsatisfied operations.
+    # @param [Hash{Symbol => Object}] options
+    # @option options [String] :base_uri
     # @raise [ShEx::NotSatisfied] along with operand graph described for return
-    def execute(focus, graph, map, shapeExterns: [], **options)
-      @graph = graph
+    def execute(focus, graph, map, shapeExterns: [], depth: 0, **options)
+      @graph, @shapes_entered = graph, {}
       @external_schemas = shapeExterns
-      focus = iri(focus)
+      focus = value(focus)
+
+      logger = options[:logger] || @options[:logger]
+      each_descendant do |op|
+        # Set logging everywhere
+        op.logger = logger
+      end
+
+      # Initialize Extensions
+      @extensions = {}
+      each_descendant do |op|
+        next unless op.is_a?(SemAct)
+        name = op.operands.first.to_s
+        if ext_class = ShEx::Extension.find(name)
+          @extensions[name] ||= ext_class.new(schema: self, depth: depth, **options)
+        end
+      end
+
+      # 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
+      graph_focus = graph.enum_term.detect {|t| t.node? && t.id == focus.id} if focus.is_a?(RDF::Node)
+      graph_focus ||= focus
+
       # Make sure they're URIs
-      @map = (map || {}).inject({}) {|memo, (k,v)| memo.merge(iri(k).to_s => iri(v).to_s)}
+      @map = (map || {}).inject({}) {|memo, (k,v)| memo.merge(value(k) => iri(v))}
 
       # First, evaluate semantic acts
       semantic_actions.all? do |op|
-        op.satisfies?([])
+        op.satisfies?([], depth: depth + 1)
       end
 
       # Keep a new Schema, specifically for recording actions
       satisfied_schema = Schema.new
       # Next run any start expression
       if start
-        status("start") {"expression: #{start.to_sxp}"}
-        satisfied_schema.operands << start.satisfies?(focus)
+        satisfied_schema.operands << start.satisfies?(focus, depth: depth + 1)
       end
 
       # Add shape result(s)
       satisfied_shapes = {}
       satisfied_schema.operands << [:shapes, satisfied_shapes] unless shapes.empty?
 
-      label = @map[focus.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 focus.is_a?(RDF::Node)
-          n = graph.enum_term.detect {|t| t.id == focus.id}
-          focus = n if n
+      # Match against all shapes associated with the labels for focus
+      Array(@map[focus]).each do |label|
+        enter_shape(label, focus) do |shape|
+          satisfied_shapes[label] = shape.satisfies?(graph_focus, depth: depth + 1)
         end
-
-        satisfied_shapes[label] = shape.satisfies?(focus)
       end
-      status "schema satisfied"
+      status "schema satisfied", depth: depth
       satisfied_schema
+    ensure
+      # Close Semantic Action extensions
+      @extensions.values.each {|ext| ext.close(schema: self, depth: depth, **options)}
     end
 
     ##
@@ -81,17 +121,37 @@ module ShEx::Algebra
 
     ##
     # Shapes as a hash
-    # @return [Hash{RDF::Resource => Operator}]
+    # @return [Array<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
+        shapes = Array(operands.detect {|op| op.is_a?(Array) && op.first == :shapes})
+        Array(shapes[1..-1])
       end
     end
 
+    ##
+    # Indicate that a shape has been entered with a specific focus node. Any future attempt to enter the same shape with the same node raises an exception.
+    # @param [RDF::Resource] label
+    # @param [RDF::Resource] node
+    # @yield :shape
+    # @yieldparam [Satisfiable] shape, or `nil` if shape already entered
+    # @return [Satisfiable]
+    def enter_shape(label, node, &block)
+      shape = shapes.detect {|s| s.label == label}
+      structure_error("No shape found for #{label}") unless shape
+      @shapes_entered[label] ||= {}
+      if @shapes_entered[label][node]
+        block.call(false)
+      else
+        @shapes_entered[label][node] = self
+        begin
+          block.call(shape)
+        ensure
+          @shapes_entered[label].delete(node)
+        end
+      end
+    end
+    
     ##
     # Externally loaded schemas, lazily evaluated
     # @return [Array<Schema>]
@@ -108,54 +168,6 @@ module ShEx::Algebra
       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
-
-    ##
-    # Returns the Base URI defined for the parser,
-    # as specified or when parsing a BASE prologue element.
-    #
-    # @example
-    #   base  #=> RDF::URI('http://example.com/')
-    #
-    # @return [HRDF::URI]
-    def base_uri
-      RDF::URI(@options[:base_uri]) if @options[:base_uri]
-    end
-
-    # Create URIs
-    def iri(value)
-      # If we have a base URI, use that when constructing a new URI
-      case value
-      when RDF::Value then value
-      when /^_:/ then RDF::Node(value[2..-1].to_s)
-      else
-        value = RDF::URI(value)
-        if base_uri && value.relative?
-          base_uri.join(value)
-        else
-          value
-        end
-      end
-    end
-
     ##
     # Start action, if any
     def start
@@ -167,7 +179,7 @@ module ShEx::Algebra
     # @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!)}
+      shapes.each {|op| op.validate! if op.respond_to?(:validate!)}
       super
     end
   end

data/lib/shex/algebra/semact.rb

@@ -3,35 +3,85 @@ module ShEx::Algebra
   class SemAct < Operator
     NAME = :semact
 
+    ##
+    # 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'] == "SemAct"
+      raise ArgumentError, "missing name in #{operator.inspect}" unless operator.has_key?('name')
+      code = operator.delete('code')
+      operator['code'] = code if code # Reorders operands appropriately
+      super
+    end
+
+    ##
+    # Called on entry
+    #
+    # @param [String] code
+    # @param [Array<RDF::Statement>] arcs_in available statements to be matched having `focus` as an object
+    # @param [Array<RDF::Statement>] arcs_out available statements to be matched having `focus` as a subject
+    # @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(**options)
+      if implementation = schema.extensions[operands.first.to_s]
+        implementation.enter(code: operands[0], expression: parent, **options)
+      end
+    end
+
     #
     # 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
+    #
+    # In addition to standard arguments `satsisfies` arguments, the current `matched` and `unmatched` statements may be passed. Additionally, all sub-classes of `Operator` have available `parent`, and `schema` accessors, which allows access to the operands of the parent, for example.
+    #
+    # @param [Object] focus (ignored)
+    # @param [Array<RDF::Statement>] matched matched statements
+    # @param [Array<RDF::Statement>] unmatched unmatched 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
+    def satisfies?(focus, matched: [], unmatched: [], depth: 0)
+      if implementation = schema.extensions[operands.first.to_s]
+        if matched.empty?
+          implementation.visit(code: operands[1],
+                         expression: parent,
+                              depth: depth) ||
+            not_satisfied("SemAct failed", unmatched: unmatched)
         end
-        $stdout.puts str
-        status str
-        not_satisfied "fail" if md && md[1] == 'fail'
-        true
+        matched.all? do |statement|
+          implementation.visit(code: operands[1],
+                            matched: statement,
+                         expression: parent,
+                              depth: depth)
+        end || not_satisfied("SemAct failed", matched: matched, unmatched: unmatched)
       else
-        status("unknown SemAct name #{operands.first}") {"expression: #{self.to_sxp}"}
+        status("unknown SemAct name #{operands.first}", depth: depth) {"expression: #{self.to_sxp}"}
         false
       end
     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 [void]
+    def exit(code: nil, matched: [], unmatched: [], depth: 0, **options)
+      if implementation = schema.extensions[operands.first.to_s]
+        implementation.exit(code: operands[1],
+                         matched: matched,
+                       unmatched: unmatched,
+                     expresssion: parent,
+                           depth: depth)
+      end
+    end
+
     # Does This operator is SemAct
     def semact?; true; end
   end

data/lib/shex/algebra/shape.rb

@@ -19,13 +19,21 @@ module ShEx::Algebra
     # @return [Array<RDF::Statement>]
     attr_accessor :unmatchables
 
+    ##
+    # 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'] == "Shape"
+      super
+    end
+
     # 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  (see Satisfiable#satisfies?)
     # @return (see Satisfiable#satisfies?)
     # @raise  (see Satisfiable#satisfies?)
-    def satisfies?(focus)
-      expression = operands.detect {|op| op.is_a?(TripleExpression)}
-
+    def satisfies?(focus, depth: 0)
+      expression = self.expression
       # neigh(G, n) is the neighbourhood of the node n in the graph G.
       #
       #    neigh(G, n) = arcsOut(G, n) ∪ arcsIn(G, n)
@@ -34,8 +42,8 @@ module ShEx::Algebra
       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) if expression
+      status("arcsIn: #{arcs_in.count}, arcsOut: #{arcs_out.count}", depth: depth)
+      matched_expression = expression.matches(arcs_in, arcs_out, depth: depth + 1) if expression
       matched = Array(matched_expression && matched_expression.matched)
 
       # `remainder` is the set of unmatched statements
@@ -55,7 +63,7 @@ module ShEx::Algebra
       unmatched = matchables.select do |statement|
         expression.triple_constraints.any? do |expr|
           begin
-            statement.predicate == expr.predicate && expr.matches([statement])
+            statement.predicate == expr.predicate && expr.matches([], [statement], depth: depth + 1)
           rescue ShEx::NotMatched
             false # Expected not to match
           end
@@ -65,7 +73,8 @@ module ShEx::Algebra
         not_satisfied "Statements remain matching TripleConstraints",
                       matched: matched,
                       unmatched: unmatched,
-                      satisfied: expression
+                      satisfied: expression,
+                      depth: depth
       end
 
       # There is no triple in matchables whose predicate does not appear in extra.
@@ -74,30 +83,30 @@ module ShEx::Algebra
         not_satisfied "Statements remains with predicate #{unmatched.map(&:predicate).compact.join(',')} not in extra",
                       matched: matched,
                       unmatched: unmatched,
-                      satisfied: expression
+                      satisfied: expression,
+                      depth: depth
       end
 
       # closed is false or unmatchables is empty.
-      not_satisfied "Unmatchables remain on a closed shape" unless !closed? || unmatchables.empty?
+      not_satisfied "Unmatchables remain on a closed shape", depth: depth 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)
+      semantic_actions.each do |op|
+        op.satisfies?(matched, matched: matched, depth: depth + 1)
       end unless matched.empty?
 
       # FIXME: also record matchables, outs and others?
-      satisfy matched: matched
+      satisfy focus: focus, matched: matched, depth: depth
     rescue ShEx::NotMatched => e
-      not_satisfied e.message, unsatisfied: e.expression
+      not_satisfied e.message, focus: focus, unsatisfied: e.expression, depth: depth
     end
 
+
     ##
-    # Included TripleExpressions
-    # @return [Array<TripleExpressions>]
-    def triple_expressions
-      operands.select {|op| op.is_a?(TripleExpression)}
+    # The optional TripleExpression for this Shape.
+    # @return [TripleExpression]
+    def expression
+      operands.detect {|op| op.is_a?(TripleExpression)}
     end
 
     private