shex 0.2.0 → 0.3.0

data/lib/shex/algebra/external.rb

@@ -6,19 +6,22 @@ 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?(focus)
+    def satisfies?(focus, depth: 0)
       extern_shape = nil
 
       # Find the label for this external
-      label = schema.shapes.key(self)
-      not_satisfied("Can't find label for this extern") unless label
+      not_satisfied("Can't find label for this extern", depth: depth) unless label
 
       schema.external_schemas.each do |schema|
-        extern_shape ||= schema.shapes[label]
+        extern_shape ||= schema.shapes.detect {|s| s.label == label}
       end
 
-      not_satisfied("External not configured for this shape") unless extern_shape
-      extern_shape.satisfies?(focus)
+      not_satisfied("External not configured for this shape", depth: depth) unless extern_shape
+      extern_shape.satisfies?(focus, depth: depth + 1)
+    end
+
+    def json_type
+      "ShapeExternal"
     end
   end
 end

data/lib/shex/algebra/inclusion.rb

@@ -4,6 +4,16 @@ module ShEx::Algebra
     include TripleExpression
     NAME = :inclusion
 
+    ##
+    # Creates an operator instance from a parsed ShExJ representation
+    # @param (see Operator#from_shexj)
+    # @return [Operator]
+    def self.from_shexj(operator, options = {})
+      raise ArgumentError unless operator.is_a?(Hash) && operator['type'] == "Inclusion"
+      raise ArgumentError, "missing include in #{operator.inspect}" unless operator.has_key?('include')
+      super
+    end
+
     def initialize(arg, **options)
       raise ArgumentError, "Shape inclusion must be an IRI or BNode: #{arg}" unless arg.is_a?(RDF::Resource)
       super
@@ -12,17 +22,17 @@ module ShEx::Algebra
     ##
     # In this case, we accept an array of statements, and match based on cardinality.
     #
-    # @param [Array<RDF::Statement>] statements
-    # @return [Array<RDF::Statement>]
-    # @raise [ShEx::NotMatched]
-    def matches(statements)
+    # @param  (see TripleExpression#matches)
+    # @return (see TripleExpression#matches)
+    # @raise  (see TripleExpression#matches)
+    def matches(arcs_in, arcs_out, depth: 0)
       status "referenced_shape: #{operands.first}"
-      expression = referenced_shape.triple_expressions.first
+      expression = referenced_shape.expression
       max = maximum
-      matched_expression = expression.matches(statements)
-      satisfy matched: matched_expression.matched
+      matched_expression = expression.matches(arcs_in, arcs_out, depth: depth + 1)
+      satisfy matched: matched_expression.matched, depth: depth
     rescue ShEx::NotMatched => e
-      not_matched e.message, unsatisfied: e.expression
+      not_matched e.message, unsatisfied: e.expression, depth: depth
     end
 
     ##
@@ -30,7 +40,7 @@ module ShEx::Algebra
     #
     # @return [Operand]
     def referenced_shape
-      schema.shapes[operands.first.to_s]
+      @referenced_shape ||= schema.shapes.detect {|s| s.label == operands.first}
     end
 
     ##
@@ -41,16 +51,17 @@ module ShEx::Algebra
     def validate!
       structure_error("Missing included shape: #{operands.first}") if referenced_shape.nil?
       structure_error("Self included shape: #{operands.first}") if referenced_shape == first_ancestor(Shape)
-
-      triple_expressions = referenced_shape.triple_expressions
-      case triple_expressions.length
-      when 0
-        structure_error("Includes shape with no triple expressions")
-      when 1
-      else
-        structure_error("Includes shape with multiple triple expressions")
-      end
+      structure_error("Referenced shape must be a Shape: #{operands.first}") unless referenced_shape.is_a?(Shape)
       super
     end
+
+    ##
+    # Returns the binary S-Expression (SXP) representation of this operator.
+    #
+    # @return [Array]
+    # @see    https://en.wikipedia.org/wiki/S-expression
+    def to_sxp_bin
+      ([:inclusion, ([:label, @label] if @label)].compact + operands).to_sxp_bin
+    end
   end
 end

data/lib/shex/algebra/node_constraint.rb

@@ -4,19 +4,28 @@ module ShEx::Algebra
     include Satisfiable
     NAME = :nodeConstraint
 
+    ##
+    # Creates an operator instance from a parsed ShExJ representation
+    # @param (see Operator#from_shexj)
+    # @return [Operator]
+    def self.from_shexj(operator, options = {})
+      raise ArgumentError unless operator.is_a?(Hash) && operator['type'] == 'NodeConstraint'
+      super
+    end
+
     #
     # 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?(focus) &&
-      satisfies_datatype?(focus) &&
-      satisfies_string_facet?(focus) &&
-      satisfies_numeric_facet?(focus) &&
-      satisfies_values?(focus) &&
-      satisfy
+    def satisfies?(focus, depth: 0)
+      status "", depth: depth
+      satisfies_node_kind?(focus, depth: depth + 1) &&
+      satisfies_datatype?(focus, depth: depth + 1) &&
+      satisfies_string_facet?(focus, depth: depth + 1) &&
+      satisfies_numeric_facet?(focus, depth: depth + 1) &&
+      satisfies_values?(focus, depth: depth + 1) &&
+      satisfy(depth: depth)
     end
 
   private
@@ -25,8 +34,8 @@ module ShEx::Algebra
     # Satisfies Node Kind Constraint
     # @return [Boolean] `true` if satisfied, `false` if it does not apply
     # @raise [ShEx::NotSatisfied] if not satisfied
-    def satisfies_node_kind?(value)
-      kind = case operands.first
+    def satisfies_node_kind?(value, depth: 0)
+      kind = case operands.detect {|o| o.is_a?(Symbol)}
       when :iri         then RDF::URI
       when :bnode       then RDF::Node
       when :literal     then RDF::Literal
@@ -34,9 +43,9 @@ module ShEx::Algebra
       else              return true
       end
 
-      not_satisfied "Node was #{value.inspect} expected kind #{kind}" unless
+      not_satisfied "Node was #{value.inspect} expected kind #{kind}", depth: depth unless
         value.is_a?(kind)
-      status "right kind: #{value}: #{kind}"
+      status "right kind: #{value}: #{kind}", depth: depth
       true
     end
 
@@ -44,13 +53,13 @@ module ShEx::Algebra
     # Datatype Constraint
     # @return [Boolean] `true` if satisfied, `false` if it does not apply
     # @raise [ShEx::NotSatisfied] if not satisfied
-    def satisfies_datatype?(value)      
-      dt = operands[1] if operands.first == :datatype
+    def satisfies_datatype?(value, depth: 0)
+      dt = op_fetch(:datatype)
       return true unless dt
 
-      not_satisfied "Node was #{value.inspect}, expected datatype #{dt}" unless
+      not_satisfied "Node was #{value.inspect}, expected datatype #{dt}", depth: depth unless
         value.is_a?(RDF::Literal) && value.datatype == RDF::URI(dt)
-      status "right datatype: #{value}: #{dt}"
+      status "right datatype: #{value}: #{dt}", depth: depth
       true
     end
 
@@ -59,7 +68,7 @@ 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
-    def satisfies_string_facet?(value)
+    def satisfies_string_facet?(value, depth: 0)
       length    = op_fetch(:length)
       minlength = op_fetch(:minlength)
       maxlength = op_fetch(:maxlength)
@@ -71,15 +80,15 @@ module ShEx::Algebra
       when RDF::Node then value.id
       else value.to_s
       end
-      not_satisfied "Node #{v_s.inspect} length not #{length}" if
+      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}" if
+      not_satisfied"Node #{v_s.inspect} length < #{minlength}", depth: depth if
         minlength && v_s.length < minlength.to_i
-      not_satisfied "Node #{v_s.inspect} length > #{maxlength}" if
+      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}" if
+      not_satisfied "Node #{v_s.inspect} does not match #{pattern}", depth: depth if
         pattern && !Regexp.new(pattern).match(v_s)
-      status "right string facet: #{value}"
+      status "right string facet: #{value}", depth: depth
       true
     end
 
@@ -88,7 +97,7 @@ module ShEx::Algebra
     # Checks all numeric facets against the value.
     # @return [Boolean] `true` if satisfied, `false` if it does not apply
     # @raise [ShEx::NotSatisfied] if not satisfied
-    def satisfies_numeric_facet?(value)
+    def satisfies_numeric_facet?(value, depth: 0)
       mininclusive   = op_fetch(:mininclusive)
       minexclusive   = op_fetch(:minexclusive)
       maxinclusive   = op_fetch(:maxinclusive)
@@ -98,32 +107,32 @@ module ShEx::Algebra
 
       return true if (mininclusive || minexclusive || maxinclusive || maxexclusive || totaldigits || fractiondigits).nil?
 
-      not_satisfied "Node #{value.inspect} not numeric" unless
+      not_satisfied "Node #{value.inspect} not numeric", depth: depth unless
         value.is_a?(RDF::Literal::Numeric)
 
-      not_satisfied "Node #{value.inspect} not decimal" if
+      not_satisfied "Node #{value.inspect} not decimal", depth: depth if
         (totaldigits || fractiondigits) && (!value.is_a?(RDF::Literal::Decimal) || value.invalid?)
 
       numeric_value = value.object
       case
-      when !mininclusive.nil? && numeric_value < mininclusive.object then not_satisfied("Node #{value.inspect} < #{mininclusive.object}")
-      when !minexclusive.nil? && numeric_value <= minexclusive.object then not_satisfied("Node #{value.inspect} not <= #{minexclusive.object}")
-      when !maxinclusive.nil? && numeric_value > maxinclusive.object then not_satisfied("Node #{value.inspect} > #{maxinclusive.object}")
-      when !maxexclusive.nil? && numeric_value >= maxexclusive.object then not_satisfied("Node #{value.inspect} >= #{maxexclusive.object}")
+      when !mininclusive.nil? && numeric_value < mininclusive.object then not_satisfied("Node #{value.inspect} < #{mininclusive.object}", depth: depth)
+      when !minexclusive.nil? && numeric_value <= minexclusive.object then not_satisfied("Node #{value.inspect} not <= #{minexclusive.object}", depth: depth)
+      when !maxinclusive.nil? && numeric_value > maxinclusive.object then not_satisfied("Node #{value.inspect} > #{maxinclusive.object}", depth: depth)
+      when !maxexclusive.nil? && numeric_value >= maxexclusive.object then not_satisfied("Node #{value.inspect} >= #{maxexclusive.object}", depth: depth)
       when !totaldigits.nil?
         md = value.canonicalize.to_s.match(/([1-9]\d*|0)?(?:\.(\d+)(?!0))?/)
         digits = md ? (md[1].to_s + md[2].to_s) : ""
         if digits.length > totaldigits.to_i
-          not_satisfied "Node #{value.inspect} total digits != #{totaldigits}"
+          not_satisfied "Node #{value.inspect} total digits != #{totaldigits}", depth: depth
         end
       when !fractiondigits.nil?
         md = value.canonicalize.to_s.match(/\.(\d+)(?!0)?/)
         num = md ? md[1].to_s : ""
         if num.length > fractiondigits.to_i
-          not_satisfied "Node #{value.inspect} fractional digits != #{fractiondigits}"
+          not_satisfied "Node #{value.inspect} fractional digits != #{fractiondigits}", depth: depth
         end
       end
-      status "right numeric facet: #{value}"
+      status "right numeric facet: #{value}", depth: depth
       true
     end
 
@@ -132,12 +141,12 @@ module ShEx::Algebra
     # Checks all numeric facets against the value.
     # @return [Boolean] `true` if satisfied, `false` if it does not apply
     # @raise [ShEx::NotSatisfied] if not satisfied
-    def satisfies_values?(value)
+    def satisfies_values?(value, depth: 0)
       values = operands.select {|op| op.is_a?(Value)}
       return true if values.empty?
-      matched_value = values.detect {|v| v.match?(value)}
-      not_satisfied "Node #{value.inspect} not expected" unless matched_value
-      status "right value: #{value}"
+      matched_value = values.detect {|v| v.match?(value, depth: depth + 1)}
+      not_satisfied "Value #{value.to_sxp} not expected, wanted #{values.to_sxp}", depth: depth unless matched_value
+      status "right value: #{value}", depth: depth
       true
     end
 

data/lib/shex/algebra/not.rb

@@ -4,20 +4,35 @@ module ShEx::Algebra
     include Satisfiable
     NAME = :not
 
+    ##
+    # Creates an operator instance from a parsed ShExJ representation
+    # @param (see Operator#from_shexj)
+    # @return [Operator]
+    def self.from_shexj(operator, options = {})
+      raise ArgumentError unless operator.is_a?(Hash) && operator['type'] == 'ShapeNot'
+      raise ArgumentError, "missing shapeExpr in #{operator.inspect}" unless operator.has_key?('shapeExpr')
+      super
+    end
+
     #
     # 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?)
     # @see [https://shexspec.github.io/spec/#shape-expression-semantics]
-    def satisfies?(focus)
+    def satisfies?(focus, depth: 0)
       status ""
       satisfied_op = begin
-        operands.first.satisfies?(focus)
+        operands.last.satisfies?(focus, depth: depth + 1)
       rescue ShEx::NotSatisfied => e
-        return satisfy satisfied: e.expression.unsatisfied
+        return satisfy focus: focus, satisfied: e.expression.unsatisfied, depth: depth
       end
-      not_satisfied "Expression should not have matched", unsatisfied: satisfied_op
+      not_satisfied "Expression should not have matched",
+        focus: focus, unsatisfied: satisfied_op, depth: depth
+    end
+
+    def json_type
+      "ShapeNot"
     end
   end
 end

data/lib/shex/algebra/one_of.rb

@@ -4,12 +4,23 @@ module ShEx::Algebra
     include TripleExpression
     NAME = :oneOf
 
+    ##
+    # Creates an operator instance from a parsed ShExJ representation
+    # @param (see Operator#from_shexj)
+    # @return [Operator]
+    def self.from_shexj(operator, options = {})
+      raise ArgumentError unless operator.is_a?(Hash) && operator['type'] == 'OneOf'
+      raise ArgumentError, "missing expressions in #{operator.inspect}" unless operator.has_key?('expressions')
+      super
+    end
+
     ##
     # `expr` is a OneOf and there is some shape expression `se2` in shapeExprs such that a `matches(T, se2, m)`...
     #
-    # @param [Array<RDF::Statement>] statements
-    # @return [Array<RDF::Statement]
-    def matches(statements)
+    # @param  (see TripleExpression#matches)
+    # @return (see TripleExpression#matches)
+    # @raise  (see TripleExpression#matches)
+    def matches(arcs_in, arcs_out, depth: 0)
       results, satisfied, unsatisfied = [], [], []
       num_iters, max = 0, maximum
 
@@ -18,22 +29,21 @@ module ShEx::Algebra
       while num_iters < max
         matched_something = operands.select {|o| o.is_a?(TripleExpression)}.any? do |op|
           begin
-            matched_op = op.matches(statements)
+            matched_op = op.matches(arcs_in, arcs_out, depth: depth + 1)
             satisfied << matched_op
             results += matched_op.matched
-            statements -= matched_op.matched
-            status "matched #{matched_op.matched.to_sxp}"
+            arcs_in -= matched_op.matched
+            arcs_out -= matched_op.matched
+            status "matched #{matched_op.matched.to_sxp}", depth: depth
           rescue ShEx::NotMatched => e
-            status "not matched: #{e.message}"
-            op = op.dup
-            op.unmatched = statements - results
-            unsatisfied << op
+            status "not matched: #{e.message}", depth: depth
+            unsatisfied << e.expression
             false
           end
         end
         break unless matched_something
         num_iters += 1
-        status "matched #{results.length} statements after #{num_iters} iterations"
+        status "matched #{results.length} statements after #{num_iters} iterations", depth: depth
       end
 
       # Max violations handled in Shape
@@ -42,15 +52,15 @@ module ShEx::Algebra
       end
 
       # Last, evaluate semantic acts
-      semantic_actions.all? do |op|
-        op.satisfies?(results)
+      semantic_actions.each do |op|
+        op.satisfies?(matched: results, depth: depth + 1)
       end unless results.empty?
 
-      satisfy matched: results, satisfied: satisfied, unsatisfied: unsatisfied
+      satisfy matched: results, satisfied: satisfied, depth: depth
     rescue ShEx::NotMatched, ShEx::NotSatisfied => e
       not_matched e.message,
-                  matched:   results,   unmatched:   (statements - results),
-                  satisfied: satisfied, unsatisfied: unsatisfied
+                  matched:   results,   unmatched:   ((arcs_in + arcs_out).uniq - results),
+                  satisfied: satisfied, unsatisfied: unsatisfied, depth: depth
     end
   end
 end

data/lib/shex/algebra/operator.rb

@@ -1,4 +1,6 @@
 require 'sparql/algebra'
+require 'json/ld/preloaded'
+require 'shex/shex_context'
 
 module ShEx::Algebra
 
@@ -30,6 +32,8 @@ module ShEx::Algebra
     #     any additional options
     #   @option options [Boolean] :memoize (false)
     #     whether to memoize results for particular operands
+    #   @option options [RDF::Resource] :label
+    #     Identifier of the operator
     # @raise  [TypeError] if any operand is invalid
     def initialize(*operands)
       @options  = operands.last.is_a?(Hash) ? operands.pop.dup : {}
@@ -51,15 +55,7 @@ module ShEx::Algebra
         end
       end
 
-      if options[:logger]
-        options[:depth] = 0
-        each_descendant(1) do |depth, operand|
-          if operand.respond_to?(:options)
-            operand.options[:logger] = options[:logger]
-            operand.options[:depth] = depth
-          end
-        end
-      end
+      @label = options[:label]
     end
 
     ##
@@ -85,6 +81,16 @@ module ShEx::Algebra
     # Does this operator a SemAct?
     def semact?; false; end
 
+    ##
+    # On a result instance, the focus of the expression
+    def focus
+      Array(operands.detect {|op| op.is_a?(Array) && op[0] == :focus} || [:focus])[1]
+    end
+    def focus=(node)
+      operands.delete_if {|op| op.is_a?(Array) && op[0] == :focus}
+      operands << [:focus, node]
+    end
+
     ##
     # On a result instance, the statements that matched this expression.
     # @return [Array<Statement>]
@@ -129,13 +135,26 @@ module ShEx::Algebra
       operands << ops.unshift(:unsatisfied) unless (ops || []).empty?
     end
 
+    ##
+    # On a result instance, the failure message. (failure only).
+    # @return [String]
+    def message
+      (operands.detect {|op| op.is_a?(Array) && op[0] == :message} || [:message])[1..-1]
+    end
+    def message=(str)
+      operands.delete_if {|op| op.is_a?(Array) && op[0] == :message}
+      operands << [:message, str]
+    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))
+    def satisfy(focus: nil, matched: nil, unmatched: nil, satisfied: nil, unsatisfied: nil, message: nil, **opts)
+      log_debug(self.class.const_get(:NAME), "satisfied", **opts) unless message
       expression = self.dup
+      expression.message = message if message
+      expression.focus = focus if focus
       expression.matched = Array(matched) if matched
       expression.unmatched = Array(unmatched) if unmatched
       expression.satisfied = Array(satisfied) if satisfied
@@ -145,25 +164,17 @@ module ShEx::Algebra
 
     ##
     # Exception handling
-    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)
+    def not_matched(message, **opts, &block)
+      expression = opts.fetch(:expression, self).satisfy(message: message, **opts)
       exception = opts.fetch(:exception, ShEx::NotMatched)
-      status(message) {(block_given? ? block.call : "") + "expression: #{expression.to_sxp}"}
+      status(message, **opts) {(block_given? ? block.call : "") + "expression: #{expression.to_sxp}"}
       raise exception.new(message, expression: expression)
     end
 
-    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)
+    def not_satisfied(message, **opts)
+      expression = opts.fetch(:expression, self).satisfy(message: message, **opts)
       exception = opts.fetch(:exception, ShEx::NotSatisfied)
-      status(message) {(block_given? ? block.call : "") + "expression: #{expression.to_sxp}"}
+      status(message, **opts) {(block_given? ? block.call : "") + "expression: #{expression.to_sxp}"}
       raise exception.new(message, expression: expression)
     end
 
@@ -173,8 +184,8 @@ module ShEx::Algebra
       log_error(message, depth: options.fetch(:depth, 0), exception: exception) {"expression: #{expression.to_sxp}"}
     end
 
-    def status(message, &block)
-      log_debug(self.class.const_get(:NAME), message, depth: options.fetch(:depth, 0), &block)
+    def status(message, **opts, &block)
+      log_debug(self.class.const_get(:NAME).to_s + (@label ? "(#{@label})" : ""), message, **opts, &block)
       true
     end
 
@@ -184,6 +195,16 @@ module ShEx::Algebra
     # @return [Array]
     attr_reader :operands
 
+    ##
+    # The label (or subject) of this operand
+    # @return [RDF::Resource]
+    attr_accessor :label
+
+    ##
+    # Logging support (reader is in RDF::Util::Logger)
+    # @return [Logger]
+    attr_writer :logger
+
     ##
     # Returns the operand at the given `index`.
     #
@@ -200,8 +221,9 @@ module ShEx::Algebra
     # @return [Array]
     # @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)]
+      [self.class.const_get(:NAME)] +
+      (label ? [[:label, label]] : []) +
+      (operands || []).map(&:to_sxp_bin)
     end
 
     ##
@@ -219,6 +241,286 @@ module ShEx::Algebra
       to_sxp_bin.to_sxp
     end
 
+    ##
+    # Creates an operator instance from a parsed ShExJ representation
+    # @param [Hash] operator
+    # @param [Hash] options ({})
+    # @option options [RDF::URI] :base
+    # @option options [Hash{String => RDF::URI}] :prefixes
+    # @return [Operator]
+    def self.from_shexj(operator, options = {})
+      options[:context] ||= JSON::LD::Context.parse(ShEx::CONTEXT)
+      operands = []
+      label = 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 '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 '@context'                        then
+          options[:context] = JSON::LD::Context.parse(v)
+          options[:base_uri] = options[:context].base
+        when 'shapes'
+          operands << case v
+          when Array
+            [:shapes] + v.map {|vv| ShEx::Algebra.from_shexj(vv, options)}
+          else
+            raise "Expected value of shapes #{v.inspect}"
+          end
+        when 'reference', 'include', '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 'extra', 'datatype'
+          v = [v] unless v.is_a?(Array)
+          operands << (v.map {|op| iri(op, options)}).unshift(k.to_sym)
+        when 'exclusions'
+          v = [v] unless v.is_a?(Array)
+          operands << v.map do |op|
+            op.is_a?(Hash) ?
+              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'
+          v = [v] unless v.is_a?(Array)
+          operands += v.map {|op| ShEx::Algebra.from_shexj(op, options)}
+        when 'code'
+          operands << v
+        when 'values'
+          v = [v] unless v.is_a?(Array)
+          operands += v.map do |op|
+            Value.new(value(op, options))
+          end
+        end
+      end
+
+      new(*operands, label: label)
+    end
+
+    def json_type
+      self.class.name.split('::').last
+    end
+
+    def to_json(options = nil)
+      self.to_h.to_json(options)
+    end
+
+    ##
+    # 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
+      operands.each do |op|
+        case op
+        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 :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 :shapes          then obj['shapes'] = Array(op[1..-1]).map {|v| v.to_h}
+          when :minlength,
+               :maxlength,
+               :length,
+               :mininclusive,
+               :maxinclusive,
+               :minexclusive,
+               :maxexclusive,
+               :totaldigits,
+               :fractiondigits  then obj[op.first.to_s] = op.last.object
+          when :min, :max       then obj[op.first.to_s] = op.last
+          when :base, :prefix
+            # Ignore base and prefix
+          when Symbol           then obj[sym.to_s] = Array(op[1..-1]).map(&:to_h)
+          else
+            raise "Expected array to start with a symbol for #{self}"
+          end
+        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 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
+          else
+            raise "How to serialize Value #{op.inspect} to json for #{self}"
+          end
+        when Symbol
+          case self
+          when NodeConstraint   then obj['nodeKind'] = op.to_s
+          when Shape            then obj['closed'] = true
+          when TripleConstraint then obj['inverse'] = true
+          else
+            raise "How to serialize Symbol #{op.inspect} to json for #{self}"
+          end
+        when TripleConstraint, EachOf, OneOf, Inclusion
+          case self
+          when EachOf, OneOf
+            (obj['expressions'] ||= []) << op.to_h
+          else
+            obj['expression'] = op.to_h
+          end
+        when NodeConstraint
+          case self
+          when And, Or
+            (obj['shapeExprs'] ||= []) << op.to_h
+          else
+            obj['valueExpr'] = op.to_h
+          end
+        when And, Or, Shape, Not, ShapeRef
+          case self
+          when And, Or
+            (obj['shapeExprs'] ||= []) << op.to_h
+          when TripleConstraint
+            obj['valueExpr'] = op.to_h
+          else
+            obj['shapeExpr'] = op.to_h
+          end
+        when Value
+          obj['values'] ||= []
+          Array(op).map {|o| o.operands}.flatten.each do |oo|
+            obj['values'] << serialize_value(oo)
+          end
+        else
+          raise "How to serialize #{op.inspect} to json for #{self}"
+        end
+      end
+      obj
+    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
+      @options[:base_uri]
+    end
+
+    # Create URIs
+    # @param [RDF::Value, String] value
+    # @param [Hash{Symbol => Object}] options
+    # @option options [RDF::URI] :base_uri
+    # @option options [Hash{String => RDF::URI}] :prefixes
+    # @option options [JSON::LD::Context] :context
+    # @return [RDF::Value]
+    def iri(value, options = @options)
+      self.class.iri(value, options)
+    end
+
+    # Create URIs
+    # @param  (see #iri)
+    # @option (see #iri)
+    # @return (see #iri)
+    def self.iri(value, options)
+      # If we have a base URI, use that when constructing a new URI
+      base_uri = options[:base_uri]
+
+      case value
+      when Hash
+        # A JSON-LD node reference
+        v = options[:context].expand_value(value)
+        raise "Expected #{value.inspect} to be a JSON-LD Node Reference" unless JSON::LD::Utils.node_reference?(v)
+        self.iri(v['@id'], options)
+      when RDF::URI
+        if base_uri && value.relative?
+          base_uri.join(value)
+        else
+          value
+        end
+      when RDF::Value then value
+      when /^_:/ then
+        id = value[2..-1].to_s
+        RDF::Node.intern(id)
+      when /^(\w+):(\S+)$/
+        prefixes = options.fetch(:prefixes, {})
+        if prefixes.has_key?($1)
+          prefixes[$1].join($2)
+        elsif RDF.type == value
+          a = RDF.type.dup; a.lexical = 'a'; a
+        elsif options[:context]
+          options[:context].expand_iri(value, vocab: true)
+        else
+          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
+          base_uri.join(value)
+        else
+          RDF::URI(value)
+        end
+      end
+    end
+
+    # Create Values, with "clever" matching to see if it might be a value, IRI or BNode.
+    # @param [RDF::Value, String] value
+    # @param [Hash{Symbol => Object}] options
+    # @option options [RDF::URI] :base_uri
+    # @option options [Hash{String => RDF::URI}] :prefixes
+    # @return [RDF::Value]
+    def value(value, options = @options)
+      self.class.value(value, options)
+    end
+
+    # Create Values, with "clever" matching to see if it might be a value, IRI or BNode.
+    # @param  (see #value)
+    # @option (see #value)
+    # @return (see #value)
+    def self.value(value, options)
+      # If we have a base URI, use that when constructing a new URI
+      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'])
+        else
+          ShEx::Algebra.from_shexj(value, options)
+        end
+      else iri(value, options)
+      end
+    end
+
+    ##
+    # Serialize a value, either as JSON, or as modififed N-Triples
+    #
+    # @param [RDF::Value, Operator] value
+    # @return [String]
+    def serialize_value(value)
+      case value
+        when RDF::Literal
+          {'value' => value.to_s}.
+          merge(value.has_datatype? ? {'type' => value.datatype.to_s} : {}).
+          merge(value.has_language? ? {'language' => value.language.to_s} : {})
+        when RDF::Resource
+          value.to_s
+        else value.to_h
+      end
+    end
+
     ##
     # Returns a developer-friendly representation of this operator.
     #
@@ -243,6 +545,12 @@ module ShEx::Algebra
     # @return [Enumerator]
     def each_descendant(depth = 0, &block)
       if block_given?
+
+        case block.arity
+        when 1 then block.call(self)
+        else block.call(depth, self)
+        end
+
         operands.each do |operand|
           case operand
           when Array
@@ -252,11 +560,6 @@ module ShEx::Algebra
           else
             operand.each_descendant(depth + 1, &block) if operand.respond_to?(:each_descendant)
           end
-
-          case block.arity
-          when 1 then block.call(operand)
-          else block.call(depth, operand)
-          end
         end
       end
       enum_for(:each_descendant)
@@ -296,6 +599,19 @@ module ShEx::Algebra
       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
+    end
+
     ##
     # A unary operator.
     #