shex 0.6.0 → 0.6.4

data/lib/shex/algebra/operator.rb

@@ -35,8 +35,8 @@ module ShEx::Algebra
     #   @option options [RDF::Resource] :id
     #     Identifier of the operator
     # @raise  [TypeError] if any operand is invalid
-    def initialize(*operands)
-      @options  = operands.last.is_a?(Hash) ? operands.pop.dup : {}
+    def initialize(*operands, **options)
+      @options  = options.dup
       @operands = operands.map! do |operand|
         case operand
           when Array
@@ -221,12 +221,19 @@ module ShEx::Algebra
     end
 
     ##
-    # The optional TripleExpression for this Shape.
-    # @return [TripleExpression]
+    # The first expression from {#expressions}.
+    # @return [RDF::Resource, Operand]
     def expression
       expressions.first
     end
 
+    ##
+    # References are all operands which are RDF::Resource
+    # @return [RDF::Resource, Operand]
+    def references
+      @references = operands.select {|op| op.is_a?(RDF::Resource)}
+    end
+
     ##
     # Returns the binary S-Expression (SXP) representation of this operator.
     #
@@ -243,11 +250,6 @@ module ShEx::Algebra
     #
     # @return [String]
     def to_sxp
-      begin
-        require 'sxp' # @see http://rubygems.org/gems/sxp
-      rescue LoadError
-        abort "SPARQL::Algebra::Operator#to_sxp requires the SXP gem (hint: `gem install sxp')."
-      end
       require 'sparql/algebra/sxp_extensions'
 
       to_sxp_bin.to_sxp
@@ -335,7 +337,7 @@ module ShEx::Algebra
         end
       end
 
-      new(*operands, options.merge(id: id))
+      new(*operands, **options.merge(id: id))
     end
 
     def json_type
@@ -432,6 +434,8 @@ module ShEx::Algebra
           case self
           when And, Or
             (obj['shapeExprs'] ||= []) << op.to_h
+          when Not
+            obj['shapeExpr'] = op.to_h
           else
             obj['valueExpr'] = op.to_h
           end
@@ -593,23 +597,23 @@ module ShEx::Algebra
 
     ##
     # Enumerate via depth-first recursive descent over operands, yielding each operator
-    # @param [Integer] depth incrementeded for each depth of operator, and provided to block if Arity is 2
+    # @param [Boolean] include_self
     # @yield operator
     # @yieldparam [Object] operator
     # @return [Enumerator]
-    def each_descendant(&block)
+    def each_descendant(include_self = false, &block)
       if block_given?
 
-        block.call(self)
+        block.call(self) if include_self
 
         operands.each do |operand|
           case operand
           when Array
             operand.each do |op|
-              op.each_descendant(&block) if op.respond_to?(:each_descendant)
+              op.each_descendant(true, &block) if op.respond_to?(:each_descendant)
             end
           else
-            operand.each_descendant(&block) if operand.respond_to?(:each_descendant)
+            operand.each_descendant(true, &block) if operand.respond_to?(:each_descendant)
           end
         end
       end
@@ -632,6 +636,14 @@ module ShEx::Algebra
       @options[:parent]= operator
     end
 
+    ##
+    # Find a ShapeExpression or TripleExpression by identifier
+    # @param [#to_s] id
+    # @return [TripleExpression, ShapeExpression]
+    def find(id)
+      each_descendant(false).detect {|op| op.id == id}
+    end
+
     ##
     # Ancestors of this Operator
     # @return [Array<Operator>]
@@ -661,12 +673,12 @@ module ShEx::Algebra
       self
     end
 
-  protected
-    def dup
-      operands = @operands.map {|o| o.dup rescue o}
-      self.class.new(*operands, id: @id)
-    end
+  def dup
+    operands = @operands.map {|o| o.dup rescue o}
+    self.class.new(*operands, id: @id)
+  end
 
+  protected
     ##
     # A unary operator.
     #

data/lib/shex/algebra/or.rb

@@ -67,22 +67,13 @@ module ShEx::Algebra
     end
 
     ##
-    # expressions must be ShapeExpressions
+    # expressions must be ShapeExpressions or references to 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
+      validate_expressions!
+      validate_self_references!
       super
     end
 

data/lib/shex/algebra/schema.rb

@@ -25,8 +25,9 @@ module ShEx::Algebra
     end
 
     # (see Operator#initialize)
-    def initialize(*operands)
+    def initialize(*operands, **options)
       super
+      schema = self
       each_descendant do |op|
         # Set schema everywhere
         op.schema = self
@@ -39,7 +40,7 @@ module ShEx::Algebra
     # @param [RDF::Queryable] graph
     # @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
+    # @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.
@@ -211,14 +212,6 @@ module ShEx::Algebra
       @start ||= operands.detect {|op| op.is_a?(Start)}
     end
 
-    ##
-    # Find a ShapeExpression or TripleExpression by identifier
-    # @param [#to_s] id
-    # @return [TripleExpression, ShapeExpression]
-    def find(id)
-      each_descendant.detect {|op| op.id == id}
-    end
-
     ##
     # Validate shapes, in addition to other operands
     # @return [Operator] `self`
@@ -250,7 +243,7 @@ module ShEx::Algebra
     attr_accessor :expression
 
     # Holds the result of processing a shape
-    # @param [RDF::Resource] label
+    # @param [RDF::Resource] shape
     # @return [ShapeResult]
     def initialize(shape)
       @shape = shape

data/lib/shex/algebra/semact.rb

@@ -18,13 +18,14 @@ module ShEx::Algebra
     ##
     # Called on entry
     #
-    # @param [String] code
-    # @param [Array<RDF::Statement>] arcs_in available statements to be matched having `focus` as an object
-    # @param [Array<RDF::Statement>] arcs_out available statements to be matched having `focus` as a subject
-    # @param [Integer] depth for logging
-    # @param [Hash{Symbol => Object}] options
-    #   Other, operand-specific options
-    # @return [Boolean] Returning `false` results in {ShEx::NotSatisfied} exception
+    # @overload enter(code, arcs_in, arcs_out, logging)
+    #   @param [String] code
+    #   @param [Array<RDF::Statement>] arcs_in available statements to be matched having `focus` as an object
+    #   @param [Array<RDF::Statement>] arcs_out available statements to be matched having `focus` as a subject
+    #   @param [Integer] depth for logging
+    #   @param [Hash{Symbol => Object}] options
+    #     Other, operand-specific options
+    #   @return [Boolean] Returning `false` results in {ShEx::NotSatisfied} exception
     def enter(**options)
       if implementation = schema.extensions[operands.first.to_s]
         implementation.enter(code: operands[0], expression: parent, **options)
@@ -67,7 +68,6 @@ module ShEx::Algebra
     # @param [String] code
     # @param [Array<RDF::Statement>] matched statements matched by this expression
     # @param [Array<RDF::Statement>] unmatched statements considered, but not matched by this expression
-    # @param [ShEx::Algebra::TripleExpression] expression containing this semantic act
     # @param [Integer] depth for logging
     # @param [Hash{Symbol => Object}] options
     #   Other, operand-specific options

data/lib/shex/algebra/shape.rb

@@ -36,8 +36,8 @@ module ShEx::Algebra
       # 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: focus).to_a.sort_by(&:to_sxp)
-      arcs_out = schema.graph.query(subject: focus).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`.
@@ -106,7 +106,7 @@ module ShEx::Algebra
     end
 
     ##
-    # expression must be a TripleExpression
+    # expression must be a TripleExpression and must not reference itself recursively.
     #
     # @return [Operator] `self`
     # @raise  [ShEx::StructureError] if the value is invalid
@@ -118,8 +118,10 @@ module ShEx::Algebra
         ref.is_a?(TripleExpression) ||
         structure_error("#{json_type} must reference a TripleExpression: #{ref}")
       else
-        structure_error("#{json_type} must reference a TripleExpression: #{ref}")
+        structure_error("#{json_type} must be a TripleExpression or reference: #{expression.to_sxp}")
       end
+      # FIXME: this runs afoul of otherwise legitamate self-references, through a TripleExpression.
+      #!validate_self_references!
       super
     end
 

data/lib/shex/algebra/shape_expression.rb

@@ -15,5 +15,34 @@ module ShEx::Algebra
     def satisfies?(focus, depth: 0, **options)
       raise NotImplementedError, "#satisfies? Not implemented in #{self.class}"
     end
+
+    ##
+    # expressions must be ShapeExpressions or references.
+    #
+    # @raise  [ShEx::StructureError] if the value is invalid
+    def validate_expressions!
+      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 be a ShapeExpression or reference: #{op.to_sxp}")
+        end
+      end
+    end
+
+    ##
+    # An Operator with a label must contain a reference to itself.
+    #
+    # @raise  [ShEx::StructureError] if the shape is invalid
+    def validate_self_references!
+      return # FIXME: needs to stop at a TripleConstraint
+      each_descendant do |op|
+        structure_error("#{json_type} must not reference itself (#{id}): #{op.to_sxp}") if op.references.include?(id)
+      end
+    end
   end
 end

data/lib/shex/algebra/start.rb

@@ -30,20 +30,12 @@ module ShEx::Algebra
     end
 
     ##
-    # expression must be a ShapeExpression
+    # expressions must be ShapeExpressions or references to ShapeExpressions
     #
     # @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
+      validate_expressions!
       super
     end
   end

data/lib/shex/algebra/stem.rb

@@ -66,8 +66,12 @@ module ShEx::Algebra
     NAME = :languageStem
 
     # (see Stem#match?)
+    # If the operand is empty, than any language will do,
+    # otherwise, it matches the substring up to that first '-', if any.
     def match?(value, depth: 0)
-      if value.literal? && value.language.to_s.start_with?(operands.first)
+      if value.literal? &&
+         value.language? &&
+         (operands.first.to_s.empty? || value.language.to_s.match?(%r(^#{operands.first}((-.*)?)$)))
         status "matched #{value}", depth: depth
         true
       else

data/lib/shex/algebra/stem_range.rb

@@ -102,7 +102,9 @@ module ShEx::Algebra
     def match?(value, depth: 0)
       initial_match = case operands.first
       when :wildcard then true
-      when RDF::Literal then value.language.to_s.start_with?(operands.first)
+      when RDF::Literal
+        value.language? &&
+        (operands.first.to_s.empty? || value.language.to_s.match?(%r(^#{operands.first}((-.*)?)$)))
       else false
       end
 

data/lib/shex/algebra/triple_constraint.rb

@@ -97,7 +97,7 @@ module ShEx::Algebra
         ref.is_a?(ShapeExpression) ||
         structure_error("#{json_type} must reference a ShapeExpression: #{ref}")
       else
-        structure_error("#{json_type} must reference a ShapeExpression: #{ref}")
+        structure_error("#{json_type} must be a ShapeExpression or reference: #{expresson.to_sxp}")
       end
       super
     end

data/lib/shex/algebra/triple_expression.rb

@@ -16,6 +16,24 @@ module ShEx::Algebra
       raise NotImplementedError, "#matches Not implemented in #{self.class}"
     end
 
+    ##
+    # expressions must be TripleExpressions or references to TripleExpressions
+    #
+    # @raise  [ShEx::StructureError] if the value is invalid
+    def validate_expressions!
+      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 be a TripleExpression or reference: #{op.to_sxp}")
+        end
+      end
+    end
+
     ##
     # Included TripleConstraints
     # @return [Array<TripleConstraints>]

data/lib/shex/algebra.rb

@@ -1,11 +1,10 @@
 $:.unshift(File.expand_path("../..", __FILE__))
 require 'sparql/algebra'
-require 'sxp'
 
 module ShEx
   # Based on the SPARQL Algebra, operators for executing a patch
   #
-  # @author [Gregg Kellogg](http://greggkellogg.net/)
+  # @author [Gregg Kellogg](https://greggkellogg.net/)
   module Algebra
     autoload :And,              'shex/algebra/and'
     autoload :Annotation,       'shex/algebra/annotation'

data/lib/shex/extensions/test.rb

@@ -6,21 +6,23 @@
 # @see http://shex.io/extensions/Test/
 require 'shex'
 
-class ShEx::Test < ShEx::Extension("http://shex.io/extensions/Test/")
-  # (see ShEx::Extension#visit)
-  def visit(code: nil, matched: nil, depth: 0, **options)
-    str = if md = /^ *(fail|print) *\( *(?:(\"(?:[^\\"]|\\")*\")|([spo])) *\) *$/.match(code.to_s)
-      md[2] || case md[3]
-      when 's' then matched.subject
-      when 'p' then matched.predicate
-      when 'o' then matched.object
-      else          matched.to_sxp
-      end.to_s
-    else
-      matched ? matched.to_sxp : 'no statement'
-    end
+module ShEx
+  Test = Class.new(ShEx::Extension("http://shex.io/extensions/Test/")) do
+    # (see ShEx::Extension#visit)
+    def visit(code: nil, matched: nil, depth: 0, **options)
+      str = if md = /^ *(fail|print) *\( *(?:(\"(?:[^\\"]|\\")*\")|([spo])) *\) *$/.match(code.to_s)
+        md[2] || case md[3]
+        when 's' then matched.subject
+        when 'p' then matched.predicate
+        when 'o' then matched.object
+        else          matched.to_sxp
+        end.to_s
+      else
+        matched ? matched.to_sxp : 'no statement'
+      end
 
-    $stdout.puts str
-    return !md || md[1] == 'print'
+      $stdout.puts str
+      return !md || md[1] == 'print'
+    end
   end
-end
+end

data/lib/shex/format.rb

@@ -4,14 +4,12 @@ module ShEx
   ##
   # ShEx format specification. Note that this format does not define any readers or writers.
   #
-  # @example Obtaining an LD Patch format class
-  #     RDF::Format.for(:shex)           #=> LD::Patch::Format
+  # @example Obtaining an ShEx format class
+  #     RDF::Format.for(:shex)           #=> ShEx::Format
   #     RDF::Format.for("etc/foaf.shex")
   #     RDF::Format.for(file_name:      "etc/foaf.shex")
   #     RDF::Format.for(file_extension: "shex")
   #     RDF::Format.for(content_type:   "application/shex")
-  #
-  # @see http://www.w3.org/TR/ldpatch/
   class Format < RDF::Format
     content_type     'application/shex', extension: :shex
     content_encoding 'utf-8'