shex 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5d83ac4fdd795f4d27280e23fc431a42faa72dd7
-  data.tar.gz: 61b80075c76f018481226ed563fa7ec44fe0c35f
+  metadata.gz: 96423cdff8bd77f2573ab32cd954d5217b2dfe20
+  data.tar.gz: 510d72ce00605e864b37af848f39c54f19de96b8
 SHA512:
-  metadata.gz: 2a158d18cdfbe1c0ae951549bbafc0e8d2d312cc08d259eefe76729e192db380b60a63b0d4a525cc4c49eee8f3092b9fd82cee03fe174cf8ab334c57bb943a4f
-  data.tar.gz: 5078624090859f18d37daf162baadcca943533c4bd35eb3e52299c737a18b3c7ab85e1d3e0d4819f3d7a12b9c97e308e580b7d408a43d866ee1264331bb01d73
+  metadata.gz: 7af06418271fa283bf833b837b546a10870af1e6f60fea90099d8a75d8dc4097f1fce6c7800b0874b50efcddbafe97abe5e30888c51f1d97f62e46298b2c5e86
+  data.tar.gz: 5c9a7e9c9f7373a64a4c0722edefb6d2c9c20e5a9aaad8920f539641ddca97d5499dec2d3c2f1aa719122405b381a2d52bf536f4bcabb71ea41702eafeb4aabc

data/README.md

@@ -48,7 +48,7 @@ The ShEx gem implements a [ShEx][ShExSpec] Shape Expression engine.
     }
     schema.satisfies?("http://rubygems.org/gems/shex", graph, map)
     # => true
-### Validating a node using ShExC
+### Validating a node using ShExJ
 
     require 'rubygems'
     require 'rdf/turtle'
@@ -174,10 +174,12 @@ The ShExC parser uses the [EBNF][] gem to generate first, follow and branch tabl
 
 The parser takes branch and follow tables generated from the [ShEx Grammar](file.shex.html) described in the [specification][ShExSpec]. Branch and Follow tables are specified in the generated {ShEx::Meta}.
 
+The result of parsing either ShExC or ShExJ is the creation of a set of executable {ShEx::Algebra} Operators which are directly executed to perform shape validation.
+
 ## Dependencies
 
-* [Ruby](http://ruby-lang.org/) (>= 2.0)
-* [RDF.rb](http://rubygems.org/gems/rdf) (>= 2.1)
+* [Ruby](http://ruby-lang.org/) (>= 2.2.2)
+* [RDF.rb](http://rubygems.org/gems/rdf) (>= 2.2)
 
 ## Installation
 

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.4.0

data/lib/shex.rb

@@ -35,10 +35,10 @@ module ShEx
     when 'shexc' then Parser.new(expression, options).parse
     when 'shexj'
       expression = expression.read if expression.respond_to?(:read)
-      Algebra.from_shexj(JSON.parse expression)
+      Algebra.from_shexj(JSON.parse(expression), options)
     when 'sxp'
       expression = expression.read if expression.respond_to?(:read)
-      Algebra.from_sxp(JSON.parse expression)
+      Algebra.from_sxp(expression, options)
     else raise "Unknown expression format: #{format.inspect}"
     end
   end

data/lib/shex/algebra.rb

@@ -10,17 +10,15 @@ module ShEx
     autoload :And, 'shex/algebra/and'
     autoload :Annotation, 'shex/algebra/annotation'
     autoload :EachOf, 'shex/algebra/each_of'
-    autoload :Inclusion, 'shex/algebra/inclusion'
+    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 :Satisfiable, 'shex/algebra/satisfiable'
     autoload :Schema, 'shex/algebra/schema'
     autoload :SemAct, 'shex/algebra/semact'
-    autoload :External, 'shex/algebra/external'
-    autoload :ShapeRef, 'shex/algebra/shape_ref'
+    autoload :ShapeExpression, 'shex/algebra/shape_expression'
     autoload :Shape, 'shex/algebra/shape'
     autoload :Start, 'shex/algebra/start'
     autoload :Stem, 'shex/algebra/stem'
@@ -50,16 +48,15 @@ module ShEx
       klass = case operator['type']
       when 'Annotation'       then Annotation
       when 'EachOf'           then EachOf
-      when 'Inclusion'        then Inclusion
       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 'ShapeRef'         then ShapeRef
       when 'Stem'             then Stem
       when 'StemRange'        then StemRange
       when 'TripleConstraint' then TripleConstraint

data/lib/shex/algebra/and.rb

@@ -1,7 +1,7 @@
 module ShEx::Algebra
   ##
   class And < Operator
-    include Satisfiable
+    include ShapeExpression
     NAME = :and
 
     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,18 +27,28 @@ module ShEx::Algebra
 
     #
     # S is a ShapeAnd and for every shape expression se2 in shapeExprs, 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 ""
-      expressions = operands.select {|o| o.is_a?(Satisfiable)}
       satisfied = []
       unsatisfied = expressions.dup
 
       # Operand raises NotSatisfied, so no need to check here.
       expressions.each do |op|
-        satisfied << op.satisfies?(focus, depth: depth)
+        satisfied << 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
+            end
+          end
+        when ShapeExpression
+          op.satisfies?(focus, depth: depth + 1)
+        end
         unsatisfied.shift
       end
       satisfy focus: focus, satisfied: satisfied, depth: depth
@@ -50,6 +60,26 @@ module ShEx::Algebra
                     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
       "ShapeAnd"
     end

data/lib/shex/algebra/annotation.rb

@@ -17,7 +17,7 @@ module ShEx::Algebra
     def to_h
       {
         'type' => json_type,
-        'predicate' => operands.first.to_s,
+        'predicate' => operands.first.last.to_s,
         'object' => serialize_value(operands.last)
       }
     end

data/lib/shex/algebra/each_of.rb

@@ -31,8 +31,9 @@ module ShEx::Algebra
       while num_iters < max
         begin
           matched_this_iter = []
-          operands.select {|o| o.is_a?(TripleExpression)}.all? do |op|
+          expressions.select {|o| o.is_a?(TripleExpression) || o.is_a?(RDF::Resource)}.all? do |op|
             begin
+              op = schema.find(op) if op.is_a?(RDF::Resource)
               matched_op = op.matches(arcs_in - matched_this_iter, arcs_out - matched_this_iter, depth: depth + 1)
               satisfied << matched_op
               matched_this_iter += matched_op.matched
@@ -70,5 +71,25 @@ module ShEx::Algebra
     ensure
       semantic_actions.each {|op| op.exit(matched: matched, depth: depth + 1)}
     end
+
+    ##
+    # expressions must be TripleExpressions
+    #
+    # @return [Operator] `self`
+    # @raise  [ShEx::StructureError] if the value is invalid
+    def validate!
+      expressions.each do |op|
+        case op
+        when TripleExpression
+        when RDF::Resource
+          ref = schema.find(op)
+          ref.is_a?(TripleExpression) ||
+          structure_error("#{json_type} must reference a TripleExpression: #{ref}")
+        else
+          structure_error("#{json_type} must reference a TripleExpression: #{ref}")
+        end
+      end
+      super
+    end
   end
 end

data/lib/shex/algebra/external.rb

@@ -1,7 +1,7 @@
 module ShEx::Algebra
   ##
   class External < Operator
-    include Satisfiable
+    include ShapeExpression
     NAME = :external
 
     #
@@ -9,11 +9,11 @@ module ShEx::Algebra
     def satisfies?(focus, depth: 0)
       extern_shape = nil
 
-      # Find the label for this external
-      not_satisfied("Can't find label for this extern", depth: depth) unless label
+      # Find the id for this external
+      not_satisfied("Can't find id for this extern", depth: depth) unless id
 
       schema.external_schemas.each do |schema|
-        extern_shape ||= schema.shapes.detect {|s| s.label == label}
+        extern_shape ||= schema.shapes.detect {|s| s.id == id}
       end
 
       not_satisfied("External not configured for this shape", depth: depth) unless extern_shape

data/lib/shex/algebra/node_constraint.rb

@@ -1,7 +1,7 @@
 module ShEx::Algebra
   ##
   class NodeConstraint < Operator
-    include Satisfiable
+    include ShapeExpression
     NAME = :nodeConstraint
 
     ##
@@ -15,9 +15,9 @@ module ShEx::Algebra
 
     #
     # 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?)
+    # @param  (see ShapeExpression#satisfies?)
+    # @return (see ShapeExpression#satisfies?)
+    # @raise  (see ShapeExpression#satisfies?)
     def satisfies?(focus, depth: 0)
       status "", depth: depth
       satisfies_node_kind?(focus, depth: depth + 1) &&

data/lib/shex/algebra/not.rb

@@ -1,7 +1,7 @@
 module ShEx::Algebra
   ##
   class Not < Operator::Unary
-    include Satisfiable
+    include ShapeExpression
     NAME = :not
 
     ##
@@ -16,14 +16,27 @@ module ShEx::Algebra
 
     #
     # S is a ShapeNot and for the shape expression se2 at shapeExpr, notSatisfies(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?)
     # @see [https://shexspec.github.io/spec/#shape-expression-semantics]
     def satisfies?(focus, depth: 0)
       status ""
+      op = expressions.last
       satisfied_op = begin
-        operands.last.satisfies?(focus, depth: depth + 1)
+        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
       rescue ShEx::NotSatisfied => e
         return satisfy focus: focus, satisfied: e.expression.unsatisfied, depth: depth
       end
@@ -31,6 +44,24 @@ module ShEx::Algebra
         focus: focus, unsatisfied: satisfied_op, depth: depth
     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
+
     def json_type
       "ShapeNot"
     end

data/lib/shex/algebra/one_of.rb

@@ -27,8 +27,9 @@ module ShEx::Algebra
       # 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|
+        matched_something = expressions.select {|o| o.is_a?(TripleExpression) || o.is_a?(RDF::Resource)}.any? do |op|
           begin
+            op = schema.find(op) if op.is_a?(RDF::Resource)
             matched_op = op.matches(arcs_in, arcs_out, depth: depth + 1)
             satisfied << matched_op
             results += matched_op.matched
@@ -62,5 +63,25 @@ module ShEx::Algebra
                   matched:   results,   unmatched:   ((arcs_in + arcs_out).uniq - results),
                   satisfied: satisfied, unsatisfied: unsatisfied, depth: depth
     end
+
+    ##
+    # expressions must be TripleExpressions
+    #
+    # @return [Operator] `self`
+    # @raise  [ShEx::StructureError] if the value is invalid
+    def validate!
+      expressions.each do |op|
+        case op
+        when TripleExpression
+        when RDF::Resource
+          ref = schema.find(op)
+          ref.is_a?(TripleExpression) ||
+          structure_error("#{json_type} must reference a TripleExpression: #{ref}")
+        else
+          structure_error("#{json_type} must reference a TripleExpression: #{ref}")
+        end
+      end
+      super
+    end
   end
 end

data/lib/shex/algebra/operator.rb

@@ -32,7 +32,7 @@ module ShEx::Algebra
     #     any additional options
     #   @option options [Boolean] :memoize (false)
     #     whether to memoize results for particular operands
-    #   @option options [RDF::Resource] :label
+    #   @option options [RDF::Resource] :id
     #     Identifier of the operator
     # @raise  [TypeError] if any operand is invalid
     def initialize(*operands)
@@ -55,7 +55,7 @@ module ShEx::Algebra
         end
       end
 
-      @label = options[:label]
+      @id = options[:id]
     end
 
     ##
@@ -72,9 +72,6 @@ module ShEx::Algebra
       operands.select {|o| o.is_a?(SemAct)}
     end
 
-    # Does this operator include Satisfiable?
-    def satisfiable?; false; end
-
     # Does this operator include TripleExpression?
     def triple_expression?; false; end
 
@@ -185,7 +182,7 @@ module ShEx::Algebra
     end
 
     def status(message, **opts, &block)
-      log_debug(self.class.const_get(:NAME).to_s + (@label ? "(#{@label})" : ""), message, **opts, &block)
+      log_debug(self.class.const_get(:NAME).to_s + (@id ? "(#{@id})" : ""), message, **opts, &block)
       true
     end
 
@@ -196,9 +193,9 @@ module ShEx::Algebra
     attr_reader :operands
 
     ##
-    # The label (or subject) of this operand
+    # The id (or subject) of this operand
     # @return [RDF::Resource]
-    attr_accessor :label
+    attr_accessor :id
 
     ##
     # Logging support (reader is in RDF::Util::Logger)
@@ -215,6 +212,21 @@ module ShEx::Algebra
       operands[index]
     end
 
+    ##
+    # Expressions are all operands which are Operators or RDF::Resource
+    # @return [RDF::Resource, Operand]
+    def expressions
+      @expressions = operands.
+        select {|op| op.is_a?(RDF::Resource) || op.is_a?(ShapeExpression) || op.is_a?(TripleExpression)}
+    end
+
+    ##
+    # The optional TripleExpression for this Shape.
+    # @return [TripleExpression]
+    def expression
+      expressions.first
+    end
+
     ##
     # Returns the binary S-Expression (SXP) representation of this operator.
     #
@@ -222,7 +234,7 @@ module ShEx::Algebra
     # @see    https://en.wikipedia.org/wiki/S-expression
     def to_sxp_bin
       [self.class.const_get(:NAME)] +
-      (label ? [[:label, label]] : []) +
+      (id ? [[:id, id]] : []) +
       (operands || []).map(&:to_sxp_bin)
     end
 
@@ -251,19 +263,25 @@ module ShEx::Algebra
     def self.from_shexj(operator, options = {})
       options[:context] ||= JSON::LD::Context.parse(ShEx::CONTEXT)
       operands = []
-      label = nil
+      id = nil
 
       operator.each do |k, v|
         case k
-        when /length|pattern|clusive/          then operands << [k.to_sym, v]
-        when 'label'                           then label = iri(v, options)
-        when 'min', 'max', 'inverse', 'closed' then operands << [k.to_sym, v]
+        when /length|pattern|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 'inverse', 'closed'               then operands << k.to_sym
         when 'nodeKind'                        then operands << v.to_sym
         when 'object'                          then operands << value(v, options)
-        when 'start'                           then operands << Start.new(ShEx::Algebra.from_shexj(v, options))
+        when 'start'
+          if v.is_a?(String)
+            operands << Start.new(iri(v, options))
+          else
+            operands << Start.new(ShEx::Algebra.from_shexj(v, options))
+          end
         when '@context'                        then
           options[:context] = JSON::LD::Context.parse(v)
-          options[:base_uri] = options[:context].base
+          options[:base_uri] ||= options[:context].base
         when 'shapes'
           operands << case v
           when Array
@@ -271,10 +289,10 @@ module ShEx::Algebra
           else
             raise "Expected value of shapes #{v.inspect}"
           end
-        when 'reference', 'include', 'stem', 'name'
+        when 'stem', 'name'
           # Value may be :wildcard for stem
           operands << (v.is_a?(Symbol) ? v : iri(v, options))
-        when 'predicate' then operands << iri(v, options)
+        when 'predicate' then operands << [:predicate, iri(v, options)]
         when 'extra', 'datatype'
           v = [v] unless v.is_a?(Array)
           operands << (v.map {|op| iri(op, options)}).unshift(k.to_sym)
@@ -285,11 +303,15 @@ module ShEx::Algebra
               ShEx::Algebra.from_shexj(op, options) :
               value(op, options)
           end.unshift(:exclusions)
-        when 'min', 'max', 'inverse', 'closed', 'valueExpr', 'semActs',
-             'shapeExpr', 'shapeExprs', 'startActs', 'expression',
-             'expressions', 'annotations'
+        when 'semActs', 'startActs', 'annotations'
           v = [v] unless v.is_a?(Array)
           operands += v.map {|op| ShEx::Algebra.from_shexj(op, options)}
+        when 'expression', 'expressions', 'shapeExpr', 'shapeExprs', 'valueExpr'
+          v = [v] unless v.is_a?(Array)
+          operands += v.map do |op|
+            # It's a URI reference to a Shape
+            op.is_a?(String) ? iri(op, options) : ShEx::Algebra.from_shexj(op, options) 
+          end
         when 'code'
           operands << v
         when 'values'
@@ -300,7 +322,7 @@ module ShEx::Algebra
         end
       end
 
-      new(*operands, label: label)
+      new(*operands, options.merge(id: id))
     end
 
     def json_type
@@ -315,10 +337,9 @@ module ShEx::Algebra
     # Create a hash version of the operator, suitable for turning into JSON.
     # @return [Hash]
     def to_h
-      obj = json_type == 'Schema' ?
-        {'@context' => ShEx::CONTEXT, 'type' => json_type} : 
-        {'type' => json_type}
-      obj['label'] = label.to_s if label
+      obj = json_type == 'Schema' ? {'@context' => ShEx::CONTEXT} :  {}
+      obj['id'] = id.to_s if id
+      obj['type'] = json_type
       operands.each do |op|
         case op
         when Array
@@ -340,6 +361,7 @@ module ShEx::Algebra
                :totaldigits,
                :fractiondigits  then obj[op.first.to_s] = op.last.object
           when :min, :max       then obj[op.first.to_s] = op.last
+          when :predicate       then obj[op.first.to_s] = op.last.to_s
           when :base, :prefix
             # Ignore base and prefix
           when Symbol           then obj[sym.to_s] = Array(op[1..-1]).map(&:to_h)
@@ -349,14 +371,20 @@ module ShEx::Algebra
         when :wildcard  then obj['stem'] = {'type' => 'Wildcard'}
         when Annotation then (obj['annotations'] ||= []) << op.to_h
         when SemAct     then (obj[is_a?(Schema) ? 'startActs' : 'semActs'] ||= []) << op.to_h
-        when Start      then obj['start'] = op.operands.first.to_h
+        when Start
+         obj['start'] =  case op.operands.first
+          when RDF::Resource then op.operands.first.to_s
+          else                    op.operands.first.to_h
+          end
         when RDF::Value
           case self
-          when TripleConstraint then obj['predicate'] = op.to_s
           when Stem, StemRange  then obj['stem'] = op.to_s
-          when Inclusion        then obj['include'] = op.to_s
-          when ShapeRef         then obj['reference'] = op.to_s
           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
+          when EachOf, OneOf    then (obj['expressions'] ||= []) << op.to_s
+          when And, Or          then (obj['shapeExprs'] ||= []) << op.to_s
+          when Not              then obj['shapeExpr'] = op.to_s
           else
             raise "How to serialize Value #{op.inspect} to json for #{self}"
           end
@@ -368,7 +396,7 @@ module ShEx::Algebra
           else
             raise "How to serialize Symbol #{op.inspect} to json for #{self}"
           end
-        when TripleConstraint, EachOf, OneOf, Inclusion
+        when TripleConstraint, EachOf, OneOf
           case self
           when EachOf, OneOf
             (obj['expressions'] ||= []) << op.to_h
@@ -382,7 +410,7 @@ module ShEx::Algebra
           else
             obj['valueExpr'] = op.to_h
           end
-        when And, Or, Shape, Not, ShapeRef
+        when And, Or, Shape, Not
           case self
           when And, Or
             (obj['shapeExprs'] ||= []) << op.to_h
@@ -462,11 +490,7 @@ module ShEx::Algebra
           RDF::URI(value)
         end
       else
-        if options[:context]
-          options[:context].expand_iri(value, document: true)
-        elsif base_uri
-          base_uri.join(value)
-        elsif base_uri
+        if base_uri
           base_uri.join(value)
         else
           RDF::URI(value)
@@ -526,14 +550,17 @@ module ShEx::Algebra
     #
     # @return [String]
     def inspect
-      sprintf("#<%s:%#0x(%s)>", self.class.name, __id__, operands.to_sse.gsub(/\s+/m, ' '))
+      sprintf("#<%s:%#0x(%s%s)>", self.class.name, __id__, ("id: #{id} " if id), operands.inspect)
     end
 
     ##
+    # Comparison does not consider operand order
     # @param  [Statement] other
     # @return [Boolean]
     def eql?(other)
-      other.class == self.class && other.operands == self.operands
+      other.class == self.class &&
+        other.id == self.id &&
+        other.operands.sort_by(&:to_s) == self.operands.sort_by(&:to_s)
     end
     alias_method :==, :eql?
 
@@ -543,22 +570,19 @@ module ShEx::Algebra
     # @yield operator
     # @yieldparam [Object] operator
     # @return [Enumerator]
-    def each_descendant(depth = 0, &block)
+    def each_descendant(&block)
       if block_given?
 
-        case block.arity
-        when 1 then block.call(self)
-        else block.call(depth, self)
-        end
+        block.call(self)
 
         operands.each do |operand|
           case operand
           when Array
             operand.each do |op|
-              op.each_descendant(depth + 1, &block) if op.respond_to?(:each_descendant)
+              op.each_descendant(&block) if op.respond_to?(:each_descendant)
             end
           else
-            operand.each_descendant(depth + 1, &block) if operand.respond_to?(:each_descendant)
+            operand.each_descendant(&block) if operand.respond_to?(:each_descendant)
           end
         end
       end
@@ -582,34 +606,38 @@ module ShEx::Algebra
     end
 
     ##
-    # First ancestor operator of type `klass`
-    #
-    # @param [Class] klass
-    # @return [Operator]
-    def first_ancestor(klass)
-      parent.is_a?(klass) ? parent : parent.first_ancestor(klass) if parent
-    end
+    # Ancestors of this Operator
+    # @return [Array<Operator>]
+    #def ancestors
+    #  parent.is_a?(Operator) ? ([parent] + parent.ancestors) : []
+    #end
 
     ##
-    # Validate all operands, operator specific classes should override for operator-specific validation
+    # Validate all operands, operator specific classes should override for operator-specific validation.
+    #
+    # A schema **must not** contain any shape expression `S` with negated references, either directly or transitively, to `S`.
+    #
     # @return [SPARQL::Algebra::Expression] `self`
     # @raise  [ShEx::StructureError] if the value is invalid
     def validate!
-      operands.each {|op| op.validate! if op.respond_to?(:validate!)}
+      operands.each do |op|
+        op.validate! if op.respond_to?(:validate!)
+        if op.is_a?(RDF::Resource) && (is_a?(ShapeExpression) || is_a?(TripleExpression))
+          ref = schema.find(op)
+          structure_error("Missing reference: #{op}") if ref.nil?
+          #if ancestors.unshift(self).include?(ref)
+          #  structure_error("Self-recursive reference to #{op}")
+          #end
+          structure_error("Self referencing shape: #{operands.first}") if ref == self
+        end
+      end
       self
     end
 
   protected
     def dup
       operands = @operands.map {|o| o.dup rescue o}
-      self.class.new(*operands, label: @label)
-    end
-
-    ##
-    # Implement `to_hash` only if accessed; otherwise, it becomes an _Implicit Accessor_ which will cause problems with splat arguments, which causes the last to be turned into a hash for extracting keyword aruments.
-    def method_missing(method, *args)
-      return to_h(*args) if method == :hash
-      super
+      self.class.new(*operands, id: @id)
     end
 
     ##