sparql 1.1.6 → 1.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7a1d4a5797ead6402462b84ed480cca4a748f2cb
-  data.tar.gz: 86cae5d9912179a3e8c08ac5d0b92ac3949787fe
+  metadata.gz: f8e188130c333370c626f037f5c2312a222b5f3d
+  data.tar.gz: 61c0398d56e8e2891dc97d4a8843411c5912e0d6
 SHA512:
-  metadata.gz: 69ef15c1ef1a15a051fb7f9837d2a4bb584c4d557ce4d52958cd214752eae33c80d0e87e5cdbf98527b4c8bb73041969ec3f2b2d2790386459a08b7c3a7baa60
-  data.tar.gz: 088b6db9ad1d2e7c1019956bd112be2abafbf1fcf4004c4a410ac5eb6a402a0c36e7a80b4f8d73b66ac0fa584683b9406494a1ba7552139a7dfd1d245d39b155
+  metadata.gz: 9398d997c21707cfaeef51fb8fd5dd11008e0d23bcc81ee8f9027d98ee37297b19735b4c4a6202cbf241c7faf811510af0dbf588742bcaf2389cfdda1488027a
+  data.tar.gz: 03a7de12fa45056026eff0a2d93bfc92d375173c6afabfc462e223f10f5ea75f4ef943d22a9621aa84836b07703be4d4ee2206b917206edba70648af30f79723

data/README.md

@@ -9,7 +9,7 @@ This is a [Ruby][] implementation of [SPARQL][] for [RDF.rb][].
 ## Features
 
 * 100% free and unencumbered [public domain](http://unlicense.org/) software.
-* [SPARQL 1.1 Query][] parsing and execution (excluding [Property Paths][])
+* Complete [SPARQL 1.1 Query][] parsing and execution
 * SPARQL results as [XML][SPARQL XML], [JSON][SPARQL JSON],
   [CSV][SPARQL 1.1 Query Results CSV and TSV Formats],
   [TSV][SPARQL 1.1 Query Results CSV and TSV Formats]
@@ -21,6 +21,7 @@ This is a [Ruby][] implementation of [SPARQL][] for [RDF.rb][].
 * [Rack][] and [Sinatra][] middleware to perform [HTTP content negotiation][conneg] for result formats
   * Compatible with any [Rack][] or [Sinatra][] application and any Rack-based framework.
   * Helper method for describing [SPARQL Service Description][SSD]
+* Implementation Report: {file:etc/earl.html EARL}
 * Compatible with Ruby >= 1.9.3.
 * Compatible with older Ruby versions with the help of the [Backports][] gem.
 * Supports Unicode query strings both on all versions of Ruby.
@@ -30,8 +31,6 @@ This is a [Ruby][] implementation of [SPARQL][] for [RDF.rb][].
 The {SPARQL} gem implements [SPARQL 1.1 Query][], and [SPARQL 1.1 Update][], and provides [Rack][] and [Sinatra][] middleware to provide results using [HTTP Content Negotiation][conneg].
 
 * {SPARQL::Grammar} implements a [SPARQL 1.1 Query][] and [SPARQL 1.1 Update][] parser generating [SPARQL S-Expressions (SSE)][SSE].
-  * Support for [Property Paths][] is excluded.
-    See the section on [SPARQL 1.1 Query][] extensions and limitations for further detail.
 * {SPARQL::Algebra} executes SSE against Any `RDF::Graph` or `RDF::Repository`, including compliant [RDF.rb][] repository adaptors such as [RDF::DO][] and [RDF::Mongo][].
 * {Rack::SPARQL} and {Sinatra::SPARQL} provide middleware components to format results using an appropriate format based on [HTTP content negotiation][conneg].
 
@@ -53,13 +52,13 @@ The SPARQL gem now implements the following [SPARQL 1.1 Query][] operations:
 * [Inline Data](http://www.w3.org/TR/2013/REC-sparql11-query-20130321/#inline-data)
 * [Exists](http://www.w3.org/TR/2013/REC-sparql11-query-20130321/#func-filter-exists)
 * [Negation](http://www.w3.org/TR/2013/REC-sparql11-query-20130321/#negation)
+* [Property Paths](http://www.w3.org/TR/2013/REC-sparql11-query-20130321/#propertypaths)
 
 The gem also includes the following [SPARQL 1.1 Update][] operations:
 * [Graph Update](http://www.w3.org/TR/sparql11-update/#graphUpdate)
 * [Graph Management](http://www.w3.org/TR/sparql11-update/#graphManagement)
 
-The only major area of [SPARQL 1.1 Query][] missing is
-[Property Paths][], which will be in later release along with:
+Not supported:
 
 * [Federated Query][SPARQL 1.1 Federated Query],
 * [Entailment Regimes][SPARQL 1.1 Entailment Regimes],
@@ -337,7 +336,6 @@ A copy of the [SPARQL 1.0 tests][] and [SPARQL 1.1 tests][] are also included in
 [SPARQL XML]:       http://www.w3.org/TR/rdf-sparql-XMLres/
 [SPARQL JSON]:      http://www.w3.org/TR/rdf-sparql-json-res/
 [SPARQL EBNF]:      http://www.w3.org/TR/sparql11-query/#sparqlGrammar
-[Property Paths]:   http://www.w3.org/TR/2013/REC-sparql11-query-20130321/#propertypaths
 
 [SSD]:              http://www.w3.org/TR/sparql11-service-description/
 [Rack]:             http://rack.rubyforge.org/

data/VERSION

@@ -1 +1 @@
-1.1.6
+1.1.7

data/lib/sparql/algebra/expression.rb

@@ -120,7 +120,7 @@ module SPARQL; module Algebra
       end
 
       debug(options) {"#{operator.inspect}(#{operands.map(&:inspect).join(',')})"}
-      options.delete_if {|k, v| [:debug, :depth, :prefixes, :base_uri, :update].include?(k) }
+      options.delete_if {|k, v| [:debug, :depth, :prefixes, :base_uri, :update, :validate].include?(k) }
       operands << options unless options.empty?
       operator.new(*operands)
     end
@@ -317,7 +317,33 @@ module SPARQL; module Algebra
     def to_sxp_bin
       self
     end
-    
+
+    ##
+    # Is this value valid, and composed only of valid components?
+    #
+    # @return [Boolean] `true` or `false`
+    def valid?
+      true
+    end
+
+    ##
+    # Is this value invalid, or is it composed of any invalid components?
+    #
+    # @return [Boolean] `true` or `false`
+    def invalid?
+      !valid?
+    end
+
+    ##
+    # Default validate! implementation, overridden in concrete classes
+    # @return [SPARQL::Algebra::Expression] `self`
+    # @raise  [ArgumentError] if the value is invalid
+    def validate!
+      raise ArgumentError if invalid?
+      self
+    end
+    alias_method :validate, :validate!
+
     private
     # @overload: May be called with node, message and an option hash
     #   @param [String] node processing node

data/lib/sparql/algebra/extensions.rb

@@ -135,6 +135,37 @@ class Array
     end
     self
   end
+
+  ##
+  # Return the non-destinguished variables contained within this Array
+  # @return [Array<RDF::Query::Variable>]
+  def ndvars
+    vars.reject(&:distinguished?)
+  end
+
+  ##
+  # Return the variables contained within this Array
+  # @return [Array<RDF::Query::Variable>]
+  def vars
+    select {|o| o.respond_to?(:vars)}.map(&:vars).flatten.compact
+  end
+
+  ##
+  # Is this value composed only of valid components?
+  #
+  # @return [Boolean] `true` or `false`
+  def valid?
+    all? {|e| e.respond_to?(:valid?) ? e.valid? : true}
+  end
+
+  ##
+  # Validate all components.
+  # @return [Array] `self`
+  # @raise  [ArgumentError] if the value is invalid
+  def validate!
+    each {|e| e.validate! if e.respond_to?(:validate!)}
+    self
+  end
 end
 
 ##
@@ -199,6 +230,20 @@ module RDF::Term
       (language == other.language || dtr == RDF::XSD.string) :
       dtr == RDF::XSD.string
   end
+
+  ##
+  # Return the non-destinguished variables contained within this operator
+  # @return [Array<RDF::Query::Variable>]
+  def ndvars
+    vars.reject(&:distinguished?)
+  end
+
+  ##
+  # Return the variables contained within this operator
+  # @return [Array<RDF::Query::Variable>]
+  def vars
+    variable? ? [self] : []
+  end
 end # RDF::Term
 
 # Override RDF::Queryable to execute against SPARQL::Algebra::Query elements as well as RDF::Query and RDF::Pattern
@@ -311,6 +356,20 @@ class RDF::Query
   def query_yields_solutions?
     true
   end
+
+  ##
+  # Return the non-destinguished variables contained within patterns
+  # @return [Array<RDF::Query::Variable>]
+  def ndvars
+    patterns.map(&:ndvars).flatten
+  end
+
+  ##
+  # Return the variables contained within patterns
+  # @return [Array<RDF::Query::Variable>]
+  def vars
+    patterns.map(&:vars).flatten
+  end
 end
 
 class RDF::Query::Pattern
@@ -323,6 +382,20 @@ class RDF::Query::Pattern
       [:triple, subject, predicate, object]
     end
   end
+
+  ##
+  # Return the non-destinguished variables contained within this pattern
+  # @return [Array<RDF::Query::Variable>]
+  def ndvars
+    vars.reject(&:distinguished?)
+  end
+
+  ##
+  # Return the variables contained within this pattern
+  # @return [Array<RDF::Query::Variable>]
+  def vars
+    variables.values
+  end
 end
 
 ##

data/lib/sparql/algebra/operator.rb

@@ -85,6 +85,17 @@ module SPARQL; module Algebra
     autoload :Subtract,           'sparql/algebra/operator/subtract'
     autoload :UCase,              'sparql/algebra/operator/ucase'
 
+    # Property Paths
+    autoload :Alt,                'sparql/algebra/operator/alt'
+    autoload :NotOneOf,           'sparql/algebra/operator/notoneof'
+    autoload :PathOpt,            'sparql/algebra/operator/path_opt'
+    autoload :PathPlus,           'sparql/algebra/operator/path_plus'
+    autoload :PathStar,           'sparql/algebra/operator/path_star'
+    autoload :Path,               'sparql/algebra/operator/path'
+    autoload :Reverse,            'sparql/algebra/operator/reverse'
+    autoload :Seq,                'sparql/algebra/operator/seq'
+    autoload :Sequence,           'sparql/algebra/operator/sequence'
+
     # Miscellaneous
     autoload :Asc,                'sparql/algebra/operator/asc'
     autoload :Coalesce,           'sparql/algebra/operator/coalesce'
@@ -159,6 +170,7 @@ module SPARQL; module Algebra
         when :>=              then GreaterThanOrEqual
         when :abs             then Abs
         when :add             then Add
+        when :alt             then Alt
         when :and, :'&&'      then And
         when :avg             then Avg
         when :bnode           then BNode
@@ -195,18 +207,26 @@ module SPARQL; module Algebra
         when :month           then Month
         when :multiply        then Multiply
         when :not, :'!'       then Not
-        when :notexists      then NotExists
+        when :notexists       then NotExists
         when :notin           then NotIn
+        when :notoneof        then NotOneOf
         when :now             then Now
         when :or, :'||'       then Or
+        when :path            then Path
+        when :path?           then PathOpt
+        when :"path*"         then PathStar
+        when :"path+"         then PathPlus
         when :plus            then Plus
         when :rand            then Rand
         when :regex           then Regex
         when :replace         then Replace
+        when :reverse         then Reverse
         when :round           then Round
         when :sameterm        then SameTerm
         when :sample          then Sample
         when :seconds         then Seconds
+        when :seq             then Seq
+        when :sequence        then Sequence
         when :sha1            then SHA1
         when :sha256          then SHA256
         when :sha512          then SHA512
@@ -322,7 +342,11 @@ module SPARQL; module Algebra
       @options  = operands.last.is_a?(Hash) ? operands.pop.dup : {}
       @operands = operands.map! do |operand|
         case operand
+          when Array
+            operand.each {|op| op.parent = self if operand.respond_to?(:parent=)}
+            operand
           when Operator, Variable, RDF::Term, RDF::Query, RDF::Query::Pattern, Array, Symbol
+            operand.parent = self if operand.respond_to?(:parent=)
             operand
           when TrueClass, FalseClass, Numeric, String, DateTime, Date, Time
             RDF::Literal(operand)
@@ -387,12 +411,6 @@ module SPARQL; module Algebra
       @prefixes = hash
     end
 
-    ##
-    # Any additional options for this operator.
-    #
-    # @return [Hash]
-    attr_reader :options
-
     ##
     # The operands to this operator.
     #
@@ -540,7 +558,7 @@ module SPARQL; module Algebra
     #
     # @return [String]
     def inspect
-      sprintf("#<%s:%#0x(%s)>", self.class.name, __id__, operands.map(&:inspect).join(', '))
+      sprintf("#<%s:%#0x(%s)>", self.class.name, __id__, operands.to_sse.gsub(/\s+/m, ' '))
     end
 
     ##
@@ -552,7 +570,21 @@ module SPARQL; module Algebra
     alias_method :==, :eql?
 
     ##
-    # Iterate via deapth-first recursive descent over operands, yielding each operator
+    # Return the non-destinguished variables contained within this operator
+    # @return [Array<RDF::Query::Variable>]
+    def ndvars
+      vars.reject(&:distinguished?)
+    end
+
+    ##
+    # Return the variables contained within this operator
+    # @return [Array<RDF::Query::Variable>]
+    def vars
+      operands.select {|o| o.respond_to?(:vars)}.map(&:vars).flatten
+    end
+
+    ##
+    # Iterate via depth-first recursive descent over operands, yielding each operator
     # @yield operator
     # @yieldparam [Object] operator
     def descendants(&block)
@@ -569,6 +601,38 @@ module SPARQL; module Algebra
         block.call(operand)
       end
     end
+
+    ##
+    # Parent expression, if any
+    #
+    # @return [Operator]
+    def parent; @options[:parent]; end
+
+    ##
+    # Parent operator, if any
+    #
+    # @return [Operator]
+    def parent=(operator)
+      @options[:parent]= operator
+    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
+
+    ##
+    # Validate all operands, operator specific classes should override for operator-specific validation
+    # @return [SPARQL::Algebra::Expression] `self`
+    # @raise  [ArgumentError] if the value is invalid
+    def validate!
+      operands.each {|op| op.validate! if op.respond_to?(:validate!)}
+      self
+    end
   protected
 
     ##

data/lib/sparql/algebra/operator/alt.rb

@@ -0,0 +1,58 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL Property Path `alt` (Alternative Property Path) operator.
+    #
+    # @example
+    #   (alt a b)
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#defn_evalPP_alternative
+    class Alt < Operator::Binary
+      include Query
+      
+      NAME = :alt
+
+      ##
+      # Equivalent to:
+      #
+      #    (path x (alt :p :q) y)
+      #     => (union (bgp (x :p y)) (bgp (x :q y)))
+      #
+      # @param  [RDF::Queryable] queryable
+      #   the graph or repository to query
+      # @param  [Hash{Symbol => Object}] options
+      #   any additional keyword options
+      # @option options [RDF::Term, RDF::Variable] :subject
+      # @option options [RDF::Term, RDF::Variable] :object
+      # @yield  [solution]
+      #   each matching solution
+      # @yieldparam  [RDF::Query::Solution] solution
+      # @yieldreturn [void] ignored
+      # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
+      def execute(queryable, options = {}, &block)
+        subject, object = options[:subject], options[:object]
+        debug(options) {"Alt #{[subject, operands, object].to_sse}"}
+
+        # Solutions where predicate exists
+        qa = if operand(0).is_a?(RDF::Term)
+          RDF::Query.new do |q|
+            q.pattern [subject, operand(0), object]
+          end
+        else
+          operand(0)
+        end
+
+        qb = if operand(1).is_a?(RDF::Term)
+          RDF::Query.new do |q|
+            q.pattern [subject, operand(1), object]
+          end
+        else
+          operand(1)
+        end
+
+        query = Union.new(qa, qb)
+        queryable.query(query, options.merge(depth: options[:depth].to_i + 1), &block)
+      end
+    end # Alt
+  end # Operator
+end; end # SPARQL::Algebra

data/lib/sparql/algebra/operator/extend.rb

@@ -41,10 +41,10 @@ module SPARQL; module Algebra
       # @see http://www.w3.org/TR/rdf-sparql-query/#evaluation
       def execute(queryable, options = {}, &block)
         debug(options) {"Extend"}
-        @solutions = operands.last.execute(queryable, options.merge(depth: options[:depth].to_i + 1))
+        @solutions = operand(1).execute(queryable, options.merge(depth: options[:depth].to_i + 1))
         @solutions.each do |solution|
           debug(options) {"===> soln #{solution.to_hash.inspect}"}
-          operands.first.each do |(var, expr)|
+          operand(0).each do |(var, expr)|
             begin
               val = expr.evaluate(solution, options.merge(
                                               queryable: queryable,
@@ -60,7 +60,19 @@ module SPARQL; module Algebra
         @solutions.each(&block) if block_given?
         @solutions
       end
-      
+
+      # The variable introduced by the BIND clause must not have been used in the group graph pattern up to the point of use in BIND
+      def validate!
+        bind_vars = operand(0).map(&:first)
+        query_vars = operand(1).vars
+        
+        unless (bind_vars.compact & query_vars.compact).empty?
+          raise ArgumentError,
+               "bound variable used in query: #{(bind_vars.compact & query_vars.compact).to_sse}"
+        end
+        super
+      end
+
       ##
       # Returns an optimized version of this query.
       #

data/lib/sparql/algebra/operator/filter.rb

@@ -52,7 +52,24 @@ module SPARQL; module Algebra
         @solutions.each(&block) if block_given?
         @solutions
       end
-      
+
+      # If filtering a join of two BGPs (having the same graph name), don't worry about validating, for shared ndvars, anyway,
+      #
+      #       (filter (regex ?homepage "^http://example.org/" "")
+      #         (join
+      #           (bgp (triple ??who :homepage ?homepage))
+      #           (bgp (triple ??who :schoolHomepage ?schoolPage))))))
+      #
+      # is legitimate
+      def validate!
+        unless (join = operands.last).is_a?(Join) &&
+                join.operands.all? {|op| op.is_a?(RDF::Query)} &&
+                join.operands.map(&:context).uniq.length == 1
+          operands.last.validate!
+        end
+        self
+      end
+
       ##
       # Returns an optimized version of this query.
       #