sparql-client 2.1.0 → 2.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7bb3fbfde7825e70b178ae2e502f4145fc75db84
-  data.tar.gz: 128998297c153debdc7ec09547eedd1c6106f84e
+  metadata.gz: 63643389b5260847e6a5ff81f8ec4e7a8d754adf
+  data.tar.gz: b0ed32a9d7f1fd58efe6de87ab64f2eb0f10a758
 SHA512:
-  metadata.gz: a64de18fb22d1f3f7662e02c9e65e5cbfa41ce083c9f73379112b833178ce3694575871675c2a18d1abb5a5950dd47d3e3b6732a15e239690128ca91fefb6cfa
-  data.tar.gz: 168112994fc8f38b83ddb20a850042ea55c6b766b119cbb0054a6bcd83d6c32bb5ab441ff8e543e43d695e9e48153cb2f44c61205b5ce1f47ea47ee1f5cc7f61
+  metadata.gz: fcfec9d172d4bb98f27136bdde32f242780080b05b1fa92390fa69f3c4faea3aad03971dc7d19b22026e228065210b86ccd543d6a749d7fe1d132737480e9459
+  data.tar.gz: b0a1ce446f6930c620b78aee2978cd46b0c9d54f9fec3c08ea00c91f5761eeae083a19f07f00d8a48867505addb370d986d54ad9cb345dcd026826244caed2c3

data/README.md

@@ -1,4 +1,4 @@
-#SPARQL Client for RDF.rb
+# SPARQL Client for RDF.rb
 
 This is a [Ruby][] implementation of a [SPARQL][] client for [RDF.rb][].
 
@@ -8,7 +8,7 @@ This is a [Ruby][] implementation of a [SPARQL][] client for [RDF.rb][].
 [![Build Status](https://travis-ci.org/ruby-rdf/sparql-client.png?branch=master)](http://travis-ci.org/ruby-rdf/sparql-client)
 [![Coverage Status](https://coveralls.io/repos/ruby-rdf/sparql-client/badge.svg?branch=master&service=github)](https://coveralls.io/github/ruby-rdf/sparql-client?branch=master)
 
-##Features
+## Features
 
 * Executes queries against any SPARQL 1.0/1.1-compatible endpoint over HTTP,
   or against an `RDF::Queryable` instance, using the `SPARQL` gem.
@@ -22,7 +22,7 @@ This is a [Ruby][] implementation of a [SPARQL][] client for [RDF.rb][].
 * Supports accessing endpoints as read/write [`RDF::Repository`][RDF::Repository]
   instances {SPARQL::Client::Repository}.
 
-##Examples
+## Examples
 
 ### Querying a remote SPARQL endpoint
     require 'sparql/client'
@@ -73,7 +73,7 @@ This is a [Ruby][] implementation of a [SPARQL][] client for [RDF.rb][].
     data = RDF::Graph.new do |graph|
       graph << [RDF::URI('http://example.org/jhacker'), RDF::Vocab::FOAF.name, "J. Random Hacker"]
     end
-    insert_data(data)
+    sparql.insert_data(data)
 
 ### Deleting data from a graph
 
@@ -81,16 +81,16 @@ This is a [Ruby][] implementation of a [SPARQL][] client for [RDF.rb][].
     data = RDF::Graph.new do |graph|
       graph << [RDF::URI('http://example.org/jhacker'), RDF::Vocab::FOAF.name, "J. Random Hacker"]
     end
-    delete_data(data)
+    sparql.delete_data(data)
 
-##Documentation
+## Documentation
 
 * {SPARQL::Client}
   * {SPARQL::Client::Query}
   * {SPARQL::Client::Repository}
   * {SPARQL::Client::Update}
 
-##Dependencies
+## Dependencies
 
 * [Ruby](http://ruby-lang.org/) (>= 2.2.2)
 * [RDF.rb](http://rubygems.org/gems/rdf) (>= 2.0)
@@ -98,14 +98,14 @@ This is a [Ruby][] implementation of a [SPARQL][] client for [RDF.rb][].
 * Soft dependency on [SPARQL](http://rubygems.org/gems/sparql) (>= 2.0)
 * Soft dependency on [Nokogiri](http://rubygems.org/gems/nokogiri) (>= 1.6)
 
-##Installation
+## Installation
 
 The recommended installation method is via [RubyGems](http://rubygems.org/).
 To install the latest official release of the `SPARQL::Client` gem, do:
 
     % [sudo] gem install sparql-client
 
-##Download
+## Download
 
 To get a local working copy of the development repository, do:
 
@@ -116,17 +116,17 @@ follows:
 
     % wget http://github.com/ruby-rdf/sparql-client/tarball/master
 
-##Mailing List
+## Mailing List
 
 * <http://lists.w3.org/Archives/Public/public-rdf-ruby/>
 
-##Authors
+## Authors
 
 * [Arto Bendiken](http://github.com/bendiken) - <http://ar.to/>
 * [Ben Lavender](http://github.com/bhuga) - <http://bhuga.net/>
 * [Gregg Kellogg](http://github.com/gkellogg) - <http://greggkellogg.net/>
 
-##Contributors
+## Contributors
 
 * [Christoph Badura](http://github.com/bad) - <http://github.com/bad>
 * [James Hetherington](http://github.com/jamespjh) - <http://twitter.com/jamespjh>
@@ -140,7 +140,7 @@ follows:
 * [Thomas Feron](http://github.com/thoferon) - <http://github.com/thoferon>
 * [Nick Gottlieb](http://github.com/ngottlieb) - <http://www.nicholasgottlieb.com>
 
-##Contributing
+## Contributing
 This repository uses [Git Flow](https://github.com/nvie/gitflow) to mange development and release activity. All submissions _must_ be on a feature branch based on the _develop_ branch to ease staging and integration.
 
 * Do your best to adhere to the existing coding conventions and idioms.
@@ -155,16 +155,15 @@ This repository uses [Git Flow](https://github.com/nvie/gitflow) to mange develo
   of thumb, additions larger than about 15 lines of code), we need an
   explicit [public domain dedication][PDD] on record from you.
 
-##Resources
+## Resources
 
 * <http://ruby-rdf.github.com/sparql-client/>
 * <http://github.com/ruby-rdf/sparql-client>
 * <http://rubygems.org/gems/sparql-client>
-* <http://rubyforge.org/projects/sparql/>
 * <http://raa.ruby-lang.org/project/sparql-client/>
 * <http://www.ohloh.net/p/rdf>
 
-##License
+## License
 
 This is free and unencumbered public domain software. For more information,
 see <http://unlicense.org/> or the accompanying {file:UNLICENSE} file.

data/VERSION

@@ -1 +1 @@
-2.1.0
+2.2.1

data/lib/sparql/client.rb

@@ -157,7 +157,7 @@ module SPARQL
     #   })
     #
     # @example Inserting data sourced from a file or URL
-    #   data = RDF::Graph.load("http://rdf.rubyforge.org/doap.nt")
+    #   data = RDF::Graph.load("https://raw.githubusercontent.com/ruby-rdf/rdf/develop/etc/doap.nt")
     #   client.insert_data(data)
     #
     # @example Inserting data into a named graph
@@ -178,7 +178,7 @@ module SPARQL
     # This requires that the endpoint support SPARQL 1.1 Update.
     #
     # @example Deleting data sourced from a file or URL
-    #   data = RDF::Graph.load("http://rdf.rubyforge.org/doap.nt")
+    #   data = RDF::Graph.load("https://raw.githubusercontent.com/ruby-rdf/rdf/develop/etc/doap.nt")
     #   client.delete_data(data)
     #
     # @example Deleting data from a named graph
@@ -609,11 +609,15 @@ module SPARQL
     # @private
     def self.serialize_patterns(patterns, use_vars = false)
       patterns.map do |pattern|
-        serialized_pattern = RDF::Statement.from(pattern).to_triple.each_with_index.map do |v, i|
-          if i == 1
-            SPARQL::Client.serialize_predicate(v)
-         else
-            SPARQL::Client.serialize_value(v, use_vars)
+        serialized_pattern = case pattern
+        when SPARQL::Client::QueryElement then [pattern.to_s]
+        else
+          RDF::Statement.from(pattern).to_triple.each_with_index.map do |v, i|
+            if i == 1
+              SPARQL::Client.serialize_predicate(v)
+           else
+              SPARQL::Client.serialize_value(v, use_vars)
+            end
           end
         end
         serialized_pattern.join(' ') + ' .'
@@ -654,7 +658,11 @@ module SPARQL
           value = ENV['https_proxy']
           proxy_url = URI.parse(value) unless value.nil? || value.empty?
       end
-      klass = Net::HTTP::Persistent.new(self.class.to_s, proxy_url)
+      klass = if Net::HTTP::Persistent::VERSION >= '3.0'
+        Net::HTTP::Persistent.new(name: self.class.to_s, proxy: proxy_url)
+      else
+        Net::HTTP::Persistent.new(self.class.to_s, proxy_url)
+      end
       klass.keep_alive =  @options[:keep_alive] || 120
       klass.read_timeout = @options[:read_timeout] || 60
       klass
@@ -748,5 +756,18 @@ module SPARQL
       end
       request
     end
+
+    # A query element can be used as a component of a query. It may be initialized with a string, which is wrapped in an appropriate container depending on the type of QueryElement. Implements {#to_s} to property serialize when generating a SPARQL query.
+    class QueryElement
+      attr_reader :elements
+
+      def initialize(*args)
+        @elements = args
+      end
+
+      def to_s
+        raise NotImplemented
+      end
+    end
   end # Client
 end # SPARQL

data/lib/sparql/client/query.rb

@@ -42,6 +42,12 @@ module SPARQL; class Client
     # @example SELECT * WHERE { ?s ?p ?o . }
     #   Query.select.where([:s, :p, :o])
     #
+    # @example SELECT ?s WHERE {?s ?p ?o .}
+    #   Query.select(:s).where([:s, :p, :o])
+    #
+    # @example SELECT COUNT(?uri as ?c) WHERE {?uri a owl:Class}
+    #   Query.select(count: {uri: :c}).where([:uri, RDF.type, RDF::OWL.Class])
+    #
     # @param  [Array<Symbol>]          variables
     # @return [Query]
     #
@@ -98,6 +104,10 @@ module SPARQL; class Client
     # @overload self.construct(*variables, options)
     #   @param  [Symbol, #to_s]          form
     #   @param  [Hash{Symbol => Object}] options (see {Client#initialize})
+    #   @option options [Hash{Symbol => Symbol}] :count
+    #     Contents are symbols relating a variable described within the query,
+    #     to the projected variable.
+    #     
     # @yield  [query]
     # @yieldparam [Query]
     def initialize(form = :ask, options = {}, &block)
@@ -121,6 +131,12 @@ module SPARQL; class Client
     # @example SELECT * WHERE { ?s ?p ?o . }
     #   query.select.where([:s, :p, :o])
     #
+    # @example SELECT ?s WHERE {?s ?p ?o .}
+    #   query.select(:s).where([:s, :p, :o])
+    #
+    # @example SELECT COUNT(?uri as ?c) WHERE {?uri a owl:Class}
+    #   query.select(count: {uri: :c}).where([:uri, RDF.type, RDF::OWL.Class])
+    #
     # @param  [Array<Symbol>] variables
     # @return [Query]
     # @see    http://www.w3.org/TR/sparql11-query/#select
@@ -172,19 +188,55 @@ module SPARQL; class Client
     #   query.select.where([:s, :p, :o])
     #   query.select.whether([:s, :p, :o])
     #
+    # @example SELECT * WHERE { { SELECT * WHERE { ?s ?p ?o . } } . ?s ?p ?o . }
+    #   subquery = query.select.where([:s, :p, :o])
+    #   query.select.where([:s, :p, :o], subquery)
+    #
+    # @example SELECT * WHERE { { SELECT * WHERE { ?s ?p ?o . } } . ?s ?p ?o . }
+    #   query.select.where([:s, :p, :o]) do |q|
+    #     q.select.where([:s, :p, :o])
+    #   end
+    #
+    # Block form can be used for chaining calls in addition to creating sub-select queries.
+    #
+    # @example SELECT * WHERE { ?s ?p ?o . } ORDER BY ?o
+    #   query.select.where([:s, :p, :o]) do
+    #     order(:o)
+    #   end
+    #
     # @param  [Array<RDF::Query::Pattern, Array>] patterns_queries
     #   splat of zero or more patterns followed by zero or more queries.
+    # @yield [query]
+    #   Yield form with or without argument; without an argument, evaluates within the query.
+    # @yieldparam [SPARQL::Client::Query] query Actually a delegator to query. Methods other than `#select` are evaluated against `self`. For `#select`, a new Query is created, and the result added as a subquery.
     # @return [Query]
     # @see    http://www.w3.org/TR/sparql11-query/#GraphPattern
-    def where(*patterns_queries)
+    def where(*patterns_queries, &block)
       subqueries, patterns = patterns_queries.partition {|pq| pq.is_a? SPARQL::Client::Query}
       @patterns += build_patterns(patterns)
       @subqueries += subqueries
+
+      if block_given?
+        decorated_query = WhereDecorator.new(self)
+        case block.arity
+          when 1 then block.call(decorated_query)
+          else decorated_query.instance_eval(&block)
+        end
+      end
       self
     end
 
     alias_method :whether, :where
 
+    # @private
+    class WhereDecorator < SimpleDelegator
+      def select(*variables)
+        query = SPARQL::Client::Query.select(*variables)
+        __getobj__.instance_variable_get(:@subqueries) << query
+        query
+      end
+    end
+
     ##
     # @example SELECT * WHERE { ?s ?p ?o . } ORDER BY ?o
     #   query.select.where([:s, :p, :o]).order(:o)
@@ -338,10 +390,141 @@ module SPARQL; class Client
     #   query.select.where([:s, :p, :o]).
     #     optional([:s, RDF.type, :o], [:s, RDF::Vocab::DC.abstract, :o])
     #
+    # The block form can be used for adding filters:
+    #
+    # @example ASK WHERE { ?s ?p ?o . OPTIONAL { ?s ?p ?o . FILTER(regex(?s, 'Abiline, Texas'))} }
+    #   query.ask.where([:s, :p, :o]).optional([:s, :p, :o]) do
+    #     filter("regex(?s, 'Abiline, Texas')")
+    #   end
+    #
+    # @param  [Array<RDF::Query::Pattern, Array>] patterns
+    #   splat of zero or more patterns followed by zero or more queries.
+    # @yield [query]
+    #   Yield form with or without argument; without an argument, evaluates within the query.
+    # @yieldparam [SPARQL::Client::Query] query used for creating filters on the optional patterns.
     # @return [Query]
     # @see    http://www.w3.org/TR/sparql11-query/#optionals
-    def optional(*patterns)
+    def optional(*patterns, &block)
       (options[:optionals] ||= []) << build_patterns(patterns)
+
+      if block_given?
+        # Steal options[:filters]
+        query_filters = options[:filters]
+        options[:filters] = []
+        case block.arity
+          when 1 then block.call(self)
+          else instance_eval(&block)
+        end
+        options[:optionals].last.concat(options[:filters])
+        options[:filters] = query_filters
+      end
+
+      self
+    end
+
+    ##
+    # @example SELECT * WHERE \{ ?book dc:title ?title \} UNION \{ ?book dc11:title ?title \}
+    #   query.select.where([:book, RDF::Vocab::DC.title, :title]).
+    #     union([:book, RDF::Vocab::DC11.title, :title])
+    #
+    # @example SELECT * WHERE \{ ?book dc:title ?title \} UNION \{ ?book dc11:title ?title . FILTER(langmatches(lang(?title), 'EN'))\}
+    #   query1 = SPARQL::Client::Query.select.
+    #     where([:book, RDF::Vocab::DC11.title, :title]).
+    #     filter("langmatches(?title, 'en')")
+    #   query.select.where([:book, RDF::Vocab::DC.title, :title]).union(query1)
+    #
+    # The block form can be used for more complicated queries, using the `select` form (note, use either block or argument forms, not both):
+    #
+    # @example SELECT * WHERE \{ ?book dc:title ?title \} UNION \{ ?book dc11:title ?title . FILTER(langmatches(lang(?title), 'EN'))\}
+    #   query1 = SPARQL::Client::Query.select.where([:book, RDF::Vocab::DC11.title, :title]).filter("langmatches(?title, 'en')")
+    #   query.select.where([:book, RDF::Vocab::DC.title, :title]).union do |q|
+    #     q.select.
+    #       where([:book, RDF::Vocab::DC11.title, :title]).
+    #       filter("langmatches(?title, 'en')")
+    #   end
+    #
+    # @param  [Array<RDF::Query::Pattern, Array>] patterns
+    #   splat of zero or more patterns followed by zero or more queries.
+    # @yield [query]
+    #   Yield form with or without argument; without an argument, evaluates within the query.
+    # @yieldparam [SPARQL::Client::Query] query used for adding select clauses.
+    # @return [Query]
+    # @see    http://www.w3.org/TR/sparql11-query/#optionals
+    def union(*patterns, &block)
+      options[:unions] ||= []
+
+      if block_given?
+        raise ArgumentError, "#union requires either arguments or a block, not both." unless patterns.empty?
+        # Evaluate calls in a new query instance
+        query = self.class.select
+        case block.arity
+          when 1 then block.call(query)
+          else query.instance_eval(&block)
+        end
+        options[:unions] << query
+      elsif patterns.all? {|p| p.is_a?(SPARQL::Client::Query)}
+        # With argument form, all must be patterns or queries
+        options[:unions] += patterns
+      elsif patterns.all? {|p| p.is_a?(Array)}
+        # With argument form, all must be patterns, or queries
+        options[:unions] << self.class.select.where(*patterns)
+      else
+        raise ArgumentError, "#union arguments are triple patters or queries, not both."
+      end
+
+      self
+    end
+
+    ##
+    # @example SELECT * WHERE \{ ?book dc:title ?title . MINUS \{ ?book dc11:title ?title \} \}
+    #   query.select.where([:book, RDF::Vocab::DC.title, :title]).
+    #     minus([:book, RDF::Vocab::DC11.title, :title])
+    #
+    # @example SELECT * WHERE \{ ?book dc:title ?title MINUS \{ ?book dc11:title ?title . FILTER(langmatches(lang(?title), 'EN')) \} \}
+    #   query1 = SPARQL::Client::Query.select.
+    #     where([:book, RDF::Vocab::DC11.title, :title]).
+    #     filter("langmatches(?title, 'en')")
+    #   query.select.where([:book, RDF::Vocab::DC.title, :title]).minus(query1)
+    #
+    # The block form can be used for more complicated queries, using the `select` form (note, use either block or argument forms, not both):
+    #
+    # @example SELECT * WHERE \{ ?book dc:title ?title MINUS \{ ?book dc11:title ?title . FILTER(langmatches(lang(?title), 'EN'))\} \}
+    #   query1 = SPARQL::Client::Query.select.where([:book, RDF::Vocab::DC11.title, :title]).filter("langmatches(?title, 'en')")
+    #   query.select.where([:book, RDF::Vocab::DC.title, :title]).minus do |q|
+    #     q.select.
+    #       where([:book, RDF::Vocab::DC11.title, :title]).
+    #       filter("langmatches(?title, 'en')")
+    #   end
+    #
+    # @param  [Array<RDF::Query::Pattern, Array>] patterns
+    #   splat of zero or more patterns followed by zero or more queries.
+    # @yield [query]
+    #   Yield form with or without argument; without an argument, evaluates within the query.
+    # @yieldparam [SPARQL::Client::Query] query used for adding select clauses.
+    # @return [Query]
+    # @see    http://www.w3.org/TR/sparql11-query/#optionals
+    def minus(*patterns, &block)
+      options[:minuses] ||= []
+
+      if block_given?
+        raise ArgumentError, "#minus requires either arguments or a block, not both." unless patterns.empty?
+        # Evaluate calls in a new query instance
+        query = self.class.select
+        case block.arity
+          when 1 then block.call(query)
+          else query.instance_eval(&block)
+        end
+        options[:minuses] << query
+      elsif patterns.all? {|p| p.is_a?(SPARQL::Client::Query)}
+        # With argument form, all must be patterns or queries
+        options[:minuses] += patterns
+      elsif patterns.all? {|p| p.is_a?(Array)}
+        # With argument form, all must be patterns, or queries
+        options[:minuses] << self.class.select.where(*patterns)
+      else
+        raise ArgumentError, "#minus arguments are triple patters or queries, not both."
+      end
+
       self
     end
 
@@ -352,15 +535,17 @@ module SPARQL; class Client
     end
 
     ##
-    # @private
+    # @private 
     def build_patterns(patterns)
       patterns.map {|pattern| RDF::Query::Pattern.from(pattern)}
     end
 
     ##
-    # @private
+    # @example ASK WHERE { ?s ?p ?o . FILTER(regex(?s, 'Abiline, Texas')) }
+    #   query.ask.where([:s, :p, :o]).filter("regex(?s, 'Abiline, Texas')")
+    # @return [Query]
     def filter(string)
-      ((options[:filters] ||= []) << string) if string and not string.empty?
+      ((options[:filters] ||= []) << Filter.new(string)) if string and not string.empty?
       self
     end
 
@@ -445,33 +630,11 @@ module SPARQL; class Client
       buffer << "FROM #{SPARQL::Client.serialize_value(options[:from])}" if options[:from]
 
       unless patterns.empty? && form == :describe
-        buffer << 'WHERE {'
-
-        if options[:graph]
-          buffer << 'GRAPH ' + SPARQL::Client.serialize_value(options[:graph])
-          buffer << '{'
-        end
-
-        @subqueries.each do |sq|
-          buffer << "{ #{sq.to_s} } ."
-        end
-
-        buffer += SPARQL::Client.serialize_patterns(patterns)
-        if options[:optionals]
-          options[:optionals].each do |patterns|
-            buffer << 'OPTIONAL {'
-            buffer += SPARQL::Client.serialize_patterns(patterns)
-            buffer << '}'
-          end
-        end
-        if options[:filters]
-          buffer += options[:filters].map { |filter| "FILTER(#{filter})" }
-        end
-        if options[:graph]
-          buffer << '}' # GRAPH
-        end
+        buffer += self.to_s_ggp.unshift('WHERE')
+      end
 
-        buffer << '}' # WHERE
+      options.fetch(:unions, []).each do |query|
+        buffer += query.to_s_ggp.unshift('UNION')
       end
 
       if options[:group_by]
@@ -524,6 +687,43 @@ module SPARQL; class Client
       buffer.join(' ')
     end
 
+    # Serialize a Group Graph Pattern
+    # @private
+    def to_s_ggp
+      buffer = ["{"]
+
+      if options[:graph]
+        buffer << 'GRAPH ' + SPARQL::Client.serialize_value(options[:graph])
+        buffer << '{'
+      end
+
+      @subqueries.each do |sq|
+        buffer << "{ #{sq.to_s} } ."
+      end
+
+      buffer += SPARQL::Client.serialize_patterns(patterns)
+      if options[:optionals]
+        options[:optionals].each do |patterns|
+          buffer << 'OPTIONAL {'
+          buffer += SPARQL::Client.serialize_patterns(patterns)
+          buffer << '}'
+        end
+      end
+      if options[:filters]
+        buffer += options[:filters].map(&:to_s)
+      end
+      if options[:graph]
+        buffer << '}' # GRAPH
+      end
+
+      options.fetch(:minuses, []).each do |query|
+        buffer += query.to_s_ggp.unshift('MINUS')
+      end
+
+      buffer << '}'
+      buffer
+    end
+
     ##
     # Outputs a developer-friendly representation of this query to `stderr`.
     #
@@ -540,5 +740,16 @@ module SPARQL; class Client
     def inspect
       sprintf("#<%s:%#0x(%s)>", self.class.name, __id__, to_s)
     end
+
+    # Allow Filters to be 
+    class Filter < SPARQL::Client::QueryElement
+      def initialize(*args)
+        super
+      end
+
+      def to_s
+        "FILTER(#{elements.join(' ')})"
+      end
+    end
   end
 end; end

data/lib/sparql/client/repository.rb

@@ -38,6 +38,30 @@ module SPARQL; class Client
       client.construct([:s, :p, :o]).where([:s, :p, :o]).each_statement(&block)
     end
 
+    ##
+    # Iterates the given block for each RDF statement.
+    #
+    # If no block was given, returns an enumerator.
+    #
+    # The order in which statements are yielded is undefined.
+    #
+    # @overload each_statement
+    #   @yield  [statement]
+    #     each statement
+    #   @yieldparam  [RDF::Statement] statement
+    #   @yieldreturn [void] ignored
+    #   @return [void]
+    #
+    # @overload each_statement
+    #   @return [Enumerator<RDF::Statement>]
+    def each_statement(&block)
+      if block_given?
+        # Invoke {#each} in the containing class:
+        each(&block)
+      end
+      enum_statement
+    end
+
     ##
     # @private
     # @see RDF::Enumerable#supports?
@@ -48,6 +72,7 @@ module SPARQL; class Client
         when :graph_name  then false
         when :inference   then false  # forward-chaining inference
         when :validity    then false
+        when :literal_equality then true
         else false
       end
     end
@@ -151,7 +176,7 @@ module SPARQL; class Client
     # @see    RDF::Repository#count?
     def count
       begin
-        binding = client.query("SELECT (COUNT(*) AS ?count) WHERE { ?s ?p ?o }").first.to_hash
+        binding = client.query("SELECT (COUNT(*) AS ?count) WHERE { ?s ?p ?o }").first.to_h
         binding[:count].value.to_i rescue 0
       rescue SPARQL::Client::MalformedQuery => e
         # SPARQL 1.0 does not include support for aggregate functions:

data/lib/sparql/client/update.rb

@@ -58,7 +58,7 @@ class SPARQL::Client
     end
 
     ##
-    # Load statements into the graph
+    # Clear the graph
     #
     # @example CLEAR GRAPH <http://example.org/data.rdf>
     #   clear.graph(RDF::URI(http://example.org/data.rdf))

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sparql-client
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.1
 platform: ruby
 authors:
 - Arto Bendiken
@@ -10,78 +10,102 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-06 00:00:00.000000000 Z
+date: 2017-12-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.2'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.2'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: net-http-persistent
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.9'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.9'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
 - !ruby/object:Gem::Dependency
   name: sparql
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.2'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '4.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.2'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: rdf-spec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.2'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '4.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.2'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.4'
+        version: '3.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.4'
+        version: '3.7'
 - !ruby/object:Gem::Dependency
   name: rspec-its
   requirement: !ruby/object:Gem::Requirement
@@ -102,28 +126,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '0.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '0.9'
 description: |-
   Executes SPARQL queries and updates against a remote SPARQL 1.0 or 1.1 endpoint,
                               or against a local repository. Generates SPARQL queries using a simple DSL.
@@ -163,8 +187,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: sparql-client
-rubygems_version: 2.5.1
+rubyforge_project: 
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
 summary: SPARQL client for RDF.rb.