shex 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a8b0ba57a643b21c61dc3ddb8a7b49323c39bc1f
-  data.tar.gz: 82bdcc8715f967354d09e1990f801806778c39b6
+  metadata.gz: 3ba75ebd8c6632f82452b8cc6a19dbe69e86258d
+  data.tar.gz: a924845f0d0ffd7caa35926b98829345ee3d427a
 SHA512:
-  metadata.gz: 6828f94a4e12c8d344ded59c69ec16e3c1f01990ea53110a1f21f1382eca27a2a1bdb53fa32e61e8c7095f2bdf0d74feb5c60f09e26b93b0626daad690171535
-  data.tar.gz: 6ad0d4ae5c64c2d8076b270f0861749410a983ba2525db7fcabef7b405394af1432fcb63f08f625c75114e8bc8bd11da335e563560aed84290327a0cfb938e37
+  metadata.gz: 1e844351dfd63a5c158a088b6d83375e3f96382d1a56c3e7aaa8e037f4c3ae380bac4f04d1da9db3727053400563b96565d291cb7537974c920df636bf7d3614
+  data.tar.gz: 3797b22ce44300b723770608ee42a3fd03418f0c8497e4a370fdf960f47ad324c67b07ec061ca498a8fa2d683b97a4fab7c95ced34123840e2c968120e162418

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/lib/shex.rb

@@ -1,5 +1,3 @@
-require 'sparql/extensions'
-
 ##
 # A ShEx runtime for RDF.rb.
 #
@@ -20,16 +18,16 @@ module ShEx
   #   ).parse
   #
   # @param  [IO, StringIO, String, #to_s]  expression (ShExC or ShExJ)
-  # @param  ['shexc', 'shexj', 'sse']  format ('shexc')
+  # @param  ['shexc', 'shexj', 'sxp']  format ('shexc')
   # @param  [Hash{Symbol => Object}] options
-  # @return [ShEx::Algebra::Schema] The executable parsed expression.
-  # @raise [ShEx::ParseError] when a syntax error is detected
-  # @raise [ShEx::StructureError, ArgumentError] on structural problems with schema
+  # @option (see ShEx::Parser#initialize)
+  # @return (see ShEx::Parser#parse)
+  # @raise  (see ShEx::Parser#parse)
   def self.parse(expression, format: 'shexc', **options)
     case format
     when 'shexc' then Parser.new(expression, options).parse
     when 'shexj'
-    when 'sse'
+    when 'sxp'
     else raise "Unknown expression format: #{format.inspect}"
     end
   end
@@ -41,15 +39,10 @@ module ShEx
   #   schema = ShEx.parse('foo.shex').parse
   #
   # @param  [String, #to_s] filename
-  # @param  ['shexc', 'shexj', 'sse']  format ('shexc')
-  # @param  [Hash{Symbol => Object}] options
-  #   any additional options (see `RDF::Reader#initialize` and `RDF::Format.for`)
-  # @yield  [ShEx::Algebra::Schema]
-  # @yieldparam  [RDF::Reader] reader
-  # @yieldreturn [void] ignored
-  # @return [ShEx::Algebra::Schema] The executable parsed expression.
-  # @raise [ShEx::ParseError] when a syntax error is detected
-  # @raise [ShEx::StructureError, ArgumentError] on structural problems with schema
+  # @param  (see parse)
+  # @option (see ShEx::Parser#initialize)
+  # @return (see ShEx::Parser#parse)
+  # @raise  (see ShEx::Parser#parse)
   def self.open(filename, format: 'shexc', **options, &block)
     RDF::Util::File.open_file(filename, options) do |file|
       self.parse(file, options.merge(format: format))
@@ -64,18 +57,31 @@ module ShEx
   #   ShEx.execute('etc/doap.shex', graph, "http://rubygems.org/gems/shex", "")
   #
   # @param [IO, StringIO, String, #to_s]  expression (ShExC or ShExJ)
-  # @param [RDF::Resource] focus
-  # @param [RDF::Resource] shape
-  # @param ['shexc', 'shexj', 'sse']  format ('shexc')
-  # @param [Hash{Symbol => Object}] options
-  # @return [Boolean] `true` if satisfied, `false` if it does not apply
-  # @raise [ShEx::NotSatisfied] if not satisfied
-  # @raise [ShEx::ParseError] when a syntax error is detected
-  # @raise [ShEx::StructureError, ArgumentError] on structural problems with schema
+  # @param (see ShEx::Algebra::Schema#execute)
+  # @return (see ShEx::Algebra::Schema#execute)
+  # @raise (see ShEx::Algebra::Schema#execute)
   def self.execute(expression, queryable, focus, shape, format: 'shexc', **options)
     shex = self.parse(expression, options.merge(format: format))
     queryable = queryable || RDF::Graph.new
 
+    shex.execute(focus, queryable, {focus => shape}, options)
+  end
+
+  ##
+  # Parse and validate the given ShEx `expression` string against `queriable`.
+  #
+  # @example executing a ShExC schema
+  #   graph = RDF::Graph.load("etc/doap.ttl")
+  #   ShEx.execute('etc/doap.shex', graph, "http://rubygems.org/gems/shex", "")
+  #
+  # @param [IO, StringIO, String, #to_s]  expression (ShExC or ShExJ)
+  # @param (see ShEx::Algebra::Schema#satisfies?)
+  # @return (see ShEx::Algebra::Schema#satisfies?)
+  # @raise (see ShEx::Algebra::Schema#satisfies?)
+  def self.satisfies?(expression, queryable, focus, shape, format: 'shexc', **options)
+    shex = self.parse(expression, options.merge(format: format))
+    queryable = queryable || RDF::Graph.new
+
     shex.satisfies?(focus, queryable, {focus => shape}, options)
   end
 
@@ -100,7 +106,48 @@ module ShEx
   class StructureError < Error; end
 
   # Shape expectation not satisfied
-  class NotSatisfied < Error; end
+  class NotSatisfied < Error
+    ##
+    # The expression which was not satified
+    # @return [ShEx::Satisfiable]
+    attr_reader :expression
+
+    ##
+    # Initializes a new parser error instance.
+    #
+    # @param  [String, #to_s]          message
+    # @param  [Satisfiable]            expression (self)
+    def initialize(message, expression: self)
+      @expression = expression
+      super(message.to_s)
+    end
+
+    def inspect
+      super + (expression ? SXP::Generator.string(expression.to_sxp_bin) : '')
+    end
+  end
+
+  # TripleExpression did not match
+  class NotMatched < ShEx::Error
+    ##
+    # The expression which was not satified
+    # @return [ShEx::Algebra::TripleExpression]
+    attr_reader :expression
+
+    ##
+    # Initializes a new parser error instance.
+    #
+    # @param  [String, #to_s]          message
+    # @param  [Satisfiable]            expression (self)
+    def initialize(message, expression: self)
+      @expression = expression
+      super(message.to_s)
+    end
+
+    def inspect
+      super + (expression ? SXP::Generator.string(expression.to_sxp_bin) : '')
+    end
+  end
 
   # Indicates bad syntax found in LD Patch document
   class ParseError < Error
@@ -117,17 +164,16 @@ module ShEx
     attr_reader :lineno
 
     ##
-    # Initializes a new parser error instance.
+    # ParseError includes `token` and `lineno` associated with the expression.
     #
     # @param  [String, #to_s]          message
     # @param  [Hash{Symbol => Object}] options
-    # @option options [String]         :token  (nil)
-    # @option options [Integer]        :lineno (nil)
-    # @option options [Integer]        :code (400)
-    def initialize(message, options = {})
-      @token      = options[:token]
-      @lineno     = options[:lineno] || (@token.lineno if @token.respond_to?(:lineno))
-      super(message.to_s, code: options.fetch(:code, 400))
+    # @param [String]                  token  (nil)
+    # @param [Integer]                 lineno (nil)
+    def initialize(message, token: nil, lineno: nil)
+      @token      = token
+      @lineno     = lineno || (@token.lineno if @token.respond_to?(:lineno))
+      super(message.to_s)
     end
   end
 end

data/lib/shex/algebra.rb

@@ -31,8 +31,6 @@ module ShEx
     autoload :TripleExpression, 'shex/algebra/triple_expression'
     autoload :UnaryShape, 'shex/algebra/unary_shape'
     autoload :Value, 'shex/algebra/value'
-
-    class NotMatched < ShEx::Error; end
   end
 end
 

data/lib/shex/algebra/and.rb

@@ -14,19 +14,23 @@ module ShEx::Algebra
 
     #
     # S is a ShapeAnd and for every shape expression se2 in shapeExprs, satisfies(n, se2, G, m).
-    # @param [RDF::Resource] n
-    # @return [Boolean] `true` when satisfied
-    # @raise [ShEx::NotSatisfied] if not satisfied
-    def satisfies?(n)
+    # @param  (see Satisfiable#satisfies?)
+    # @return (see Satisfiable#satisfies?)
+    # @raise  (see Satisfiable#satisfies?)
+    def satisfies?(focus)
       status ""
+      expressions = operands.select {|o| o.is_a?(Satisfiable)}
+      satisfied = []
 
       # Operand raises NotSatisfied, so no need to check here.
-      operands.select {|o| o.is_a?(Satisfiable)}.each {|op| op.satisfies?(n)}
-      status("satisfied")
-      true
+      expressions.each do |op|
+        satisfied << op.satisfies?(focus)
+      end
+      satisfy satisfied: satisfied
     rescue ShEx::NotSatisfied => e
-      not_satisfied(e.message)
-      raise
+      not_satisfied e.message,
+                    satisfied:   satisfied,
+                    unsatisfied: (expressions - satisfied)
     end
   end
 end

data/lib/shex/algebra/each_of.rb

@@ -7,47 +7,55 @@ module ShEx::Algebra
     ##
     # expr is an EachOf and there is some partition of T into T1, T2,… such that for every expression expr1, expr2,… in shapeExprs, matches(Tn, exprn, m)...
     #
-    # @param [Array<RDF::Statement>] t
+    # @param [Array<RDF::Statement>] statements
     # @return [Array<RDF::Statement>]
-    # @raise NotMatched, ShEx::NotSatisfied
-    def matches(t)
+    # @raise [ShEx::NotMatched]
+    def matches(statements)
       status ""
-      results = []
-      statements = t.dup
-      num_iters = 0
-      max = maximum
+      results, satisfied, unsatisfied = [], [], []
+      num_iters, max = 0, maximum
 
       while num_iters < max
         begin
           matched_this_iter = []
           operands.select {|o| o.is_a?(TripleExpression)}.all? do |op|
-            matched = op.matches(statements - matched_this_iter)
-            matched_this_iter += matched
+            begin
+              matched_op = op.matches(statements - matched_this_iter)
+              satisfied << matched_op
+              matched_this_iter += matched_op.matched
+            rescue ShEx::NotMatched => e
+              status "not matched: #{e.message}"
+              op = op.dup
+              op.unmatched = statements - matched_this_iter
+              unsatisfied << op
+              raise
+            end
           end
           results += matched_this_iter
           statements -= matched_this_iter
           num_iters += 1
           status "matched #{results.length} statements after #{num_iters} iterations"
-        rescue NotMatched => e
-          log_recover("eachOf: ignore error: #{e.message}", depth: options.fetch(:depth, 0))
+        rescue ShEx::NotMatched => e
+          status "no match after #{num_iters} iterations (ignored)"
           break
         end
       end
 
       # Max violations handled in Shape
-      not_matched "Minimum Cardinality Violation: #{num_iters} < #{minimum}" if
-        num_iters < minimum
+      if num_iters < minimum
+        raise ShEx::NotMatched, "Minimum Cardinality Violation: #{results.length} < #{minimum}"
+      end
 
       # Last, evaluate semantic acts
       semantic_actions.all? do |op|
         op.satisfies?(results)
       end unless results.empty?
 
-      status "each of satisfied"
-      results
-    rescue NotMatched => e
-      not_matched(e.message)
-      raise
+      satisfy matched: results, satisfied: satisfied
+    rescue ShEx::NotMatched, ShEx::NotSatisfied => e
+      not_matched e.message,
+                  matched:   results,   unmatched:   (statements - results),
+                  satisfied: satisfied, unsatisfied: unsatisfied
     end
   end
 end

data/lib/shex/algebra/external.rb

@@ -6,7 +6,7 @@ module ShEx::Algebra
 
     #
     # S is a ShapeRef and the Schema's shapes maps reference to a shape expression se2 and satisfies(n, se2, G, m).
-    def satisfies?(n)
+    def satisfies?(focus)
       extern_shape = nil
 
       # Find the label for this external
@@ -18,7 +18,7 @@ module ShEx::Algebra
       end
 
       not_satisfied("External not configured for this shape") unless extern_shape
-      extern_shape.satisfies?(n)
+      extern_shape.satisfies?(focus)
     end
   end
 end

data/lib/shex/algebra/inclusion.rb

@@ -12,20 +12,17 @@ module ShEx::Algebra
     ##
     # In this case, we accept an array of statements, and match based on cardinality.
     #
-    # @param [Array<RDF::Statement>] t
+    # @param [Array<RDF::Statement>] statements
     # @return [Array<RDF::Statement>]
-    # @raise NotMatched, ShEx::NotSatisfied
-    def matches(t)
+    # @raise [ShEx::NotMatched]
+    def matches(statements)
       status "referenced_shape: #{operands.first}"
       expression = referenced_shape.triple_expressions.first
       max = maximum
-      results = expression.matches(t)
-
-      # Max violations handled in Shape
-      not_matched "Minimum Cardinality Violation: #{results.length} < #{minimum}" if
-        results.length < minimum
-
-      results
+      matched_expression = expression.matches(statements)
+      satisfy matched: matched_expression.matched
+    rescue ShEx::NotMatched => e
+      not_matched e.message, unsatisfied: e.expression
     end
 
     ##

data/lib/shex/algebra/node_constraint.rb

@@ -5,17 +5,18 @@ module ShEx::Algebra
     NAME = :nodeConstraint
 
     #
-    # S is a NodeConstraint and satisfies2(n, se) as described below in Node Constraints. Note that testing if a node satisfies a node constraint does not require a graph or shapeMap.
-    # @param [RDF::Resource] n
-    # @return [Boolean] `true` if satisfied, `false` if it does not apply
-    # @raise [ShEx::NotSatisfied] if not satisfied
-    def satisfies?(n)
+    # S is a NodeConstraint and satisfies2(focus, se) as described below in Node Constraints. Note that testing if a node satisfies a node constraint does not require a graph or shapeMap.
+    # @param  (see Satisfiable#satisfies?)
+    # @return (see Satisfiable#satisfies?)
+    # @raise  (see Satisfiable#satisfies?)
+    def satisfies?(focus)
       status ""
-      satisfies_node_kind?(n) &&
-      satisfies_datatype?(n) &&
-      satisfies_string_facet?(n) &&
-      satisfies_numeric_facet?(n) &&
-      satisfies_values?(n)
+      satisfies_node_kind?(focus) &&
+      satisfies_datatype?(focus) &&
+      satisfies_string_facet?(focus) &&
+      satisfies_numeric_facet?(focus) &&
+      satisfies_values?(focus) &&
+      satisfy
     end
 
   private

data/lib/shex/algebra/not.rb

@@ -6,14 +6,18 @@ module ShEx::Algebra
 
     #
     # S is a ShapeNot and for the shape expression se2 at shapeExpr, notSatisfies(n, se2, G, m).
-    # @param [RDF::Resource] n
-    # @return [Boolean] `true` when satisfied, meaning that the operand was not satisfied
-    # @raise [ShEx::NotSatisfied] if not satisfied, meaning that the operand was satisfied
-    def satisfies?(n)
+    # @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 ""
-      operands.last.not_satisfies?(n)
-      status "not satisfied"
-      true
+      satisfied_op = begin
+        operands.first.satisfies?(focus)
+      rescue ShEx::NotSatisfied => e
+        return satisfy satisfied: e.expression.unsatisfied
+      end
+      not_satisfied "Expression should not have matched", unsatisfied: satisfied_op
     end
   end
 end

data/lib/shex/algebra/one_of.rb

@@ -7,25 +7,27 @@ module ShEx::Algebra
     ##
     # `expr` is a OneOf and there is some shape expression `se2` in shapeExprs such that a `matches(T, se2, m)`...
     #
-    # @param [Array<RDF::Statement>] t
+    # @param [Array<RDF::Statement>] statements
     # @return [Array<RDF::Statement]
-    def matches(t)
-      results = []
-      statements = t.dup
-      num_iters = 0
-      max = maximum
+    def matches(statements)
+      results, satisfied, unsatisfied = [], [], []
+      num_iters, max = 0, maximum
 
       # OneOf is greedy, and consumes triples from every sub-expression, although only one is requred it succeed. Cardinality is somewhat complicated, as if two expressions match, this works for either a cardinality of one or two. Or two passes with just one match on each pass.
       status ""
       while num_iters < max
         matched_something = operands.select {|o| o.is_a?(TripleExpression)}.any? do |op|
           begin
-            matched = op.matches(statements)
-            results += matched
-            statements -= matched
-            status "matched #{t.first.to_sxp}"
-          rescue NotMatched => e
-            log_recover("oneOf: ignore error: #{e.message}", depth: options.fetch(:depth, 0))
+            matched_op = op.matches(statements)
+            satisfied << matched_op
+            results += matched_op.matched
+            statements -= matched_op.matched
+            status "matched #{matched_op.matched.to_sxp}"
+          rescue ShEx::NotMatched => e
+            status "not matched: #{e.message}"
+            op = op.dup
+            op.unmatched = statements - results
+            unsatisfied << op
             false
           end
         end
@@ -35,16 +37,20 @@ module ShEx::Algebra
       end
 
       # Max violations handled in Shape
-      not_matched "Minimum Cardinality Violation: #{num_iters} < #{minimum}" if
-        num_iters < minimum
+      if num_iters < minimum
+        raise ShEx::NotMatched, "Minimum Cardinality Violation: #{results.length} < #{minimum}"
+      end
 
       # Last, evaluate semantic acts
       semantic_actions.all? do |op|
         op.satisfies?(results)
       end unless results.empty?
 
-      status "one of satisfied"
-      results
+      satisfy matched: results, satisfied: satisfied, unsatisfied: unsatisfied
+    rescue ShEx::NotMatched, ShEx::NotSatisfied => e
+      not_matched e.message,
+                  matched:   results,   unmatched:   (statements - results),
+                  satisfied: satisfied, unsatisfied: unsatisfied
     end
   end
 end

data/lib/shex/algebra/operator.rb

@@ -1,5 +1,4 @@
 require 'sparql/algebra'
-require 'sparql/extensions'
 
 module ShEx::Algebra
 
@@ -86,18 +85,86 @@ module ShEx::Algebra
     # Does this operator a SemAct?
     def semact?; false; end
 
+    ##
+    # On a result instance, the statements that matched this expression.
+    # @return [Array<Statement>]
+    def matched
+      Array((operands.detect {|op| op.is_a?(Array) && op[0] == :matched} || [:matched])[1..-1])
+    end
+    def matched=(statements)
+      operands.delete_if {|op| op.is_a?(Array) && op[0] == :matched}
+      operands << statements.unshift(:matched) unless (statements || []).empty?
+    end
+
+    ##
+    # On a result instance, the statements that did not match this expression (failure only).
+    # @return [Array<Statement>]
+    def unmatched
+      Array((operands.detect {|op| op.is_a?(Array) && op[0] == :unmatched} || [:unmatched])[1..-1])
+    end
+    def unmatched=(statements)
+      operands.delete_if {|op| op.is_a?(Array) && op[0] == :unmatched}
+      operands << statements.unshift(:unmatched) unless (statements || []).empty?
+    end
+
+    ##
+    # On a result instance, the sub-expressions which were matched.
+    # @return [Array<Operator>]
+    def satisfied
+      Array((operands.detect {|op| op.is_a?(Array) && op[0] == :satisfied} || [:satisfied])[1..-1])
+    end
+    def satisfied=(ops)
+      operands.delete_if {|op| op.is_a?(Array) && op[0] == :satisfied}
+      operands << ops.unshift(:satisfied) unless (ops || []).empty?
+    end
+
+    ##
+    # On a result instance, the sub-satisfieables which were not satisfied. (failure only).
+    # @return [Array<Operator>]
+    def unsatisfied
+      Array((operands.detect {|op| op.is_a?(Array) && op[0] == :unsatisfied} || [:unsatisfied])[1..-1])
+    end
+    def unsatisfied=(ops)
+      operands.delete_if {|op| op.is_a?(Array) && op[0] == :unsatisfied}
+      operands << ops.unshift(:unsatisfied) unless (ops || []).empty?
+    end
+
+    ##
+    # Duplication this operand, and add `matched`, `unmatched`, `satisfied`, and `unsatisfied` operands for accessing downstream.
+    #
+    # @return [Operand]
+    def satisfy(matched: nil, unmatched: nil, satisfied: nil, unsatisfied: nil)
+      log_debug(self.class.const_get(:NAME), "satisfied", depth: options.fetch(:depth, 0))
+      expression = self.dup
+      expression.matched = Array(matched) if matched
+      expression.unmatched = Array(unmatched) if unmatched
+      expression.satisfied = Array(satisfied) if satisfied
+      expression.unsatisfied = Array(unsatisfied) if unsatisfied
+      expression
+    end
+
     ##
     # Exception handling
-    def not_matched(message, **opts)
-      expression = opts.fetch(:expression, self)
-      exception = opts.fetch(:exception, NotMatched)
-      log_error(message, depth: options.fetch(:depth, 0), exception: exception) {"expression: #{expression.to_sxp}"}
+    def not_matched(message, matched: nil, unmatched: nil, satisfied: nil, unsatisfied: nil, **opts, &block)
+      expression = opts.fetch(:expression, self).satisfy(
+        matched:     matched,
+        unmatched:   unmatched,
+        satisfied:   satisfied,
+        unsatisfied: unsatisfied)
+      exception = opts.fetch(:exception, ShEx::NotMatched)
+      status(message) {(block_given? ? block.call : "") + "expression: #{expression.to_sxp}"}
+      raise exception.new(message, expression: expression)
     end
 
-    def not_satisfied(message, **opts)
-      expression = opts.fetch(:expression, self)
+    def not_satisfied(message, matched: nil, unmatched: nil, satisfied: nil, unsatisfied: nil, **opts)
+      expression = opts.fetch(:expression, self).satisfy(
+        matched:     matched,
+        unmatched:   unmatched,
+        satisfied:   satisfied,
+        unsatisfied: unsatisfied)
       exception = opts.fetch(:exception, ShEx::NotSatisfied)
-      log_error(message, depth: options.fetch(:depth, 0), exception: exception) {"expression: #{expression.to_sxp}"}
+      status(message) {(block_given? ? block.call : "") + "expression: #{expression.to_sxp}"}
+      raise exception.new(message, expression: expression)
     end
 
     def structure_error(message, **opts)
@@ -107,7 +174,7 @@ module ShEx::Algebra
     end
 
     def status(message, &block)
-      log_info(self.class.const_get(:NAME), message, depth: options.fetch(:depth, 0), &block)
+      log_debug(self.class.const_get(:NAME), message, depth: options.fetch(:depth, 0), &block)
       true
     end
 
@@ -128,10 +195,10 @@ module ShEx::Algebra
     end
 
     ##
-    # Returns the SPARQL S-Expression (SSE) representation of this operator.
+    # Returns the binary S-Expression (SXP) representation of this operator.
     #
     # @return [Array]
-    # @see    http://openjena.org/wiki/SSE
+    # @see    https://en.wikipedia.org/wiki/S-expression
     def to_sxp_bin
       operator = [self.class.const_get(:NAME)].flatten.first
       [operator, *(operands || []).map(&:to_sxp_bin)]

data/lib/shex/algebra/or.rb

@@ -14,24 +14,30 @@ module ShEx::Algebra
 
     #
     # 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|
+    # @param  (see Satisfiable#satisfies?)
+    # @return (see Satisfiable#satisfies?)
+    # @raise  (see Satisfiable#satisfies?)
+    def satisfies?(focus)
+      status ""
+      expressions = operands.select {|o| o.is_a?(Satisfiable)}
+      unsatisfied = []
+      expressions.any? do |op|
         begin
-          op.satisfies?(n)
-          status "satisfied #{n}"
-          return true
+          matched_op = op.satisfies?(focus)
+          return satisfy satisfied: matched_op, unsatisfied: unsatisfied
         rescue ShEx::NotSatisfied => e
-          log_recover("or: ignore error: #{e.message}", depth: options.fetch(:depth, 0))
-          any_not_satisfied = e
+          status "unsatisfied #{focus}"
+          op = op.dup
+          op.satisfied = e.expression.satisfied
+          op.unsatisfied = e.expression.unsatisfied
+          unsatisfied << op
+          status("unsatisfied: #{e.message}")
           false
         end
       end
 
-      not_satisfied "Expected some expression to be satisfied"
+      not_satisfied "Expected some expression to be satisfied",
+                    unsatisfied: unsatisfied
     end
   end
 end

data/lib/shex/algebra/satisfiable.rb

@@ -1,36 +1,18 @@
 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
+    # @param [RDF::Resource] focus
+    # @return [TripleExpression] 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?(n)
+    def satisfies?(focus)
       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>]

data/lib/shex/algebra/schema.rb

@@ -1,7 +1,6 @@
 module ShEx::Algebra
   ##
   class Schema < Operator
-    include Satisfiable
     NAME = :schema
 
     # Graph to validate
@@ -15,46 +14,69 @@ module ShEx::Algebra
     ##
     # 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 [RDF::Resource] 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 [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
+    # @return [Operand] Returns operand graph annotated with satisfied and unsatisfied operations.
+    # @raise [ShEx::NotSatisfied] along with operand graph described for return
+    def execute(focus, graph, map, shapeExterns: [], **options)
+      @graph = graph
       @external_schemas = shapeExterns
+      focus = iri(focus)
       # Make sure they're URIs
-      @map = m.inject({}) {|memo, (k,v)| memo.merge(k.to_s => v.to_s)}
+      @map = (map || {}).inject({}) {|memo, (k,v)| memo.merge(iri(k).to_s => iri(v).to_s)}
 
       # First, evaluate semantic acts
       semantic_actions.all? do |op|
         op.satisfies?([])
       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}"}
-        start.satisfies?(n)
+        satisfied_schema.operands << start.satisfies?(focus)
       end
 
-      label = @map[n.to_s]
+      # 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 n.is_a?(RDF::Node)
-          nn = graph.enum_term.detect {|t| t.id == n.id}
-          n = nn if nn
+        if focus.is_a?(RDF::Node)
+          n = graph.enum_term.detect {|t| t.id == focus.id}
+          focus = n if n
         end
 
-        shape.satisfies?(n)
+        satisfied_shapes[label] = shape.satisfies?(focus)
       end
       status "schema satisfied"
-      true
+      satisfied_schema
+    end
+
+    ##
+    # Match on schema. Finds appropriate shape for node, and matches that shape.
+    #
+    # @param [RDF::Resource] 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.
+    # @param [Hash{Symbol => Object}] options
+    # @option options [String] :base_uri
+    # @return [Boolean]
+    def satisfies?(focus, graph, map, shapeExterns: [], **options)
+      execute(focus, graph, map, options.merge(shapeExterns: shapeExterns))
+    rescue ShEx::NotSatisfied
+      false
     end
 
     ##
@@ -62,8 +84,7 @@ module ShEx::Algebra
     # @return [Hash{RDF::Resource => Operator}]
     def shapes
       @shapes ||= begin
-        shapes = operands.
-        detect {|op| op.is_a?(Array) && op.first == :shapes}
+        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)
@@ -107,6 +128,34 @@ module ShEx::Algebra
       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

data/lib/shex/algebra/shape.rb

@@ -4,59 +4,77 @@ module ShEx::Algebra
     include Satisfiable
     NAME = :shape
 
-    #
+    ##
+    # Let `outs` be the `arcsOut` in `remainder`: `outs = remainder ∩ arcsOut(G, n)`.
+    # @return [Array<RDF::Statement>]
+    attr_accessor :outs
+
+    ##
+    # Let `matchables` be the triples in `outs` whose predicate appears in a {TripleConstraint} in `expression`. If `expression` is absent, `matchables = Ø` (the empty set).
+    # @return [Array<RDF::Statement>]
+    attr_accessor :matchables
+
+    ##
+    # Let `unmatchables` be the triples in `outs` which are not in `matchables`. `matchables ∪ unmatchables = outs.`
+    # @return [Array<RDF::Statement>]
+    attr_accessor :unmatchables
+
     # 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)
+    # @param  (see Satisfiable#satisfies?)
+    # @return (see Satisfiable#satisfies?)
+    # @raise  (see Satisfiable#satisfies?)
+    def satisfies?(focus)
       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)
+      arcs_in = schema.graph.query(object: focus).to_a.sort_by(&:to_sxp)
+      arcs_out = schema.graph.query(subject: focus).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) : []
+      matched_expression = expression.matches(neigh) if expression
+      matched = Array(matched_expression && matched_expression.matched)
 
       # `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}
+      @outs = remainder.select {|s| s.subject == focus}
 
       # 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)}
+      @matchables = outs.select {|s| predicates.include?(s.predicate)}
+
+      # Let `unmatchables` be the triples in `outs` which are not in `matchables`.
+      @unmatchables = outs - matchables
 
       # No matchable can be matched by any TripleConstraint in expression
-      matchables.each do |statement|
-        expression.triple_constraints.each do |expr|
+      unmatched = matchables.select do |statement|
+        expression.triple_constraints.any? 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
+            statement.predicate == expr.predicate && expr.matches([statement])
+          rescue ShEx::NotMatched
+            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
+        end if expression
+      end
+      unless unmatched.empty?
+        not_satisfied "Statements remain matching TripleConstraints",
+                      matched: matched,
+                      unmatched: unmatched,
+                      satisfied: expression
+      end
 
       # 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)
+      unmatched = matchables.reject {|st| extra.include?(st.predicate)}
+      unless unmatched.empty?
+        not_satisfied "Statements remains with predicate #{unmatched.map(&:predicate).compact.join(',')} not in extra",
+                      matched: matched,
+                      unmatched: unmatched,
+                      satisfied: expression
       end
 
       # closed is false or unmatchables is empty.
@@ -69,10 +87,10 @@ module ShEx::Algebra
         op.satisfies?(matched)
       end unless matched.empty?
 
-      true
-    rescue NotMatched => e
-      logger.recovering = false
-      not_satisfied e.message
+      # FIXME: also record matchables, outs and others?
+      satisfy matched: matched
+    rescue ShEx::NotMatched => e
+      not_satisfied e.message, unsatisfied: e.expression
     end
 
     ##

data/lib/shex/algebra/shape_ref.rb

@@ -10,18 +10,17 @@ module ShEx::Algebra
     end
 
     ##
-    # Satisfies method
-    # @param [RDF::Resource] n
-    # @return [Boolean] `true` if satisfied
-    # @raise [ShEx::NotSatisfied] if not satisfied
+    # 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?(n)
+    def satisfies?(focus)
       status "ref #{operands.first.to_s}"
-      referenced_shape.satisfies?(n)
-      status "ref satisfied"
-      true
+      matched_shape = referenced_shape.satisfies?(focus)
+      satisfy satisfied: matched_shape
     rescue ShEx::NotSatisfied => e
-      not_satisfied e.message
+      not_satisfied e.message, unsatisfied: e.expression
       raise
     end
 

data/lib/shex/algebra/start.rb

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

data/lib/shex/algebra/triple_constraint.rb

@@ -7,46 +7,52 @@ module ShEx::Algebra
     ##
     # In this case, we accept an array of statements, and match based on cardinality.
     #
-    # @param [Array<RDF::Statement>] t
-    # @return [Array<RDF::Statement>]
-    # @raise NotMatched, ShEx::NotSatisfied
-    def matches(t)
+    # @param  (see TripleExpression#matches)
+    # @return (see TripleExpression#matches)
+    # @raise  (see TripleExpression#matches)
+    def matches(statements)
       status "predicate #{predicate}"
-      max = maximum
-      results = t.select do |statement|
-        if max > 0
-          value = inverse? ? statement.subject : statement.object
+      results, satisfied, unsatisfied = [], [], []
+      num_iters, max = 0, maximum
 
-          if statement.predicate == predicate && shape_expr_satisfies?(shape, value)
-            status "matched #{statement.to_sxp}"
-            max -= 1
-          else
-            status "no match #{statement.to_sxp}"
-            false
+      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}"
+          if matched_shape
+            matched_shape.matched = [statement]
+            statement = statement.dup.extend(ReferencedStatement)
+            statement.referenced = matched_shape
+            satisfied << matched_shape
           end
-        else
-          false # matched enough
+          results << statement
+          num_iters += 1
+        rescue ShEx::NotSatisfied => e
+          status "not satisfied: #{e.message}"
+          statement = statement.dup.extend(ReferencedStatement)
+          unmatched << statement.referenced = shape
         end
       end
 
       # Max violations handled in Shape
-      not_matched "Minimum Cardinality Violation: #{results.length} < #{minimum}" if
-        results.length < minimum
+      if results.length < minimum
+        raise ShEx::NotMatched, "Minimum Cardinality Violation: #{results.length} < #{minimum}"
+      end
 
       # Last, evaluate semantic acts
       semantic_actions.all? do |op|
         op.satisfies?(results)
       end unless results.empty?
 
-      results
-    end
-
-    def shape_expr_satisfies?(shape, value)
-      shape.nil? || shape.satisfies?(value)
-    rescue ShEx::NotSatisfied => e
-      status "ignore error: #{e.message}"
-      logger.recovering = false
-      false
+      satisfy matched: results, satisfied: satisfied, unsatisfied: unsatisfied
+    rescue ShEx::NotMatched, ShEx::NotSatisfied => e
+      not_matched e.message,
+                  matched:   results,   unmatched:   (statements - results),
+                  satisfied: satisfied, unsatisfied: unsatisfied
     end
 
     def predicate

data/lib/shex/algebra/triple_expression.rb

@@ -1,19 +1,17 @@
 require 'sparql/algebra'
-require 'sparql/extensions'
 
 module ShEx::Algebra
   # Implements `neigh`, `arcs_out`, `args_in` and `matches`
   module TripleExpression
-
     ##
     # `matches`: asserts that a triple expression is matched by a set of triples that come from the neighbourhood of a node in an RDF graph. The expression `matches(T, expr, m)` indicates that a set of triples `T` can satisfy these rules...
     #
     # Behavior should be overridden in subclasses, which end by calling this through `super`.
     #
-    # @param [Array<RDF::Statement>] t
-    # @return [Array<RDF::Statement>]
-    # @raise NotMatched, ShEx::NotSatisfied
-    def matches(t)
+    # @param [Array<RDF::Statement>] statements
+    # @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)
       raise NotImplementedError, "#matches Not implemented in #{self.class}"
     end
 
@@ -21,26 +19,44 @@ module ShEx::Algebra
     # Included TripleConstraints
     # @return [Array<TripleConstraints>]
     def triple_constraints
-      operands.select {|o| o.is_a?(TripleExpression)}.map(&:triple_constraints).flatten.uniq
+      @triple_contraints ||= operands.select do |o|
+        o.is_a?(TripleExpression)
+      end.
+      map(&:triple_constraints).
+      flatten.
+      uniq
     end
 
     ##
     # Minimum constraint (defaults to 1)
     # @return [Integer]
     def minimum
-      op = operands.detect {|o| o.is_a?(Array) && o.first == :min} || [:min, 1]
-      op[1]
+      @minimum ||= begin
+        op = operands.detect {|o| o.is_a?(Array) && o.first == :min} || [:min, 1]
+        op[1]
+      end
     end
 
     ##
     # Maximum constraint (defaults to 1)
     # @return [Integer, Float::INFINITY]
     def maximum
-      op = operands.detect {|o| o.is_a?(Array) && o.first == :max} || [:max, 1]
-      op[1] == '*' ? Float::INFINITY : op[1]
+      @maximum ||= begin
+        op = operands.detect {|o| o.is_a?(Array) && o.first == :max} || [:max, 1]
+        op[1] == '*' ? Float::INFINITY : op[1]
+      end
     end
 
     # This operator includes TripleExpression
     def triple_expression?; true; end
   end
+
+  module ReferencedStatement
+    # @return [ShEx::Algebra::Satisfiable] referenced operand which satisfied some of this statement
+    attr_accessor :referenced
+
+    def to_sxp_bin
+      referenced ? super + [referenced.to_sxp_bin] : super
+    end
+  end
 end

data/lib/shex/parser.rb

@@ -12,6 +12,7 @@ module ShEx
     include ShEx::Meta
     include ShEx::Terminals
     include EBNF::LL1::Parser
+    include RDF::Util::Logger
 
     ##
     # Any additional options for the parser.
@@ -568,7 +569,7 @@ module ShEx
     # @option options [#to_s]    :anon_base     ("b0")
     #   Basis for generating anonymous Nodes
     # @option options [Boolean] :resolve_iris (false)
-    #   Resolve prefix and relative IRIs, otherwise, when serializing the parsed SSE
+    #   Resolve prefix and relative IRIs, otherwise, when serializing the parsed SXP
     #   as S-Expressions, use the original prefixed and relative URIs along with `base` and `prefix`
     #   definitions.
     # @option options [Boolean]  :validate     (false)
@@ -591,10 +592,6 @@ module ShEx
       end
       @input.encode!(Encoding::UTF_8) if @input.respond_to?(:encode!)
       @options = {anon_base: "b0", validate: false}.merge(options)
-      @options[:debug] ||= case
-      when options[:progress] then 2
-      when options[:validate] then 1
-      end
 
       debug("base IRI") {base_uri.inspect}
       debug("validate") {validate?.inspect}
@@ -630,7 +627,9 @@ module ShEx
     #
     # @param [Symbol, #to_s] prod The starting production for the parser.
     #   It may be a URI from the grammar, or a symbol representing the local_name portion of the grammar URI.
-    # @return [Array]
+    # @return [ShEx::Algebra::Schema] The executable parsed expression.
+    # @raise [ShEx::ParseError] when a syntax error is detected
+    # @raise [ShEx::StructureError, ArgumentError] on structural problems with schema
     # @see http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
     # @see http://axel.deri.ie/sparqltutorial/ESWC2007_SPARQL_Tutorial_unit2b.pdf
     def parse(prod = START)
@@ -641,17 +640,18 @@ module ShEx
       ) do |context, *data|
         case context
         when :trace
-          level, lineno, depth, *args = data
-          message = args.to_sse
-          d_str = depth > 100 ? ' ' * 100 + '+' : ' ' * depth
-          str = "[#{lineno}](#{level})#{d_str}#{message}".chop
-          case @options[:debug]
-          when Array
-            @options[:debug] << str unless level > 2
-          when TrueClass
-            $stderr.puts str
-          when Integer
-            $stderr.puts(str) if level <= @options[:debug]
+          if options[:logger]
+            level, lineno, depth, *args = data
+            case level
+            when 0
+              log_error(*args, depth: depth, lineno: lineno)
+            when 1
+              log_warning(*args, depth: depth, lineno: lineno)
+            when 2
+              log_info(*args, depth: depth, lineno: lineno)
+            else
+              log_debug(*args, depth: depth, lineno: lineno)
+            end
           end
         end
       end
@@ -735,7 +735,7 @@ module ShEx
     #
     # @return [HRDF::URI]
     def base_uri
-      RDF::URI(@options[:base_uri])
+      RDF::URI(@options[:base_uri]) if @options[:base_uri]
     end
 
     ##

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shex
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Gregg Kellogg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-11 00:00:00.000000000 Z
+date: 2016-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf