shex 0.3.0 → 0.4.0

data/lib/shex/algebra/or.rb

@@ -1,7 +1,7 @@
 module ShEx::Algebra
   ##
   class Or < Operator
-    include Satisfiable
+    include ShapeExpression
     NAME = :or
 
     def initialize(*args, **options)
@@ -10,8 +10,8 @@ module ShEx::Algebra
         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)}
+      # All arguments must be ShapeExpression
+      raise ArgumentError, "All operands must be Shape operands or resource" unless args.all? {|o| o.is_a?(ShapeExpression) || o.is_a?(RDF::Resource)}
       super
     end
 
@@ -27,22 +27,35 @@ module ShEx::Algebra
 
     #
     # S is a ShapeOr and there is some shape expression se2 in shapeExprs such that satisfies(n, se2, G, m).
-    # @param  (see Satisfiable#satisfies?)
-    # @return (see Satisfiable#satisfies?)
-    # @raise  (see Satisfiable#satisfies?)
+    # @param  (see ShapeExpression#satisfies?)
+    # @return (see ShapeExpression#satisfies?)
+    # @raise  (see ShapeExpression#satisfies?)
     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, depth: depth + 1)
+          matched_op = case op
+          when RDF::Resource
+            schema.enter_shape(op, focus) do |shape|
+              if shape
+                shape.satisfies?(focus, depth: depth + 1)
+              else
+                status "Satisfy as #{op} was re-entered for #{focus}", depth: depth
+                shape
+              end
+            end
+          when ShapeExpression
+            op.satisfies?(focus, depth: depth + 1)
+          end
           return satisfy focus: focus, satisfied: matched_op, depth: depth
         rescue ShEx::NotSatisfied => e
           status "unsatisfied #{focus}", depth: depth
           op = op.dup
-          op.satisfied = e.expression.satisfied
-          op.unsatisfied = e.expression.unsatisfied
+          if op.respond_to?(:satisfied)
+            op.satisfied = e.expression.satisfied
+            op.unsatisfied = e.expression.unsatisfied
+          end
           unsatisfied << op
           status "unsatisfied: #{e.message}", depth: depth
           false
@@ -53,6 +66,26 @@ module ShEx::Algebra
                     focus: focus, unsatisfied: unsatisfied, depth: depth
     end
 
+    ##
+    # expressions must be ShapeExpressions
+    #
+    # @return [Operator] `self`
+    # @raise  [ShEx::StructureError] if the value is invalid
+    def validate!
+      expressions.each do |op|
+        case op
+        when ShapeExpression
+        when RDF::Resource
+          ref = schema.find(op)
+          ref.is_a?(ShapeExpression) ||
+          structure_error("#{json_type} must reference a ShapeExpression: #{ref}")
+        else
+          structure_error("#{json_type} must reference a ShapeExpression: #{ref}")
+        end
+      end
+      super
+    end
+
     def json_type
       "ShapeOr"
     end

data/lib/shex/algebra/schema.rb

@@ -43,12 +43,12 @@ module ShEx::Algebra
     #   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
+    # @option options [String] :base_uri (for resolving focus)
     # @raise [ShEx::NotSatisfied] along with operand graph described for return
     def execute(focus, graph, map, shapeExterns: [], depth: 0, **options)
       @graph, @shapes_entered = graph, {}
       @external_schemas = shapeExterns
-      focus = value(focus)
+      focus = value(focus, options)
 
       logger = options[:logger] || @options[:logger]
       each_descendant do |op|
@@ -66,7 +66,7 @@ module ShEx::Algebra
         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
+      # If `n` is a Blank Node, we won't find it through normal matching, find an equivalent node in the graph having the same id
       graph_focus = graph.enum_term.detect {|t| t.node? && t.id == focus.id} if focus.is_a?(RDF::Node)
       graph_focus ||= focus
 
@@ -89,10 +89,10 @@ module ShEx::Algebra
       satisfied_shapes = {}
       satisfied_schema.operands << [:shapes, satisfied_shapes] unless shapes.empty?
 
-      # 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)
+      # Match against all shapes associated with the ids for focus
+      Array(@map[focus]).each do |id|
+        enter_shape(id, focus) do |shape|
+          satisfied_shapes[id] = shape.satisfies?(graph_focus, depth: depth + 1)
         end
       end
       status "schema satisfied", depth: depth
@@ -131,23 +131,24 @@ module ShEx::Algebra
 
     ##
     # 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] id
     # @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]
+    # @yieldparam [ShapeExpression] shape, or `nil` if shape already entered
+    # @return (see ShapeExpression#satisfies?)
+    # @raise (see ShapeExpression#satisfies?)
+    def enter_shape(id, node, &block)
+      shape = shapes.detect {|s| s.id == id}
+      structure_error("No shape found for #{id}") unless shape
+      @shapes_entered[id] ||= {}
+      if @shapes_entered[id][node]
         block.call(false)
       else
-        @shapes_entered[label][node] = self
+        @shapes_entered[id][node] = self
         begin
           block.call(shape)
         ensure
-          @shapes_entered[label].delete(node)
+          @shapes_entered[id].delete(node)
         end
       end
     end
@@ -174,12 +175,26 @@ module ShEx::Algebra
       @start ||= operands.detect {|op| op.is_a?(Start)}
     end
 
+    ##
+    # Find a ShapeExpression or TripleExpression by identifier
+    # @param [#to_s] id
+    # @return [TripleExpression, ShapeExpression]
+    def find(id)
+      each_descendant.detect {|op| op.id == id}
+    end
+
     ##
     # Validate shapes, in addition to other operands
-    # @return [SPARQL::Algebra::Expression] `self`
+    # @return [Operator] `self`
     # @raise  [ArgumentError] if the value is invalid
     def validate!
-      shapes.each {|op| op.validate! if op.respond_to?(:validate!)}
+      shapes.each do |op|
+        op.validate! if op.respond_to?(:validate!)
+        if op.is_a?(RDF::Resource)
+          ref = find(op)
+          structure_error("Missing reference: #{op}") if ref.nil?
+        end
+      end
       super
     end
   end

data/lib/shex/algebra/shape.rb

@@ -1,7 +1,7 @@
 module ShEx::Algebra
   ##
   class Shape < Operator
-    include Satisfiable
+    include ShapeExpression
     NAME = :shape
 
     ##
@@ -29,11 +29,10 @@ module ShEx::Algebra
     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?)
+    # @param  (see ShapeExpression#satisfies?)
+    # @return (see ShapeExpression#satisfies?)
+    # @raise  (see ShapeExpression#satisfies?)
     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)
@@ -43,7 +42,12 @@ module ShEx::Algebra
 
       # `matched` is the subset of statements which match `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_expression = case expression
+      when RDF::Resource
+        ref.matches(arcs_in, arcs_out, depth: depth + 1)
+      when TripleExpression
+        expression.matches(arcs_in, arcs_out, depth: depth + 1)
+      end
       matched = Array(matched_expression && matched_expression.matched)
 
       # `remainder` is the set of unmatched statements
@@ -101,12 +105,22 @@ module ShEx::Algebra
       not_satisfied e.message, focus: focus, unsatisfied: e.expression, depth: depth
     end
 
-
     ##
-    # The optional TripleExpression for this Shape.
-    # @return [TripleExpression]
-    def expression
-      operands.detect {|op| op.is_a?(TripleExpression)}
+    # expression must be a TripleExpression
+    #
+    # @return [Operator] `self`
+    # @raise  [ShEx::StructureError] if the value is invalid
+    def validate!
+      case expression
+      when nil, TripleExpression
+      when RDF::Resource
+        ref = schema.find(expression)
+        ref.is_a?(TripleExpression) ||
+        structure_error("#{json_type} must reference a TripleExpression: #{ref}")
+      else
+        structure_error("#{json_type} must reference a TripleExpression: #{ref}")
+      end
+      super
     end
 
     private

data/lib/shex/algebra/{satisfiable.rb → shape_expression.rb}

@@ -2,21 +2,18 @@ require 'sparql/algebra'
 
 module ShEx::Algebra
   # Implements `satisfies?` and `not_satisfies?`
-  module Satisfiable
+  module ShapeExpression
     ##
     # Satisfies method
     # @param [RDF::Resource] focus
     # @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
+    # @return [ShapeExpression] 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, depth: 0, **options)
       raise NotImplementedError, "#satisfies? Not implemented in #{self.class}"
     end
-
-    # This operator includes Satisfiable
-    def satisfiable?; true; end
   end
 end

data/lib/shex/algebra/start.rb

@@ -1,20 +1,50 @@
 module ShEx::Algebra
   ##
   class Start < Operator::Unary
-    include Satisfiable
+    include ShapeExpression
     NAME = :start
 
     #
-    # @param  (see Satisfiable#satisfies?)
-    # @return (see Satisfiable#satisfies?)
-    # @raise  (see Satisfiable#satisfies?)
+    # @param  (see ShapeExpression#satisfies?)
+    # @return (see ShapeExpression#satisfies?)
+    # @raise  (see ShapeExpression#satisfies?)
     def satisfies?(focus, depth: 0)
       status "", depth: depth
-      matched_op = operands.first.satisfies?(focus, depth: depth + 1)
+      matched_op = case expression
+      when RDF::Resource
+        schema.enter_shape(expression, focus) do |shape|
+          if shape
+            shape.satisfies?(focus, depth: depth + 1)
+          else
+            status "Satisfy as #{expression} was re-entered for #{focus}", depth: depth
+            nil
+          end
+        end
+      when ShapeExpression
+        expression.satisfies?(focus, depth: depth + 1)
+      end
       satisfy focus: focus, satisfied: matched_op, depth: depth
     rescue ShEx::NotSatisfied => e
       not_satisfied e.message, focus: focus, unsatisfied: e.expression, depth: depth
       raise
     end
+
+    ##
+    # expression must be a ShapeExpression
+    #
+    # @return [Operator] `self`
+    # @raise  [ShEx::StructureError] if the value is invalid
+    def validate!
+      case expression
+      when ShapeExpression
+      when RDF::Resource
+        ref = schema.find(expression)
+        ref.is_a?(ShapeExpression) ||
+        structure_error("#{json_type} must reference a ShapeExpression: #{ref}")
+      else
+        structure_error("#{json_type} must reference a ShapeExpression: #{ref}")
+      end
+      super
+    end
   end
 end

data/lib/shex/algebra/triple_constraint.rb

@@ -29,10 +29,21 @@ module ShEx::Algebra
       statements.select {|st| st.predicate == predicate}.each do |statement|
         break if num_iters == max # matched enough
 
-        value = inverse? ? statement.subject : statement.object
+        focus = inverse? ? statement.subject : statement.object
 
         begin
-          shape && (matched_shape = shape.satisfies?(value, depth: depth + 1))
+          matched_shape = if expression.is_a?(RDF::Resource)
+            schema.enter_shape(expression, focus) do |shape|
+              if shape
+                shape.satisfies?(focus, depth: depth + 1)
+              else
+                status "Satisfy as #{expression} was re-entered for #{focus}", depth: depth
+                nil
+              end
+            end
+          elsif expression
+            expression.satisfies?(focus, depth: depth + 1)
+          end
           status "matched #{statement.to_sxp}", depth: depth
           if matched_shape
             matched_shape.matched = [statement]
@@ -46,7 +57,7 @@ module ShEx::Algebra
           status "not satisfied: #{e.message}", depth: depth
           unsatisfied << e.expression
           statement = statement.dup.extend(ReferencedStatement)
-          statement.referenced = shape
+          statement.referenced = expression
           unmatched << statement
         end
       end
@@ -70,7 +81,25 @@ module ShEx::Algebra
     end
 
     def predicate
-      operands.detect {|o| o.is_a?(RDF::URI)}
+      @predicate ||= operands.detect {|o| o.is_a?(Array) && o.first == :predicate}.last
+    end
+
+    ##
+    # expression must be a ShapeExpression
+    #
+    # @return [Operator] `self`
+    # @raise  [ShEx::StructureError] if the value is invalid
+    def validate!
+      case expression
+      when nil, ShapeExpression
+      when RDF::Resource
+        ref = schema.find(expression)
+        ref.is_a?(ShapeExpression) ||
+        structure_error("#{json_type} must reference a ShapeExpression: #{ref}")
+      else
+        structure_error("#{json_type} must reference a ShapeExpression: #{ref}")
+      end
+      super
     end
 
     ##
@@ -83,9 +112,5 @@ module ShEx::Algebra
     def inverse?
       operands.include?(:inverse)
     end
-
-    def shape
-      operands.detect {|o| o.is_a?(Satisfiable)}
-    end
   end
 end

data/lib/shex/algebra/triple_expression.rb

@@ -53,7 +53,7 @@ module ShEx::Algebra
   end
 
   module ReferencedStatement
-    # @return [ShEx::Algebra::Satisfiable] referenced operand which satisfied some of this statement
+    # @return [ShEx::Algebra::ShapeExpression] referenced operand which satisfied some of this statement
     attr_accessor :referenced
 
     def to_sxp_bin

data/lib/shex/parser.rb

@@ -156,7 +156,10 @@ module ShEx
     production(:shexDoc) do |input, data, callback|
       data[:start] = data[:start] if data[:start]
 
-      expressions = Array(data[:codeDecl])
+      expressions = []
+      expressions << [:base, data[:baseDecl]] if data[:baseDecl]
+      expressions << [:prefix, data[:prefixDecl]] if data[:prefixDecl]
+      expressions += Array(data[:codeDecl])
       expressions << Algebra::Start.new(data[:start]) if data[:start]
       expressions << data[:shapes].unshift(:shapes) if data[:shapes]
 
@@ -168,13 +171,14 @@ module ShEx
 
     # [3]     baseDecl              ::= "BASE" IRIREF
     production(:baseDecl) do |input, data, callback|
-      self.base_uri = iri(data[:iri])
+      input[:baseDecl] = self.base_uri = iri(data[:iri])
     end
 
     # [4]     prefixDecl            ::= "PREFIX" PNAME_NS IRIREF
     production(:prefixDecl) do |input, data, callback|
       pfx = data[:prefix]
       self.prefix(pfx, data[:iri])
+      (input[:prefixDecl] ||= []) << [pfx.to_s, data[:iri]]
     end
 
     # [5]     notStartAction        ::= start | shapeExprDecl
@@ -188,14 +192,14 @@ module ShEx
 
     # [9]     shapeExprDecl         ::= shapeLabel (shapeExpression|"EXTERNAL")
     production(:shapeExprDecl) do |input, data, callback|
-      label = Array(data[:shapeLabel]).first
+      id = Array(data[:shapeLabel]).first
       expression = case data[:shapeExpression]
-      when Algebra::NodeConstraint, Algebra::Or, Algebra::And, Algebra::Not, Algebra::ShapeRef, Algebra::Shape
+      when Algebra::NodeConstraint, Algebra::Or, Algebra::And, Algebra::Not, Algebra::Shape, RDF::Resource
         data[:shapeExpression]
       else
         data[:external] ? Algebra::External.new() : Algebra::Shape.new()
       end
-      expression.label = label
+      expression.id = id if id && !expression.is_a?(RDF::Resource)
 
       (input[:shapes] ||= []) << expression
     end
@@ -214,7 +218,7 @@ module ShEx
     def shape_or(input, data)
       input.merge!(data.dup.keep_if {|k, v| [:closed, :extraPropertySet, :codeDecl].include?(k)})
       expression = if Array(data[:shapeExpression]).length > 1
-        Algebra::Or.new(*data[:shapeExpression])
+        Algebra::Or.new(*data[:shapeExpression], {})
       else
         Array(data[:shapeExpression]).first
       end
@@ -238,7 +242,7 @@ module ShEx
         memo.concat(expr.is_a?(Algebra::And) ? expr.operands : [expr])
       end
       expression = if expressions.length > 1
-        Algebra::And.new(*expressions)
+        Algebra::And.new(*expressions, {})
       else
         expressions.first
       end
@@ -287,9 +291,8 @@ module ShEx
       expression = [constraint, shape].compact
       expression = case expression.length
       when 0 then nil
-      when 1
-         expression.first
-      else   Algebra::And.new(*expression)
+      when 1 then expression.first
+      else        Algebra::And.new(*expression, {})
       end
 
       input[:shapeExpression] = expression if expression
@@ -307,7 +310,7 @@ module ShEx
     def shape_or_ref(input, data)
       input.merge!(data.dup.keep_if {|k, v| [:closed, :extraPropertySet, :codeDecl].include?(k)})
       if data[:shape] || Array(data[:shapeLabel]).first
-        input[:shapeOrRef] = data[:shape] || Algebra::ShapeRef.new(Array(data[:shapeLabel]).first)
+        input[:shapeOrRef] = data[:shape] || Array(data[:shapeLabel]).first
       end
     rescue ArgumentError => e
       error(nil, "Argument Error on ShapeOrRef: #{e.message}")
@@ -335,7 +338,7 @@ module ShEx
       attrs += Array(data[:numericFacet])
       attrs += Array(data[:stringFacet])
 
-      input[:nodeConstraint] = Algebra::NodeConstraint.new(*attrs.compact)
+      input[:nodeConstraint] = Algebra::NodeConstraint.new(*attrs.compact, {})
     end
 
     # [23]    nonLiteralKind        ::= "IRI" | "BNODE" | "NONLITERAL"
@@ -390,7 +393,7 @@ module ShEx
       attrs += Array(data[:annotation])
       attrs += Array(data[:codeDecl])
 
-      input[:shape] = Algebra::Shape.new(*attrs) if expression
+      input[:shape] = Algebra::Shape.new(*attrs, {}) if expression
     end
     private :shape_definition
 
@@ -403,7 +406,7 @@ module ShEx
     # [34]    oneOfTripleExpr           ::= groupTripleExpr ('|' groupTripleExpr)*
     production(:oneOfTripleExpr) do |input, data, callback|
       expression = if Array(data[:tripleExpression]).length > 1
-        Algebra::OneOf.new(*data[:tripleExpression])
+        Algebra::OneOf.new(*data[:tripleExpression], {})
       else
         Array(data[:tripleExpression]).first
       end
@@ -413,7 +416,7 @@ module ShEx
     # [37]    groupTripleExpr            ::= unaryTripleExpr (';' unaryTripleExpr?)*
     production(:groupTripleExpr) do |input, data, callback|
       expression = if Array(data[:tripleExpression]).length > 1
-        Algebra::EachOf.new(*data[:tripleExpression])
+        Algebra::EachOf.new(*data[:tripleExpression], {})
       else
         Array(data[:tripleExpression]).first
       end
@@ -423,7 +426,7 @@ module ShEx
     # [40]    unaryTripleExpr            ::= productionLabel? (tripleConstraint | bracketedTripleExpr) | include
     production(:unaryTripleExpr) do |input, data, callback|
       expression = data[:tripleExpression]
-      expression.label = data[:productionLabel] if expression && data[:productionLabel]
+      expression.id = data[:productionLabel] if expression && data[:productionLabel]
 
       (input[:tripleExpression] ||= []) << expression if expression
     end
@@ -458,7 +461,7 @@ module ShEx
       cardinality = data.fetch(:cardinality, {})
       attrs = [
         (:inverse if data[:inverse] || data[:not]),
-        Array(data[:predicate]).first,  # predicate
+        [:predicate, Array(data[:predicate]).first],
         data[:shapeExpression],
         ([:min, cardinality[:min]] if cardinality[:min]),
         ([:max, cardinality[:max]] if cardinality[:max])
@@ -466,7 +469,7 @@ module ShEx
       attrs += Array(data[:codeDecl])
       attrs += Array(data[:annotation])
 
-      input[:tripleExpression] = Algebra::TripleConstraint.new(*attrs) unless attrs.empty?
+      input[:tripleExpression] = Algebra::TripleConstraint.new(*attrs, {}) unless attrs.empty?
     end
 
     # [44]    cardinality            ::= '*' | '+' | '?' | REPEAT_RANGE
@@ -499,12 +502,12 @@ module ShEx
 
     # [50]     include               ::= '&' shapeLabel
     production(:include) do |input, data, callback|
-      input[:tripleExpression] = Algebra::Inclusion.new(*data[:shapeLabel])
+      input[:tripleExpression] = data[:shapeLabel].first
     end
 
     # [51]    annotation            ::= '//' predicate (iri | literal)
     production(:annotation) do |input, data, callback|
-      annotation = Algebra::Annotation.new(data[:predicate].first, (data[:iri] || data[:literal]))
+      annotation = Algebra::Annotation.new([:predicate, data[:predicate].first], (data[:iri] || data[:literal]))
       (input[:annotation] ||= []) << annotation
     end
 
@@ -512,7 +515,7 @@ module ShEx
 
     # [53]    codeDecl              ::= '%' iri (CODE | "%")
     production(:codeDecl) do |input, data, callback|
-      (input[:codeDecl] ||= []) <<  Algebra::SemAct.new(*[data[:iri], data[:code]].compact)
+      (input[:codeDecl] ||= []) <<  Algebra::SemAct.new(*[data[:iri], data[:code]].compact, {})
     end
 
     # [13t]   literal               ::= rdfLiteral | numericLiteral | booleanLiteral
@@ -662,7 +665,7 @@ module ShEx
       @result.validate! if @result && validate?
       @result
     rescue EBNF::LL1::Parser::Error, EBNF::LL1::Lexer::Error =>  e
-      raise ShEx::ParseError.new(e.message, lineno: e.lineno, token: e.token)
+      raise ShEx::ParseError, e.message, e.backtrace
     end
 
     private