shex 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 96423cdff8bd77f2573ab32cd954d5217b2dfe20
-  data.tar.gz: 510d72ce00605e864b37af848f39c54f19de96b8
+  metadata.gz: d66489982d96aa02cd6be18354daaa81934af243
+  data.tar.gz: 7385a3e9933b1c81e09b7d0a126a1760de9aa4c2
 SHA512:
-  metadata.gz: 7af06418271fa283bf833b837b546a10870af1e6f60fea90099d8a75d8dc4097f1fce6c7800b0874b50efcddbafe97abe5e30888c51f1d97f62e46298b2c5e86
-  data.tar.gz: 5c9a7e9c9f7373a64a4c0722edefb6d2c9c20e5a9aaad8920f539641ddca97d5499dec2d3c2f1aa719122405b381a2d52bf536f4bcabb71ea41702eafeb4aabc
+  metadata.gz: d060ca866830927b3342352249337b6c06b25060677a8fe46e3a017d9c7a269749e5e1e792928eb6c4324bbaffb3bab91da1fb560d5e97ef33df57847df281e7
+  data.tar.gz: 7bf7a3fb6bd9d121a00ba837a5b0725cb5b2732d04dc8c959a8ee37ff3a311340dd9ebdf4496254dc450c39ee139e92800773990a133d922ffb98e5e7f602160

data/README.md

@@ -38,7 +38,7 @@ The ShEx gem implements a [ShEx][ShExSpec] Shape Expression engine.
         (doap:name;doap:description|dc:title;dc:description)+;
         doap:category*;
         doap:developer IRI;
-        doap:implements    [<https://shexspec.github.io/spec/>]
+        doap:implements    [<http://shex.io/shex-semantics/>]
       }
     )
     graph = RDF::Graph.load("etc/doap.ttl")
@@ -109,26 +109,26 @@ The ShEx gem implements a [ShEx][ShExSpec] Shape Expression engine.
                     ]
                   }
                 ],
-                "min": 1, "max": "*"
+                "min": 1, "max": -1
               },
               {
                 "type": "TripleConstraint",
                 "predicate": "http://usefulinc.com/ns/doap#category",
                 "valueExpr": {"type": "NodeConstraint", "nodeKind": "iri"},
-                "min": 0, "max": "*"
+                "min": 0, "max": -1
               },
               {
                 "type": "TripleConstraint",
                 "predicate": "http://usefulinc.com/ns/doap#developer",
                 "valueExpr": {"type": "NodeConstraint", "nodeKind": "iri"},
-                "min": 1, "max": "*"
+                "min": 1, "max": -1
               },
               {
                 "type": "TripleConstraint",
                 "predicate": "http://usefulinc.com/ns/doap#implements",
                 "valueExpr": {
                   "type": "NodeConstraint",
-                  "values": ["https://shexspec.github.io/spec/"]
+                  "values": ["http://shex.io/shex-semantics/"]
                 }
               }
             ]
@@ -143,7 +143,7 @@ The ShEx gem implements a [ShEx][ShExSpec] Shape Expression engine.
     # => true
 
 ## Extensions
-ShEx has an extension mechanism using [Semantic Actions](https://shexspec.github.io/spec/#semantic-actions). Extensions may be implemented in Ruby ShEx by sub-classing {ShEx::Extension} and implementing {ShEx::Extension#visit} and possibly {ShEx::Extension#initialize}, {ShEx::Extension#enter}, {ShEx::Extension#exit}, and {ShEx::Extension#close}. The `#visit` method will be called as part of the `#satisfies?` operation.
+ShEx has an extension mechanism using [Semantic Actions](http://shex.io/shex-semantics/#semantic-actions). Extensions may be implemented in Ruby ShEx by sub-classing {ShEx::Extension} and implementing {ShEx::Extension#visit} and possibly {ShEx::Extension#initialize}, {ShEx::Extension#enter}, {ShEx::Extension#exit}, and {ShEx::Extension#close}. The `#visit` method will be called as part of the `#satisfies?` operation.
 
     require 'shex'
     class ShEx::Test < ShEx::Extension("http://shex.io/extensions/Test/")
@@ -179,7 +179,7 @@ The result of parsing either ShExC or ShExJ is the creation of a set of executab
 ## Dependencies
 
 * [Ruby](http://ruby-lang.org/) (>= 2.2.2)
-* [RDF.rb](http://rubygems.org/gems/rdf) (>= 2.2)
+* [RDF.rb](http://rubygems.org/gems/rdf) (~> 2.2)
 
 ## Installation
 
@@ -237,7 +237,7 @@ This repository uses [Git Flow](https://github.com/nvie/gitflow) to mange develo
 This is free and unencumbered public domain software. For more information,
 see <http://unlicense.org/> or the accompanying {file:LICENSE} file.
 
-[ShExSpec]:     https://shexspec.github.io/spec/
+[ShExSpec]:     http://shex.io/shex-semantics/
 [RDF]:          http://www.w3.org/RDF/
 [RDF.rb]:       http://rubydoc.info/github/ruby-rdf/rdf
 [EBNF]:         http://rubygems.org/gems/ebnf

data/VERSION

@@ -1 +1 @@
-0.4.0
+0.5.0

data/etc/doap.ttl

@@ -15,7 +15,7 @@
   doap:description   "ShEx is an Shape Expression engine for the RDF.rb library suite."@en ;
   doap:created       "2016-12-09"^^xsd:date ;
   doap:programming-language "Ruby" ;
-  doap:implements    <https://shexspec.github.io/spec/> ;
+  doap:implements    <http://shex.io/shex-semantics/> ;
   doap:category      <http://dbpedia.org/resource/Resource_Description_Framework>,
                      <http://dbpedia.org/resource/Ruby_(programming_language)> ;
   doap:download-page <http://rubygems.org/gems/shex> ;

data/lib/shex.rb

@@ -1,7 +1,7 @@
 ##
 # A ShEx runtime for RDF.rb.
 #
-# @see https://shexspec.github.io/spec/#shexc
+# @see http://shex.io/shex-semantics/#shexc
 module ShEx
   autoload :Algebra,    'shex/algebra'
   autoload :Meta,       'shex/meta'
@@ -11,7 +11,7 @@ module ShEx
   autoload :VERSION,    'shex/version'
 
   # Location of the ShEx JSON-LD context
-  CONTEXT = "https://shexspec.github.io/context.jsonld"
+  CONTEXT = "http://www.w3.org/ns/shex.jsonld"
 
   # Extensions defined in this gem
   EXTENSIONS = %w{test}
@@ -71,11 +71,11 @@ module ShEx
   # @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)
+  def self.execute(expression, queryable, map, format: 'shexc', **options)
     shex = self.parse(expression, options.merge(format: format))
     queryable = queryable || RDF::Graph.new
 
-    shex.execute(focus, queryable, {focus => shape}, options)
+    shex.execute(queryable, map, options)
   end
 
   ##
@@ -89,11 +89,11 @@ module ShEx
   # @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)
+  def self.satisfies?(expression, queryable, map, format: 'shexc', **options)
     shex = self.parse(expression, options.merge(format: format))
     queryable = queryable || RDF::Graph.new
 
-    shex.satisfies?(focus, queryable, {focus => shape}, options)
+    shex.satisfies?(queryable, map, options)
   end
 
   ##
@@ -129,14 +129,14 @@ module ShEx
   class NotSatisfied < Error
     ##
     # The expression which was not satified
-    # @return [ShEx::Satisfiable]
+    # @return [ShEx::Algebra::ShapeExpression]
     attr_reader :expression
 
     ##
     # Initializes a new parser error instance.
     #
-    # @param  [String, #to_s]          message
-    # @param  [Satisfiable]            expression (self)
+    # @param  [String, #to_s]                   message
+    # @param  [ShEx::Algebra::ShapeExpression]  expression
     def initialize(message, expression: self)
       @expression = expression
       super(message.to_s)
@@ -157,8 +157,8 @@ module ShEx
     ##
     # Initializes a new parser error instance.
     #
-    # @param  [String, #to_s]          message
-    # @param  [Satisfiable]            expression (self)
+    # @param  [String, #to_s]                   message
+    # @param  [ShEx::Algebra::TripleExpression] expression
     def initialize(message, expression: self)
       @expression = expression
       super(message.to_s)

data/lib/shex/algebra.rb

@@ -7,25 +7,31 @@ module ShEx
   #
   # @author [Gregg Kellogg](http://greggkellogg.net/)
   module Algebra
-    autoload :And, 'shex/algebra/and'
-    autoload :Annotation, 'shex/algebra/annotation'
-    autoload :EachOf, 'shex/algebra/each_of'
-    autoload :External, 'shex/algebra/external'
-    autoload :Not, 'shex/algebra/not'
-    autoload :NodeConstraint, 'shex/algebra/node_constraint'
-    autoload :OneOf, 'shex/algebra/one_of'
-    autoload :Operator, 'shex/algebra/operator'
-    autoload :Or, 'shex/algebra/or'
-    autoload :Schema, 'shex/algebra/schema'
-    autoload :SemAct, 'shex/algebra/semact'
-    autoload :ShapeExpression, 'shex/algebra/shape_expression'
-    autoload :Shape, 'shex/algebra/shape'
-    autoload :Start, 'shex/algebra/start'
-    autoload :Stem, 'shex/algebra/stem'
-    autoload :StemRange, 'shex/algebra/stem_range'
+    autoload :And,              'shex/algebra/and'
+    autoload :Annotation,       'shex/algebra/annotation'
+    autoload :EachOf,           'shex/algebra/each_of'
+    autoload :External,         'shex/algebra/external'
+    autoload :IriStem,          'shex/algebra/stem'
+    autoload :IriStemRange,     'shex/algebra/stem_range'
+    autoload :LanguageStem,     'shex/algebra/stem'
+    autoload :LanguageStemRange,'shex/algebra/stem_range'
+    autoload :LiteralStem,      'shex/algebra/stem'
+    autoload :LiteralStemRange, 'shex/algebra/stem_range'
+    autoload :NodeConstraint,   'shex/algebra/node_constraint'
+    autoload :Not,              'shex/algebra/not'
+    autoload :OneOf,            'shex/algebra/one_of'
+    autoload :Operator,         'shex/algebra/operator'
+    autoload :Or,               'shex/algebra/or'
+    autoload :Schema,           'shex/algebra/schema'
+    autoload :SemAct,           'shex/algebra/semact'
+    autoload :Shape,            'shex/algebra/shape'
+    autoload :ShapeExpression,  'shex/algebra/shape_expression'
+    autoload :Start,            'shex/algebra/start'
+    autoload :Stem,             'shex/algebra/stem'
+    autoload :StemRange,        'shex/algebra/stem_range'
     autoload :TripleConstraint, 'shex/algebra/triple_constraint'
     autoload :TripleExpression, 'shex/algebra/triple_expression'
-    autoload :Value, 'shex/algebra/value'
+    autoload :Value,            'shex/algebra/value'
 
 
     ##
@@ -46,22 +52,26 @@ module ShEx
     def self.from_shexj(operator, options = {})
       raise ArgumentError unless operator.is_a?(Hash)
       klass = case operator['type']
-      when 'Annotation'       then Annotation
-      when 'EachOf'           then EachOf
-      when 'NodeConstraint'   then NodeConstraint
-      when 'OneOf'            then OneOf
-      when 'Schema'           then Schema
-      when 'SemAct'           then SemAct
-      when 'Shape'            then Shape
-      when 'ShapeAnd'         then And
-      when 'ShapeExternal'    then External
-      when 'ShapeNot'         then Not
-      when 'ShapeOr'          then Or
-      when 'Stem'             then Stem
-      when 'StemRange'        then StemRange
-      when 'TripleConstraint' then TripleConstraint
-      when 'Wildcard'         then StemRange
-      else raise ArgumentError, "unknown type #{operator['type']}"
+      when 'Annotation'         then Annotation
+      when 'EachOf'             then EachOf
+      when 'IriStem'            then IriStem
+      when 'IriStemRange'       then IriStemRange
+      when 'LanguageStem'       then LanguageStem
+      when 'LanguageStemRange'  then LanguageStemRange
+      when 'LiteralStem'        then LiteralStem
+      when 'LiteralStemRange'   then LiteralStemRange
+      when 'NodeConstraint'     then NodeConstraint
+      when 'OneOf'              then OneOf
+      when 'Schema'             then Schema
+      when 'SemAct'             then SemAct
+      when 'Shape'              then Shape
+      when 'ShapeAnd'           then And
+      when 'ShapeExternal'      then External
+      when 'ShapeNot'           then Not
+      when 'ShapeOr'            then Or
+      when 'TripleConstraint'   then TripleConstraint
+      when 'Wildcard'           then StemRange
+      else raise ArgumentError, "unknown type #{operator['type'].inspect}"
       end
 
       klass.from_shexj(operator, options)

data/lib/shex/algebra/node_constraint.rb

@@ -1,3 +1,4 @@
+# -*- encoding: utf-8 -*-
 module ShEx::Algebra
   ##
   class NodeConstraint < Operator
@@ -58,7 +59,7 @@ module ShEx::Algebra
       return true unless dt
 
       not_satisfied "Node was #{value.inspect}, expected datatype #{dt}", depth: depth unless
-        value.is_a?(RDF::Literal) && value.datatype == RDF::URI(dt)
+        value.is_a?(RDF::Literal) && value.datatype == RDF::URI(dt) && value.valid?
       status "right datatype: #{value}: #{dt}", depth: depth
       true
     end
@@ -68,11 +69,18 @@ module ShEx::Algebra
     # Checks all length/minlength/maxlength/pattern facets against the string representation of the value.
     # @return [Boolean] `true` if satisfied, `false` if it does not apply
     # @raise [ShEx::NotSatisfied] if not satisfied
+    # @todo using the XPath regexp engine supports additional flags "s" and "q"
     def satisfies_string_facet?(value, depth: 0)
       length    = op_fetch(:length)
       minlength = op_fetch(:minlength)
       maxlength = op_fetch(:maxlength)
-      pattern   = op_fetch(:pattern)
+      pat = (operands.detect {|op| op.is_a?(Array) && op[0] == :pattern} || [])
+      pattern = pat[1]
+
+      flags = 0
+      flags |= Regexp::EXTENDED   if pat[2].to_s.include?("x")
+      flags |= Regexp::IGNORECASE if pat[2].to_s.include?("i")
+      flags |= Regexp::MULTILINE  if pat[2].to_s.include?("m")
 
       return true if (length || minlength || maxlength || pattern).nil?
 
@@ -80,6 +88,7 @@ module ShEx::Algebra
       when RDF::Node then value.id
       else value.to_s
       end
+
       not_satisfied "Node #{v_s.inspect} length not #{length}", depth: depth if
         length && v_s.length != length.to_i
       not_satisfied"Node #{v_s.inspect} length < #{minlength}", depth: depth if
@@ -87,7 +96,7 @@ module ShEx::Algebra
       not_satisfied "Node #{v_s.inspect} length > #{maxlength}", depth: depth if
         maxlength && v_s.length > maxlength.to_i
       not_satisfied "Node #{v_s.inspect} does not match #{pattern}", depth: depth if
-        pattern && !Regexp.new(pattern).match(v_s)
+        pattern && !Regexp.new(pattern, flags).match(v_s)
       status "right string facet: #{value}", depth: depth
       true
     end

data/lib/shex/algebra/not.rb

@@ -19,7 +19,7 @@ module ShEx::Algebra
     # @param  (see ShapeExpression#satisfies?)
     # @return (see ShapeExpression#satisfies?)
     # @raise  (see ShapeExpression#satisfies?)
-    # @see [https://shexspec.github.io/spec/#shape-expression-semantics]
+    # @see [http://shex.io/shex-semantics/#shape-expression-semantics]
     def satisfies?(focus, depth: 0)
       status ""
       op = expressions.last

data/lib/shex/algebra/operator.rb

@@ -267,12 +267,16 @@ module ShEx::Algebra
 
       operator.each do |k, v|
         case k
-        when /length|pattern|clusive|digits/   then operands << [k.to_sym, RDF::Literal(v)]
+        when /length|clusive|digits/           then operands << [k.to_sym, RDF::Literal(v)]
         when 'id'                              then id = iri(v, options)
-        when 'min', 'max'                      then operands << [k.to_sym, v]
+        when 'flags'                            then ; # consumed in pattern below
+        when 'min', 'max'                      then operands << [k.to_sym, (v == -1 ? '*' : v)]
         when 'inverse', 'closed'               then operands << k.to_sym
         when 'nodeKind'                        then operands << v.to_sym
         when 'object'                          then operands << value(v, options)
+        when 'pattern'
+          # Include flags as well
+          operands << [:pattern, RDF::Literal(v), operator['flags']].compact
         when 'start'
           if v.is_a?(String)
             operands << Start.new(iri(v, options))
@@ -291,7 +295,7 @@ module ShEx::Algebra
           end
         when 'stem', 'name'
           # Value may be :wildcard for stem
-          operands << (v.is_a?(Symbol) ? v : iri(v, options))
+          operands << (v.is_a?(Symbol) ? v : value(v, options))
         when 'predicate' then operands << [:predicate, iri(v, options)]
         when 'extra', 'datatype'
           v = [v] unless v.is_a?(Array)
@@ -299,7 +303,7 @@ module ShEx::Algebra
         when 'exclusions'
           v = [v] unless v.is_a?(Array)
           operands << v.map do |op|
-            op.is_a?(Hash) ?
+            op.is_a?(Hash) && op.has_key?('type') ?
               ShEx::Algebra.from_shexj(op, options) :
               value(op, options)
           end.unshift(:exclusions)
@@ -345,11 +349,12 @@ module ShEx::Algebra
         when Array
           # First element should be a symbol
           case sym = op.first
-          when :datatype,
-               :pattern         then obj[op.first.to_s] = op.last.to_s
+          when :datatype        then obj['datatype'] = op.last.to_s
           when :exclusions      then obj['exclusions'] = Array(op[1..-1]).map {|v| serialize_value(v)}
           when :extra           then (obj['extra'] ||= []).concat Array(op[1..-1]).map(&:to_s)
-            # FIXME Shapes should be an array, not a hash
+          when :pattern
+            obj['pattern'] = op[1]
+            obj['flags'] = op[2] if op[2]
           when :shapes          then obj['shapes'] = Array(op[1..-1]).map {|v| v.to_h}
           when :minlength,
                :maxlength,
@@ -360,7 +365,7 @@ module ShEx::Algebra
                :maxexclusive,
                :totaldigits,
                :fractiondigits  then obj[op.first.to_s] = op.last.object
-          when :min, :max       then obj[op.first.to_s] = op.last
+          when :min, :max       then obj[op.first.to_s] = op.last == '*' ? -1 : op.last
           when :predicate       then obj[op.first.to_s] = op.last.to_s
           when :base, :prefix
             # Ignore base and prefix
@@ -378,7 +383,7 @@ module ShEx::Algebra
           end
         when RDF::Value
           case self
-          when Stem, StemRange  then obj['stem'] = op.to_s
+          when Stem, StemRange  then obj['stem'] = serialize_value(op)
           when SemAct           then obj[op.is_a?(RDF::URI) ? 'name' : 'code'] = op.to_s
           when TripleConstraint then obj['valueExpr'] = op.to_s
           when Shape            then obj['expression'] = op.to_s
@@ -517,10 +522,10 @@ module ShEx::Algebra
       case value
       when Hash
         # Either a value object or a node reference
-        if value['uri']
-          iri(value['uri'], options)
-        elsif value['value']
-          RDF::Literal(value['value'], datatype: value['type'], language: value['language'])
+        if value['uri'] || value['@id']
+          iri(value['uri'] || value['@id'], options)
+        elsif value['value'] || value['@value']
+          RDF::Literal(value['value'] || value['@value'], datatype: value['type'] || value['@type'], language: value['language'] || value['@language'])
         else
           ShEx::Algebra.from_shexj(value, options)
         end
@@ -541,6 +546,8 @@ module ShEx::Algebra
           merge(value.has_language? ? {'language' => value.language.to_s} : {})
         when RDF::Resource
           value.to_s
+        when String
+          {'value' => value}
         else value.to_h
       end
     end

data/lib/shex/algebra/schema.rb

@@ -36,19 +36,22 @@ module ShEx::Algebra
     ##
     # Match on schema. Finds appropriate shape for node, and matches that shape.
     #
-    # @param [RDF::Term] focus
     # @param [RDF::Queryable] graph
-    # @param [Hash{RDF::Resource => RDF::Resource}] map
+    # @param [Hash{RDF::Term => <RDF::Resource>}, Array<Array(RDF::Term, RDF::Resource)>] map
+    #   A set of (`term`, `resource`) pairs where `term` is a node within `graph`, and `resource` identifies a shape
+    # @param [Array<RDF::Term>] *focus
+    # 	One or more nodes within `graph` for which to run the start expression.
     # @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.
+    # @return [Hash{RDF::Term => Array<ShapeResult>}] Returns _ShapeResults_, a hash of graph nodes to the results of their associated shapes
     # @param [Hash{Symbol => Object}] options
     # @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, {}
+    # @raise [ShEx::NotSatisfied] along with individual shape results
+    def execute(graph, map, focus: [], shapeExterns: [], depth: 0, **options)
+      @graph, @shapes_entered, results = graph, {}, {}
       @external_schemas = shapeExterns
-      focus = value(focus, options)
+      @extensions = {}
+      focus = Array(focus).map {|f| value(f, options)}
 
       logger = options[:logger] || @options[:logger]
       each_descendant do |op|
@@ -57,7 +60,6 @@ module ShEx::Algebra
       end
 
       # Initialize Extensions
-      @extensions = {}
       each_descendant do |op|
         next unless op.is_a?(SemAct)
         name = op.operands.first.to_s
@@ -67,36 +69,74 @@ module ShEx::Algebra
       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 id
-      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(value(k) => iri(v))}
+      @map = case map
+      when Hash
+        map.inject({}) do |memo, (node, shapes)|
+          gnode = graph.enum_term.detect {|t| t.node? && t.id == node.id} if node.is_a?(RDF::Node)
+          node = gnode if gnode
+          memo.merge(node => Array(shapes))
+        end
+      when Array
+        map.inject({}) do |memo, (node, shape)|
+          gnode = graph.enum_term.detect {|t| t.node? && t.id == node.id} if node.is_a?(RDF::Node)
+          node = gnode if gnode
+          (memo[node] ||= []).concat(Array(shape))
+          memo
+        end
+      when nil then {}
+      else
+        structure_error "Unrecognized shape map: #{map.inspect}"
+      end
 
       # First, evaluate semantic acts
       semantic_actions.all? do |op|
         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
-        satisfied_schema.operands << start.satisfies?(focus, depth: depth + 1)
+      if !focus.empty?
+        if start
+          focus.each do |node|
+            node = graph.enum_term.detect {|t| t.node? && t.id == node.id} if node.is_a?(RDF::Node)
+            sr = ShapeResult.new(RDF::URI("http://www.w3.org/ns/shex#Start"))
+            (results[node] ||= []) << sr
+            begin
+              sr.expression = start.satisfies?(node, depth: depth + 1)
+              sr.result = true
+            rescue ShEx::NotSatisfied => e
+              sr.expression = e.expression
+              sr.result = false
+            end
+          end
+        else
+          structure_error "Focus nodes with no start"
+        end
       end
 
-      # Add shape result(s)
-      satisfied_shapes = {}
-      satisfied_schema.operands << [:shapes, satisfied_shapes] unless shapes.empty?
-
       # 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)
+      @map.each do |node, shapes|
+        results[node] ||= []
+        shapes.each do |id|
+          enter_shape(id, node) do |shape|
+            sr = ShapeResult.new(id)
+            results[node] << sr
+            begin
+              sr.expression = shape.satisfies?(node, depth: depth + 1)
+              sr.result = true
+            rescue ShEx::NotSatisfied => e
+              sr.expression = e.expression
+              sr.result = false
+            end
+          end
         end
       end
-      status "schema satisfied", depth: depth
-      satisfied_schema
+
+      if results.values.flatten.all? {|sr| sr.result}
+        status "schema satisfied", depth: depth
+        results
+      else
+        raise ShEx::NotSatisfied.new("Graph does not conform to schema", expression: results)
+      end
     ensure
       # Close Semantic Action extensions
       @extensions.values.each {|ext| ext.close(schema: self, depth: depth, **options)}
@@ -105,16 +145,12 @@ module ShEx::Algebra
     ##
     # 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 (see ShEx::Algebra::Schema#execute)
     # @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))
+    def satisfies?(graph, map, **options)
+      execute(graph, map, **options)
     rescue ShEx::NotSatisfied
       false
     end
@@ -198,4 +234,41 @@ module ShEx::Algebra
       super
     end
   end
+
+  # A shape result
+  class ShapeResult
+    # The label of the shape within the schema, or a URI indicating a start shape
+    # @return [RDF::Resource]
+    attr_reader :shape
+
+    # Does the node conform to the shape
+    # @return [Boolean]
+    attr_accessor :result
+
+    # The annotated {Operator} indicating processing results
+    # @return [ShEx::Algebra::Operator]
+    attr_accessor :expression
+
+    # Holds the result of processing a shape
+    # @param [RDF::Resource] label
+    # @return [ShapeResult]
+    def initialize(shape)
+      @shape = shape
+    end
+
+    # The SXP of {#expression}
+    # @return [String]
+    def reason
+      SXP::Generator.string(expression.to_sxp_bin)
+    end
+
+    ##
+    # Returns the binary S-Expression (SXP) representation of this result.
+    #
+    # @return [Array]
+    # @see    https://en.wikipedia.org/wiki/S-expression
+    def to_sxp_bin
+      [:ShapeResult, shape, result, expression].map(&:to_sxp_bin)
+    end
+  end
 end