sparql 1.1.5 → 1.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 801ecd5a6266884f24b915006b337846b941534d
-  data.tar.gz: 760791e723d11bc30782568248cea6b9695c3a19
+  metadata.gz: 7a1d4a5797ead6402462b84ed480cca4a748f2cb
+  data.tar.gz: 86cae5d9912179a3e8c08ac5d0b92ac3949787fe
 SHA512:
-  metadata.gz: 721f8cb66c8b0530492644664208e5023183825e66594774d6f881d6df5c896dab91d93fdba219e014962db257ecd1b3136e27210f00369a05a36c41ef5378cc
-  data.tar.gz: f6ae985c72d5390502aac98a7f747883b6ed07f66b7e15f6f4b33b727dc46f9857508f1904bdc1a2d838ba6eeb8f06f68bc16da9b0054c6988cef72f0d22031f
+  metadata.gz: 69ef15c1ef1a15a051fb7f9837d2a4bb584c4d557ce4d52958cd214752eae33c80d0e87e5cdbf98527b4c8bb73041969ec3f2b2d2790386459a08b7c3a7baa60
+  data.tar.gz: 088b6db9ad1d2e7c1019956bd112be2abafbf1fcf4004c4a410ac5eb6a402a0c36e7a80b4f8d73b66ac0fa584683b9406494a1ba7552139a7dfd1d245d39b155

data/README.md

@@ -17,29 +17,26 @@ This is a [Ruby][] implementation of [SPARQL][] for [RDF.rb][].
 * SPARQL CONSTRUCT or DESCRIBE serialized based on Format, Extension of Mime Type
   using available RDF Writers (see [Linked Data][])
 * SPARQL Client for accessing remote SPARQL endpoints.
+* SPARQL Update
 * [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]
-* Compatible with Ruby >= 1.9.2.
+* 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.
 
 ## Description
 
-The {SPARQL} gem implements [SPARQL 1.1 Query][], and provides [Rack][] and [Sinatra][]
-middleware to provide results using [HTTP Content Negotiation][conneg].
+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][] parser generating [SPARQL S-Expressions (SSE)][SSE].
+* {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].
+* {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].
 
 ### [SPARQL 1.1 Query][] Extensions and Limitations
-The {SPARQL} gem uses the [SPARQL 1.1 Query][] {file:etc/sparql11.bnf EBNF grammar}, which provides
-much more capability than [SPARQL 1.0][], but has a few limitations:
+The {SPARQL} gem uses the [SPARQL 1.1 Query][] {file:etc/sparql11.html EBNF grammar}, which provides much more capability than [SPARQL 1.0][], but has a few limitations:
 
 * The format for decimal datatypes has changed in [RDF 1.1][]; they may no
   longer have a trailing ".", although they do not need a leading digit.
@@ -57,11 +54,13 @@ The SPARQL gem now implements the following [SPARQL 1.1 Query][] operations:
 * [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)
 
+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:
+[Property Paths][], which will be in later release along with:
 
-* [Update][SPARQL 1.1 Update],
 * [Federated Query][SPARQL 1.1 Federated Query],
 * [Entailment Regimes][SPARQL 1.1 Entailment Regimes],
 * [Protocol][SPARQL 1.1 Protocol], and
@@ -117,11 +116,7 @@ for N-Triples, N-Quads, Turtle, RDF/XML, RDF/JSON, JSON-LD, RDFa, TriG and TriX.
 
 ### Remote datasets
 
-A SPARQL query containing `FROM` or `FROM NAMED` will load the referenced IRI unless the repository
-already contains a context with that same IRI. This is performed using [RDF.rb][] `RDF::Util::File.open_file`
-passing HTTP Accept headers for various available RDF formats. For best results, require [Linked Data][] to enable
-a full set of RDF formats in the `GET` request. Also, consider overriding `RDF::Util::File.open_file` with
-an implementation with support for HTTP Get headers (such as `Net::HTTP`).
+A SPARQL query containing `FROM` or `FROM NAMED` (also `UPDATE` or `UPDATE NAMED`) will load the referenced IRI unless the repository already contains a context with that same IRI. This is performed using [RDF.rb][] `RDF::Util::File.open_file` passing HTTP Accept headers for various available RDF formats. For best results, require [Linked Data][] to enable a full set of RDF formats in the `GET` request. Also, consider overriding `RDF::Util::File.open_file` with an implementation with support for HTTP Get headers (such as `Net::HTTP`).
 
 Queries using datasets are re-written to use the identified graphs for `FROM` and `FROM NAMED` by filtering the results, allowing the use of a repository that contains many graphs without confusing information.
 
@@ -154,6 +149,15 @@ a full set of RDF formats.
       result.inspect
     end
 
+### Updating a respository
+
+    queryable = RDF::Repository.load("etc/doap.ttl")
+    sse = SPARQL.parse(%(
+      PREFIX doap: <http://usefulinc.com/ns/doap#>
+      INSERT DATA { <http://rubygems.org/gems/sparql> doap:implements <http://www.w3.org/TR/sparql11-update/>}
+    ), update: true)
+    sse.execute(queryable)
+
 ### Rendering solutions as JSON, XML, CSV, TSV or HTML
     queryable = RDF::Repository.load("etc/doap.ttl")
     solutions = SPARQL.execute("SELECT * WHERE { ?s ?p ?o }", queryable)
@@ -212,7 +216,7 @@ a full set of RDF formats.
     require 'uri'
 
     get '/' do
-      settings.sparql_options.replace(:standard_prefixes => true)
+      settings.sparql_options.replace(standard_prefixes: true)
       repository = RDF::Repository.new do |graph|
         graph << [RDF::Node.new, RDF::DC.title, "Hello, world!"]
       end
@@ -220,11 +224,11 @@ a full set of RDF formats.
         query = params["query"].to_s.match(/^http:/) ? RDF::Util::File.open_file(params["query"]) : ::URI.decode(params["query"].to_s)
         SPARQL.execute(query, repository)
       else
-        settings.sparql_options.merge!(:prefixes => {
-          :ssd => "http://www.w3.org/ns/sparql-service-description#",
-          :void => "http://rdfs.org/ns/void#"
+        settings.sparql_options.merge!(prefixes: {
+          ssd: "http://www.w3.org/ns/sparql-service-description#",
+          void: "http://rdfs.org/ns/void#"
         })
-        service_description(:repo => repository)
+        service_description(repo: repository)
       end
     end
 
@@ -249,19 +253,19 @@ Full documentation available on [Rubydoc.info][SPARQL doc]
 
 ## Dependencies
 
-* [Ruby](http://ruby-lang.org/) (>= 1.9.2)
-* [RDF.rb](http://rubygems.org/gems/rdf) (>= 1.0.7)
-* [SPARQL::Client](https://rubygems.org/gems/sparql-client) (>= 1.0.3)
-* [SXP](https://rubygems.org/gems/sxp) (>= 0.1.0)
+* [Ruby](http://ruby-lang.org/) (>= 1.9.3)
+* [RDF.rb](http://rubygems.org/gems/rdf) (>= 1.1.12)
+* [SPARQL::Client](https://rubygems.org/gems/sparql-client) (>= 1.1.3)
+* [SXP](https://rubygems.org/gems/sxp) (>= 0.1.3)
 * [Builder](https://rubygems.org/gems/builder) (>= 3.0.0)
-* [JSON](https://rubygems.org/gems/json) (>= 1.5.1)
-* Soft dependency on [Linked Data][] (>= 1.0)
-* Soft dependency on [Nokogiri](http://rubygems.org/gems/nokogiri) (>= 1.5.0)
+* [JSON](https://rubygems.org/gems/json) (>= 1.8.2)
+* Soft dependency on [Linked Data][] (>= 1.1)
+* Soft dependency on [Nokogiri](http://rubygems.org/gems/nokogiri) (>= 1.6.6)
   Falls back to REXML for XML parsing Builder for XML serializing. Nokogiri is much more efficient
 * Soft dependency on [Equivalent XML](https://rubygems.org/gems/equivalent-xml) (>= 0.3.0)
   Equivalent XML performs more efficient comparisons of XML Literals when Nokogiri is included
-* Soft dependency on [Rack][] (>= 1.4.4)
-* Soft dependency on [Sinatra][] (>= 1.3.3)
+* Soft dependency on [Rack][] (>= 1.6.0)
+* Soft dependency on [Sinatra][] (>= 1.4.6)
 
 ## Installation
 

data/VERSION

@@ -1 +1 @@
-1.1.5
+1.1.6

data/bin/sparql

@@ -11,7 +11,7 @@ require 'getoptlong'
 
 def run(input, options = {})
   if options[:debug]
-    puts "input graph:\n#{options[:graph].dump(:ttl, :standard_prefixes => true)}\n" if options[:graph]
+    puts "input graph:\n#{options[:graph].dump(:ttl, standard_prefixes: true)}\n" if options[:graph]
     puts "query:\n#{input}\n"
   end
   options[:graph] ||= RDF::Repository.new
@@ -21,7 +21,7 @@ def run(input, options = {})
   end
 
   query = if options[:sse]
-    SPARQL::Algebra.parse(input, {:debug => options[:debug]})
+    SPARQL::Algebra.parse(input, {debug: options[:debug], update: options[:update]})
   else
     # Only do grammar debugging if we're generating SSE
     SPARQL::Grammar.parse(input, options)
@@ -30,10 +30,10 @@ def run(input, options = {})
   puts ("\nSSE:\n" + query.to_sse) if options[:debug] || options[:to_sse]
 
   unless options[:to_sse]
-    res = query.execute(options[:graph], :debug => options[:debug])
+    res = query.execute(options[:graph], debug: options[:debug])
     puts res.inspect if options[:verbose]
     puts case res
-    when RDF::Graph   then res.dump(:ttl, :base_uri => query.base_uri, :prefixes => query.prefixes, :standard_prefixes => true)
+    when RDF::Graph   then res.dump(:ttl, base_uri: query.base_uri, prefixes: query.prefixes, standard_prefixes: true)
     when RDF::Literal then res.inspect
     else                   res.map {|s| s.bindings.map {|k,v| "#{k}: #{v}"}}.join("\n")
     end
@@ -52,7 +52,7 @@ opts = GetoptLong.new(
 )
 
 options = {
-  :graph => RDF::Repository.new,
+  graph: RDF::Repository.new,
 }
 
 input = nil
@@ -65,6 +65,7 @@ opts.each do |opt, arg|
   when '--sse'           then options[:sse] = true
   when '--to-sse'        then options[:to_sse] = true
   when '--debug'         then options[:debug] = true
+  when '--update'        then options[:update] = true
   when '--verbose'       then options[:verbose] = true
   when "--help"
     puts "Usage: #{$0} [options] file-or-uri ..."
@@ -76,6 +77,7 @@ opts.each do |opt, arg|
     puts "      --sse:                Input is in SSE format"
     puts "      --to-sse:             Generate SSE instead of running query"
     puts "      --debug:              Display detailed debug output"
+    puts "      --update:             Process query as a SPARQL Update"
     puts "      --verbose:            Display details of processing"
     puts "      --help,-?:            This message"
     exit(0)
@@ -88,7 +90,7 @@ if ARGV.empty?
 else
   ARGV.each do |test_file|
     puts "parse #{test_file}"
-    run(RDF::Util::File.open_file(test_file).read, options.merge(:base_uri => RDF::URI(test_file)))
+    run(RDF::Util::File.open_file(test_file).read, options.merge(base_uri: RDF::URI(test_file)))
   end
 end
 puts

data/lib/sparql.rb

@@ -21,13 +21,15 @@ module SPARQL
   #
   # @param  [IO, StringIO, String, #to_s]  query
   # @param  [Hash{Symbol => Object}] options
+  # @option options [Boolean] :update (false)
+  #   Parse starting with UpdateUnit production, QueryUnit otherwise.
   # @return [SPARQL::Query]
   #   The resulting query may be executed against
   #   a `queryable` object such as an RDF::Graph
   #   or RDF::Repository. 
   # @raise  [Parser::Error] on invalid input
   def self.parse(query, options = {})
-    query = Grammar::Parser.new(query, options).parse
+    query = Grammar::Parser.new(query, options).parse(options[:update] ? :UpdateUnit : :QueryUnit)
   end
 
   ##
@@ -82,7 +84,7 @@ module SPARQL
         queryable.load(uri)
       end
       [options[:named_graph_uri]].flatten.each do |uri|
-        queryable.load(uri, :context => uri)
+        queryable.load(uri, context: uri)
       end
     end
     query.execute(queryable, &block)

data/lib/sparql/algebra.rb

@@ -176,7 +176,7 @@ module SPARQL
   #     solutions = RDF::Query.execute(RDF::Graph.load('etc/doap.ttl')) do |query|
   #       query.pattern [:person, RDF.type,  RDF::FOAF.Person]
   #       query.pattern [:person, RDF::FOAF.name, :name]
-  #       query.pattern [:person, RDF::FOAF.mbox, :email], :optional => true
+  #       query.pattern [:person, RDF::FOAF.mbox, :email], optional: true
   #     end
   # 
   #     # Find people who have a name but don't have a known e-mail address:
@@ -209,8 +209,8 @@ module SPARQL
   # Expressions can optionally be [memoized][memoization], which can speed up
   # repeatedly executing the expression on a solution sequence:
   # 
-  #     SPARQL::Algebra::Expression.parse(sse, :memoize => true)
-  #     Operator.new(*operands, :memoize => true)
+  #     SPARQL::Algebra::Expression.parse(sse, memoize: true)
+  #     Operator.new(*operands, memoize: true)
   # 
   # Memoization is implemented using RDF.rb's [RDF::Util::Cache][] utility
   # library, a weak-reference cache that allows values contained in the cache to
@@ -225,58 +225,127 @@ module SPARQL
   # ## Documentation
   # 
   # * {SPARQL::Algebra}
+  #   * {SPARQL::Algebra::Aggregate}
+  #   * {SPARQL::Algebra::Evaluatable}
   #   * {SPARQL::Algebra::Expression}
   #   * {SPARQL::Algebra::Query}
+  #   * {SPARQL::Algebra::Update}
   #   * {SPARQL::Algebra::Operator}
+  #     * {SPARQL::Algebra::Operator::Abs}
   #     * {SPARQL::Algebra::Operator::Add}
   #     * {SPARQL::Algebra::Operator::And}
   #     * {SPARQL::Algebra::Operator::Asc}
   #     * {SPARQL::Algebra::Operator::Ask}
+  #     * {SPARQL::Algebra::Operator::Avg}
   #     * {SPARQL::Algebra::Operator::Base}
+  #     * {SPARQL::Algebra::Operator::BGP}
   #     * {SPARQL::Algebra::Operator::Bound}
+  #     * {SPARQL::Algebra::Operator::Ceil}
+  #     * {SPARQL::Algebra::Operator::Clear}
+  #     * {SPARQL::Algebra::Operator::Coalesce}
   #     * {SPARQL::Algebra::Operator::Compare}
+  #     * {SPARQL::Algebra::Operator::Concat}
   #     * {SPARQL::Algebra::Operator::Construct}
+  #     * {SPARQL::Algebra::Operator::Contains}
+  #     * {SPARQL::Algebra::Operator::Copy}
+  #     * {SPARQL::Algebra::Operator::Count}
+  #     * {SPARQL::Algebra::Operator::Create}
   #     * {SPARQL::Algebra::Operator::Dataset}
   #     * {SPARQL::Algebra::Operator::Datatype}
+  #     * {SPARQL::Algebra::Operator::Day}
+  #     * {SPARQL::Algebra::Operator::Delete}
+  #     * {SPARQL::Algebra::Operator::DeleteData}
+  #     * {SPARQL::Algebra::Operator::DeleteWhere}
   #     * {SPARQL::Algebra::Operator::Desc}
   #     * {SPARQL::Algebra::Operator::Describe}
   #     * {SPARQL::Algebra::Operator::Distinct}
   #     * {SPARQL::Algebra::Operator::Divide}
+  #     * {SPARQL::Algebra::Operator::Drop}
+  #     * {SPARQL::Algebra::Operator::EncodeForURI}
   #     * {SPARQL::Algebra::Operator::Equal}
   #     * {SPARQL::Algebra::Operator::Exprlist}
+  #     * {SPARQL::Algebra::Operator::Extend}
   #     * {SPARQL::Algebra::Operator::Filter}
+  #     * {SPARQL::Algebra::Operator::Floor}
   #     * {SPARQL::Algebra::Operator::Graph}
   #     * {SPARQL::Algebra::Operator::GreaterThan}
   #     * {SPARQL::Algebra::Operator::GreaterThanOrEqual}
+  #     * {SPARQL::Algebra::Operator::Group}
+  #     * {SPARQL::Algebra::Operator::GroupConcat}
+  #     * {SPARQL::Algebra::Operator::Hours}
+  #     * {SPARQL::Algebra::Operator::If}
+  #     * {SPARQL::Algebra::Operator::In}
+  #     * {SPARQL::Algebra::Operator::Insert}
+  #     * {SPARQL::Algebra::Operator::InsertData}
+  #     * {SPARQL::Algebra::Operator::IRI}
   #     * {SPARQL::Algebra::Operator::IsBlank}
   #     * {SPARQL::Algebra::Operator::IsIRI}
   #     * {SPARQL::Algebra::Operator::IsLiteral}
+  #     * {SPARQL::Algebra::Operator::IsNumeric}
   #     * {SPARQL::Algebra::Operator::Join}
   #     * {SPARQL::Algebra::Operator::Lang}
   #     * {SPARQL::Algebra::Operator::LangMatches}
   #     * {SPARQL::Algebra::Operator::LeftJoin}
   #     * {SPARQL::Algebra::Operator::LessThan}
   #     * {SPARQL::Algebra::Operator::LessThanOrEqual}
+  #     * {SPARQL::Algebra::Operator::Max}
+  #     * {SPARQL::Algebra::Operator::MD5}
+  #     * {SPARQL::Algebra::Operator::Min}
   #     * {SPARQL::Algebra::Operator::Minus}
+  #     * {SPARQL::Algebra::Operator::Minutes}
+  #     * {SPARQL::Algebra::Operator::Modify}
+  #     * {SPARQL::Algebra::Operator::Month}
+  #     * {SPARQL::Algebra::Operator::Move}
   #     * {SPARQL::Algebra::Operator::Multiply}
+  #     * {SPARQL::Algebra::Operator::Negate}
   #     * {SPARQL::Algebra::Operator::Not}
   #     * {SPARQL::Algebra::Operator::NotEqual}
+  #     * {SPARQL::Algebra::Operator::NotExists}
+  #     * {SPARQL::Algebra::Operator::NotIn}
+  #     * {SPARQL::Algebra::Operator::Now}
   #     * {SPARQL::Algebra::Operator::Or}
   #     * {SPARQL::Algebra::Operator::Order}
   #     * {SPARQL::Algebra::Operator::Plus}
   #     * {SPARQL::Algebra::Operator::Prefix}
   #     * {SPARQL::Algebra::Operator::Project}
+  #     * {SPARQL::Algebra::Operator::Rand}
   #     * {SPARQL::Algebra::Operator::Reduced}
   #     * {SPARQL::Algebra::Operator::Regex}
+  #     * {SPARQL::Algebra::Operator::Replace}
+  #     * {SPARQL::Algebra::Operator::Round}
   #     * {SPARQL::Algebra::Operator::SameTerm}
+  #     * {SPARQL::Algebra::Operator::Sample}
+  #     * {SPARQL::Algebra::Operator::Seconds}
+  #     * {SPARQL::Algebra::Operator::SHA1}
+  #     * {SPARQL::Algebra::Operator::SHA256}
+  #     * {SPARQL::Algebra::Operator::SHA384}
+  #     * {SPARQL::Algebra::Operator::SHA512}
   #     * {SPARQL::Algebra::Operator::Slice}
   #     * {SPARQL::Algebra::Operator::Str}
+  #     * {SPARQL::Algebra::Operator::StrAfter}
+  #     * {SPARQL::Algebra::Operator::StrBefore}
+  #     * {SPARQL::Algebra::Operator::StrDT}
+  #     * {SPARQL::Algebra::Operator::StrEnds}
+  #     * {SPARQL::Algebra::Operator::StrLang}
+  #     * {SPARQL::Algebra::Operator::StrLen}
+  #     * {SPARQL::Algebra::Operator::StrStarts}
+  #     * {SPARQL::Algebra::Operator::StrUUID}
+  #     * {SPARQL::Algebra::Operator::SubStr}
   #     * {SPARQL::Algebra::Operator::Subtract}
+  #     * {SPARQL::Algebra::Operator::Sum}
+  #     * {SPARQL::Algebra::Operator::Table}
+  #     * {SPARQL::Algebra::Operator::Timezone}
+  #     * {SPARQL::Algebra::Operator::TZ}
+  #     * {SPARQL::Algebra::Operator::Ucase}
   #     * {SPARQL::Algebra::Operator::Union}
+  #     * {SPARQL::Algebra::Operator::Update}
+  #     * {SPARQL::Algebra::Operator::Using}
+  #     * {SPARQL::Algebra::Operator::UUID}
+  #     * {SPARQL::Algebra::Operator::With}
+  #     * {SPARQL::Algebra::Operator::Year}
   # 
   # TODO
   # ====
-  # * Need to come up with appropriate SXP for SPARQL 1.1
   # * Operator#optimize needs to be completed and tested.
   # 
   # @see http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
@@ -288,6 +357,7 @@ module SPARQL
     autoload :Expression,  'sparql/algebra/expression'
     autoload :Operator,    'sparql/algebra/operator'
     autoload :Query,       'sparql/algebra/query'
+    autoload :Update,      'sparql/algebra/update'
 
     ##
     # @example

data/lib/sparql/algebra/aggregate.rb

@@ -26,7 +26,7 @@ module SPARQL; module Algebra
       args_enum = solutions.map do |solution|
         operands.map do |operand|
           begin
-            operand.evaluate(solution, options.merge(:depth => options[:depth].to_i + 1))
+            operand.evaluate(solution, options.merge(depth: options[:depth].to_i + 1))
           rescue TypeError
             # Ignore errors
             nil

data/lib/sparql/algebra/evaluatable.rb

@@ -14,7 +14,7 @@ module SPARQL; module Algebra
     # @return [RDF::Term]
     # @abstract
     def evaluate(bindings, options = {})
-      args = operands.map { |operand| operand.evaluate(bindings, options.merge(:depth => options[:depth].to_i + 1)) }
+      args = operands.map { |operand| operand.evaluate(bindings, options.merge(depth: options[:depth].to_i + 1)) }
       options[:memoize] ? memoize(*args) : apply(*args)
     end
 

data/lib/sparql/algebra/expression.rb

@@ -79,7 +79,7 @@ module SPARQL; module Algebra
 
     ##
     # @example
-    #   Expression.new([:isLiteral, RDF::Literal(3.1415)], :version => 1.0)
+    #   Expression.new([:isLiteral, RDF::Literal(3.1415)], version: 1.0)
     #
     # @param  [Array] sse
     #   a SPARQL S-Expression (SSE) form
@@ -95,12 +95,12 @@ module SPARQL; module Algebra
         return case sse.first
         when Array
           debug(options) {"Map array elements #{sse}"}
-          sse.map {|s| self.new(s, options.merge(:depth => options[:depth].to_i + 1))}
+          sse.map {|s| self.new(s, options.merge(depth: options[:depth].to_i + 1))}
         else
           debug(options) {"No operator found for #{sse.first}"}
           sse.map do |s|
             s.is_a?(Array) ?
-              self.new(s, options.merge(:depth => options[:depth].to_i + 1)) :
+              self.new(s, depth: options[:depth].to_i + 1) :
               s
           end
         end
@@ -110,7 +110,7 @@ module SPARQL; module Algebra
         debug(options) {"Operator=#{operator.inspect}, Operand=#{operand.inspect}"}
         case operand
           when Array
-            self.new(operand, options.merge(:depth => options[:depth].to_i + 1))
+            self.new(operand, options.merge(depth: options[:depth].to_i + 1))
           when Operator, Variable, RDF::Term, RDF::Query, Symbol
             operand
           when TrueClass, FalseClass, Numeric, String, DateTime, Date, Time
@@ -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].include?(k) }
+      options.delete_if {|k, v| [:debug, :depth, :prefixes, :base_uri, :update].include?(k) }
       operands << options unless options.empty?
       operator.new(*operands)
     end
@@ -160,7 +160,7 @@ module SPARQL; module Algebra
     ##
     # Registered extensions
     #
-    # @return [Hash{RDF::URI => Proc}]
+    # @return [Hash{RDF:URI: Proc}]
     def self.extensions
       @extensions ||= {}
     end
@@ -203,22 +203,22 @@ module SPARQL; module Algebra
       when RDF::XSD.dateTime
         case value
         when RDF::Literal::DateTime, RDF::Literal::Date, RDF::Literal::Time
-          RDF::Literal.new(value, :datatype => datatype)
+          RDF::Literal.new(value, datatype: datatype)
         when RDF::Literal::Numeric, RDF::Literal::Boolean, RDF::URI, RDF::Node
           raise TypeError, "Value #{value.inspect} cannot be cast as #{datatype}"
         else
-          RDF::Literal.new(value.value, :datatype => datatype, :validate => true)
+          RDF::Literal.new(value.value, datatype: datatype, validate: true)
         end
       when RDF::XSD.float, RDF::XSD.double
         case value
         when RDF::Literal::Boolean
-          RDF::Literal.new(value.object ? 1 : 0, :datatype => datatype)
+          RDF::Literal.new(value.object ? 1 : 0, datatype: datatype)
         when RDF::Literal::Numeric
-          RDF::Literal.new(value.to_f, :datatype => datatype)
+          RDF::Literal.new(value.to_f, datatype: datatype)
         when RDF::Literal::DateTime, RDF::Literal::Date, RDF::Literal::Time, RDF::URI, RDF::Node
           raise TypeError, "Value #{value.inspect} cannot be cast as #{datatype}"
         else
-          RDF::Literal.new(value.value, :datatype => datatype, :validate => true)
+          RDF::Literal.new(value.value, datatype: datatype, validate: true)
         end
       when RDF::XSD.boolean
         case value
@@ -229,21 +229,21 @@ module SPARQL; module Algebra
         when RDF::Literal::DateTime, RDF::Literal::Date, RDF::Literal::Time, RDF::URI, RDF::Node
           raise TypeError, "Value #{value.inspect} cannot be cast as #{datatype}"
         else
-          RDF::Literal.new(!value.to_s.empty?, :datatype => datatype, :validate => true)
+          RDF::Literal.new(!value.to_s.empty?, datatype: datatype, validate: true)
         end
       when RDF::XSD.decimal, RDF::XSD.integer
         case value
         when RDF::Literal::Boolean
-          RDF::Literal.new(value.object ? 1 : 0, :datatype => datatype)
+          RDF::Literal.new(value.object ? 1 : 0, datatype: datatype)
         when RDF::Literal::Integer, RDF::Literal::Decimal
-          RDF::Literal.new(value, :datatype => datatype)
+          RDF::Literal.new(value, datatype: datatype)
         when RDF::Literal::DateTime, RDF::Literal::Date, RDF::Literal::Time, RDF::URI, RDF::Node
           raise TypeError, "Value #{value.inspect} cannot be cast as #{datatype}"
         else
-          RDF::Literal.new(value.value, :datatype => datatype, :validate => true)
+          RDF::Literal.new(value.value, datatype: datatype, validate: true)
         end
       when RDF::XSD.string
-         RDF::Literal.new(value, :datatype => datatype)
+         RDF::Literal.new(value, datatype: datatype)
       else
         raise TypeError, "Expected datatype (#{datatype}) to be a recognized XPath function"
       end
@@ -260,6 +260,14 @@ module SPARQL; module Algebra
       false
     end
 
+    ##
+    # Returns `false`.
+    #
+    # @return [Boolean]
+    def has_blank_nodes?
+      false
+    end
+
     ##
     # Returns `true`.
     #