sparql-client 2.0.2 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 1a6ad63410ae80d9c27f0be01b03b76e190ff9d3
-  data.tar.gz: 8eb1f2318206ca77f8d3de492edd5b39a21544e6
+SHA256:
+  metadata.gz: 25fd44467b4b7014096fea7c336164c863b3da501ee747466ed486bdfab2f93d
+  data.tar.gz: f44d3e424e8c3fb13b0a323403212134c34e8fa7fb7ebaba562ded69a9d02fd7
 SHA512:
-  metadata.gz: 06077bcbae3445a986788c5b0a6486892a13dbcf66c20d21a6fae3af20b119065dcaef2608f734d8f9b2c37574c99a08799293ec95cb93c93e8d872a0b90d895
-  data.tar.gz: 65a0b4b376331ec5997c34590035f00223391672a092c696129ca51de547082c58178677d49b74ac99e577f62a4b60552fa37d82e5d3c7d08c40a65b07e70ea3
+  metadata.gz: 404e7f204b5bda734f531b29133705dcdf236a4bc7f348f32f6034595e43cd7e78814cb2d8cf66c696a9fd548496fd50b245b5bf2e705a551ef6e5012321c7d6
+  data.tar.gz: 4764b49167f0bd23e16455d9e1cf9ede6193db3dcd96eb17fd9ed4245557906dd5195424dbe88f098c8381e580ffc433f577e558b5472cb4f8f2a1756de3f911

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,90 +22,121 @@ 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'
 
-    sparql = SPARQL::Client.new("http://dbpedia.org/sparql")
+```ruby
+require 'sparql/client'
+sparql = SPARQL::Client.new("http://dbpedia.org/sparql")
+```
 
-### Querying a `RDF::Repository` instance
+### Querying a remote SPARQL endpoint with a custom User-Agent
+By default, SPARQL::Client adds a `User-Agent` field to requests, but applications may choose to provide their own, using the `headers` option:
 
-    require 'rdf/trig'
-    repository = RDF::Repository.load("http://example/dataset.trig")
+```ruby
+require 'sparql/client'
+sparql = SPARQL::Client.new("http://dbpedia.org/sparql", headers: {'User-Agent' => 'MyBotName'})
+```
 
-    sparql = SPARQL::Client.new(repository)
+### Querying a remote SPARQL endpoint with a specified default graph
 
-### Executing a boolean query and outputting the result
+```ruby
+require 'sparql/client'
+sparql = SPARQL::Client.new("http://dbpedia.org/sparql", { graph: "http://dbpedia.org" })
+```
+
+
+### Querying a `RDF::Repository` instance
+
+```ruby
+require 'rdf/trig'
+repository = RDF::Repository.load("http://example/dataset.trig")
+sparql = SPARQL::Client.new(repository)
+```
 
-    # ASK WHERE { ?s ?p ?o }
-    result = sparql.ask.whether([:s, :p, :o]).true?
+### Executing a boolean query and outputting the result
 
-    puts result.inspect   #=> true or false
+```ruby
+# ASK WHERE { ?s ?p ?o }
+result = sparql.ask.whether([:s, :p, :o]).true?
+puts result.inspect   #=> true or false
+```
 
 ### Executing a tuple query and iterating over the returned solutions
 
-    # SELECT * WHERE { ?s ?p ?o } OFFSET 100 LIMIT 10
-    query = sparql.select.where([:s, :p, :o]).offset(100).limit(10)
+```ruby
+# SELECT * WHERE { ?s ?p ?o } OFFSET 100 LIMIT 10
+query = sparql.select.where([:s, :p, :o]).offset(100).limit(10)
 
-    query.each_solution do |solution|
-      puts solution.inspect
-    end
+query.each_solution do |solution|
+  puts solution.inspect
+end
+```
 
 ### Executing a graph query and iterating over the returned statements
 
-    # CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o } LIMIT 10
-    query = sparql.construct([:s, :p, :o]).where([:s, :p, :o]).limit(10)
 
-    query.each_statement do |statement|
-      puts statement.inspect
-    end
+```ruby
+# CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o } LIMIT 10
+query = sparql.construct([:s, :p, :o]).where([:s, :p, :o]).limit(10)
+
+query.each_statement do |statement|
+  puts statement.inspect
+end
+```
 
 ### Executing an arbitrary textual SPARQL query string
 
-    result = sparql.query("ASK WHERE { ?s ?p ?o }")
+```ruby
+result = sparql.query("ASK WHERE { ?s ?p ?o }")
 
-    puts result.inspect   #=> true or false
+puts result.inspect   #=> true or false
+```
 
 ### Inserting data into a graph
 
-    # INSERT DATA { <http://example.org/jhacker> <http://xmlns.com/foaf/0.1/name> "J. Random Hacker" .}
-    data = RDF::Graph.new do |graph|
-      graph << [RDF::URI('http://example.org/jhacker'), RDF::Vocab::FOAF.name, "J. Random Hacker"]
-    end
-    insert_data(data)
+```ruby
+# INSERT DATA { <http://example.org/jhacker> <http://xmlns.com/foaf/0.1/name> "J. Random Hacker" .}
+data = RDF::Graph.new do |graph|
+  graph << [RDF::URI('http://example.org/jhacker'), RDF::Vocab::FOAF.name, "J. Random Hacker"]
+end
+sparql.insert_data(data)
+```
 
 ### Deleting data from a graph
 
-    # DELETE DATA { <http://example.org/jhacker> <http://xmlns.com/foaf/0.1/name> "J. Random Hacker" .}
-    data = RDF::Graph.new do |graph|
-      graph << [RDF::URI('http://example.org/jhacker'), RDF::Vocab::FOAF.name, "J. Random Hacker"]
-    end
-    delete_data(data)
+```ruby
+# DELETE DATA { <http://example.org/jhacker> <http://xmlns.com/foaf/0.1/name> "J. Random Hacker" .}
+data = RDF::Graph.new do |graph|
+  graph << [RDF::URI('http://example.org/jhacker'), RDF::Vocab::FOAF.name, "J. Random Hacker"]
+end
+sparql.delete_data(data)
+```
 
-##Documentation
+## Documentation
 
-* {SPARQL::Client}
-  * {SPARQL::Client::Query}
-  * {SPARQL::Client::Repository}
-  * {SPARQL::Client::Update}
+* [SPARQL::Client](https://www.rubydoc.info/github/ruby-rdf/sparql-client/SPARQL/Client)
+  * [SPARQL::Client::Query](https://www.rubydoc.info/github/ruby-rdf/sparql-client/SPARQL/Client/Query)
+  * [SPARQL::Client::Repository](https://www.rubydoc.info/github/ruby-rdf/sparql-client/SPARQL/Client/Repository)
+  * [SPARQL::Client::Update](https://www.rubydoc.info/github/ruby-rdf/sparql-client/SPARQL/Client/Update)
 
-##Dependencies
+## Dependencies
 
-* [Ruby](http://ruby-lang.org/) (>= 2.0)
-* [RDF.rb](http://rubygems.org/gems/rdf) (>= 2.0)
-* [Net::HTTP::Persistent](http://rubygems.org/gems/net-http-persistent) (>= 1.4)
-* Soft dependency on [SPARQL](http://rubygems.org/gems/sparql) (>= 1.1)
-* Soft dependency on [Nokogiri](http://rubygems.org/gems/nokogiri) (>= 1.6)
+* [Ruby](http://ruby-lang.org/) (>= 2.4)
+* [RDF.rb](http://rubygems.org/gems/rdf) (~> 3.1)
+* [Net::HTTP::Persistent](http://rubygems.org/gems/net-http-persistent) (~> 3.1)
+* Soft dependency on [SPARQL](http://rubygems.org/gems/sparql) (~> 3.1)
+* Soft dependency on [Nokogiri](http://rubygems.org/gems/nokogiri) (>= 1.10)
 
-##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 +147,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 +171,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 +186,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.0.2
+3.1.0

data/lib/sparql/client.rb

@@ -40,7 +40,7 @@ module SPARQL
       '*/*;q=0.1'
     ].join(', ').freeze
     GRAPH_ALL  = (
-      RDF::Format.content_types.keys + 
+      RDF::Format.content_types.keys +
       ['*/*;q=0.1']
     ).join(', ').freeze
 
@@ -86,8 +86,13 @@ module SPARQL
     # @option options [Symbol] :method (DEFAULT_METHOD)
     # @option options [Number] :protocol (DEFAULT_PROTOCOL)
     # @option options [Hash] :headers
+    #   HTTP Request headers
+    #
+    #   Defaults `Accept` header based on available reader content types if triples are expected and to SPARQL result types otherwise, to allow for content negotiation based on available readers.
+    #
+    #   Defaults  `User-Agent` header, unless one is specified.
     # @option options [Hash] :read_timeout
-    def initialize(url, options = {}, &block)
+    def initialize(url, **options, &block)
       case url
       when RDF::Queryable
         @url, @options = url, options.dup
@@ -95,6 +100,9 @@ module SPARQL
         @url, @options = RDF::URI.new(url.to_s), options.dup
         @headers = @options.delete(:headers) || {}
         @http = http_klass(@url.scheme)
+
+        # Close the http connection when object is deallocated
+        ObjectSpace.define_finalizer(self, proc {@http.shutdown if @http.respond_to?(:shutdown)})
       end
 
       if block_given?
@@ -105,13 +113,23 @@ module SPARQL
       end
     end
 
+    ##
+    # Closes a client instance by finishing the connection.
+    # The client is unavailable for any further data operations; an IOError is raised if such an attempt is made. I/O streams are automatically closed when they are claimed by the garbage collector.
+    # @return [void] `self`
+    def close
+      @http.shutdown if @http
+      @http = nil
+      self
+    end
+
     ##
     # Executes a boolean `ASK` query.
     #
     # @param (see Query.ask)
     # @return [Query]
-    def ask(*args)
-      call_query_method(:ask, *args)
+    def ask(*args, **options)
+      call_query_method(:ask, *args, **options)
     end
 
     ##
@@ -119,8 +137,8 @@ module SPARQL
     #
     # @param (see Query.select)
     # @return [Query]
-    def select(*args)
-      call_query_method(:select, *args)
+    def select(*args, **options)
+      call_query_method(:select, *args, **options)
     end
 
     ##
@@ -128,8 +146,8 @@ module SPARQL
     #
     # @param (see Query.describe)
     # @return [Query]
-    def describe(*args)
-      call_query_method(:describe, *args)
+    def describe(*args, **options)
+      call_query_method(:describe, *args, **options)
     end
 
     ##
@@ -137,8 +155,8 @@ module SPARQL
     #
     # @param (see Query.construct)
     # @return [Query]
-    def construct(*args)
-      call_query_method(:construct, *args)
+    def construct(*args, **options)
+      call_query_method(:construct, *args, **options)
     end
 
     ##
@@ -157,19 +175,19 @@ 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
-    #   client.insert_data(data, :graph => "http://example.org/")
+    #   client.insert_data(data, graph: "http://example.org/")
     #
     # @param  [RDF::Enumerable] data
     # @param  [Hash{Symbol => Object}] options
     # @option options [RDF::URI, String] :graph
     # @return [void] `self`
     # @see    http://www.w3.org/TR/sparql11-update/#insertData
-    def insert_data(data, options = {})
-      self.update(Update::InsertData.new(data, options))
+    def insert_data(data, **options)
+      self.update(Update::InsertData.new(data, **options))
     end
 
     ##
@@ -178,19 +196,19 @@ 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
-    #   client.delete_data(data, :graph => "http://example.org/")
+    #   client.delete_data(data, graph: "http://example.org/")
     #
     # @param  [RDF::Enumerable] data
     # @param  [Hash{Symbol => Object}] options
     # @option options [RDF::URI, String] :graph
     # @return [void] `self`
     # @see    http://www.w3.org/TR/sparql11-update/#deleteData
-    def delete_data(data, options = {})
-      self.update(Update::DeleteData.new(data, options))
+    def delete_data(data, **options)
+      self.update(Update::DeleteData.new(data, **options))
     end
 
     ##
@@ -205,8 +223,8 @@ module SPARQL
     # @option options [RDF::URI, String] :graph
     # @return [void] `self`
     # @see    http://www.w3.org/TR/sparql11-update/#deleteInsert
-    def delete_insert(delete_graph, insert_graph = nil, where_graph = nil, options = {})
-      self.update(Update::DeleteInsert.new(delete_graph, insert_graph, where_graph, options))
+    def delete_insert(delete_graph, insert_graph = nil, where_graph = nil, **options)
+      self.update(Update::DeleteInsert.new(delete_graph, insert_graph, where_graph, **options))
     end
 
     ##
@@ -222,8 +240,8 @@ module SPARQL
     # @option options [Boolean] :silent
     # @return [void] `self`
     # @see    http://www.w3.org/TR/sparql11-update/#clear
-    def clear_graph(graph_uri, options = {})
-      self.clear(:graph, graph_uri, options)
+    def clear_graph(graph_uri, **options)
+      self.clear(:graph, graph_uri, **options)
     end
 
     ##
@@ -249,7 +267,7 @@ module SPARQL
     #   @option options [Boolean] :silent
     #   @return [void] `self`
     #
-    # @overload clear(what, *arguments, options = {})
+    # @overload clear(what, *arguments, **options)
     #   @param  [Symbol, #to_sym] what
     #   @param  [Array] arguments splat of other arguments to {Update::Clear}.
     #   @param  [Hash{Symbol => Object}] options
@@ -263,9 +281,9 @@ module SPARQL
 
     ##
     # @private
-    def call_query_method(meth, *args)
+    def call_query_method(meth, *args, **options)
       client = self
-      result = Query.send(meth, *args)
+      result = Query.send(meth, *args, **options)
       (class << result; self; end).send(:define_method, :execute) do
         client.query(self)
       end
@@ -288,21 +306,22 @@ module SPARQL
     # @option options [String] :content_type
     # @option options [Hash] :headers
     # @return [Array<RDF::Query::Solution>]
+    # @raise [IOError] if connection is closed
     # @see    http://www.w3.org/TR/sparql11-protocol/#query-operation
-    def query(query, options = {})
+    def query(query, **options)
       @op = :query
       @alt_endpoint = options[:endpoint]
       case @url
       when RDF::Queryable
         require 'sparql' unless defined?(::SPARQL::Grammar)
         begin
-          SPARQL.execute(query, @url, options)
+          SPARQL.execute(query, @url, **options)
         rescue SPARQL::MalformedQuery
           $stderr.puts "error running #{query}: #{$!}"
           raise
         end
       else
-        parse_response(response(query, options), options)
+        parse_response(response(query, **options), **options)
       end
     end
 
@@ -315,16 +334,17 @@ module SPARQL
     # @option options [String] :content_type
     # @option options [Hash] :headers
     # @return [void] `self`
+    # @raise [IOError] if connection is closed
     # @see    http://www.w3.org/TR/sparql11-protocol/#update-operation
-    def update(query, options = {})
+    def update(query, **options)
       @op = :update
       @alt_endpoint = options[:endpoint]
       case @url
       when RDF::Queryable
         require 'sparql' unless defined?(::SPARQL::Grammar)
-        SPARQL.execute(query, @url, options.merge(update: true))
+        SPARQL.execute(query, @url, update: true, **options)
       else
-        response(query, options)
+        response(query, **options)
       end
       self
     end
@@ -338,8 +358,9 @@ module SPARQL
     # @option options [String] :content_type
     # @option options [Hash] :headers
     # @return [String]
-    def response(query, options = {})
-      headers = options[:headers] || {}
+    # @raise [IOError] if connection is closed
+    def response(query, **options)
+      headers = options[:headers] || @headers
       headers['Accept'] = options[:content_type] if options[:content_type]
       request(query, headers) do |response|
         case response
@@ -359,7 +380,7 @@ module SPARQL
     # @param  [Net::HTTPSuccess] response
     # @param  [Hash{Symbol => Object}] options
     # @return [Object]
-    def parse_response(response, options = {})
+    def parse_response(response, **options)
       case options[:content_type] || response.content_type
         when NilClass
           response.body
@@ -374,7 +395,7 @@ module SPARQL
         when RESULT_TSV
           self.class.parse_tsv_bindings(response.body, nodes)
         else
-          parse_rdf_serialization(response, options)
+          parse_rdf_serialization(response, **options)
       end
     end
 
@@ -411,9 +432,9 @@ module SPARQL
         when :uri
           RDF::URI.new(value['value'])
         when :literal
-          RDF::Literal.new(value['value'], :datatype => value['datatype'], :language => value['xml:lang'])
+          RDF::Literal.new(value['value'], datatype: value['datatype'], language: value['xml:lang'])
         when :'typed-literal'
-          RDF::Literal.new(value['value'], :datatype => value['datatype'])
+          RDF::Literal.new(value['value'], datatype: value['datatype'])
         else nil
       end
     end
@@ -529,7 +550,7 @@ module SPARQL
         when :literal
           lang     = value.respond_to?(:attr) ? value.attr('xml:lang') : value.attributes['xml:lang']
           datatype = value.respond_to?(:attr) ? value.attr('datatype') : value.attributes['datatype']
-          RDF::Literal.new(value.text, :language => lang, :datatype => datatype)
+          RDF::Literal.new(value.text, language: lang, datatype: datatype)
         else nil
       end
     end
@@ -538,12 +559,12 @@ module SPARQL
     # @param  [Net::HTTPSuccess] response
     # @param  [Hash{Symbol => Object}] options
     # @return [RDF::Enumerable]
-    def parse_rdf_serialization(response, options = {})
-      options = {:content_type => response.content_type} unless options[:content_type]
+    def parse_rdf_serialization(response, **options)
+      options = {content_type: response.content_type} unless options[:content_type]
       if reader = RDF::Reader.for(options)
         reader.new(response.body)
       else
-        raise RDF::ReaderError, "no suitable rdf reader was found."
+        raise RDF::ReaderError, "no RDF reader was found for #{options}."
       end
     end
 
@@ -609,11 +630,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 +679,7 @@ 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 = Net::HTTP::Persistent.new(name: self.class.to_s, proxy: proxy_url)
       klass.keep_alive =  @options[:keep_alive] || 120
       klass.read_timeout = @options[:read_timeout] || 60
       klass
@@ -665,9 +690,15 @@ module SPARQL
     #
     # @param  [String, #to_s]          query
     # @param  [Hash{String => String}] headers
+      #   HTTP Request headers
+      #
+      #   Defaults `Accept` header based on available reader content types if triples are expected and to SPARQL result types otherwise, to allow for content negotiation based on available readers.
+      #
+      #   Defaults  `User-Agent` header, unless one is specified.
     # @yield  [response]
     # @yieldparam [Net::HTTPResponse] response
     # @return [Net::HTTPResponse]
+    # @raise [IOError] if connection is closed
     # @see    http://www.w3.org/TR/sparql11-protocol/#query-operation
     def request(query, headers = {}, &block)
       # Make sure an appropriate Accept header is present
@@ -678,6 +709,7 @@ module SPARQL
       else
         RESULT_ALL
       end
+      headers['User-Agent'] ||= "Ruby SPARQL::Client/#{SPARQL::Client::VERSION}"
 
       request = send("make_#{request_method(query)}_request", query, headers)
 
@@ -685,6 +717,7 @@ module SPARQL
 
       pre_http_hook(request) if respond_to?(:pre_http_hook)
 
+      raise IOError, "Client has been closed" unless @http
       response = @http.request(::URI.parse(url.to_s), request)
 
       post_http_hook(response) if respond_to?(:post_http_hook)
@@ -693,8 +726,8 @@ module SPARQL
         if response.kind_of? Net::HTTPRedirection
           response = @http.request(::URI.parse(response['location']), request)
         else
-          return block_given? ? block.call(response) : response 
-        end          
+          return block_given? ? block.call(response) : response
+        end
       end
       raise ServerError, "Infinite redirect at #{url}. Redirected more than 10 times."
     end
@@ -717,7 +750,8 @@ module SPARQL
     # @see    http://www.w3.org/TR/sparql11-protocol/#query-via-get
     def make_get_request(query, headers = {})
       url = self.url.dup
-      url.query_values = (url.query_values || {}).merge(:query => query.to_s)
+      url.query_values = (url.query_values || {}).merge(query: query.to_s)
+      set_url_default_graph url unless @options[:graph].nil?
       request = Net::HTTP::Get.new(url.request_uri, self.headers.merge(headers))
       request
     end
@@ -732,21 +766,67 @@ module SPARQL
     # @see    http://www.w3.org/TR/sparql11-protocol/#query-via-post-urlencoded
     def make_post_request(query, headers = {})
       if @alt_endpoint.nil?
-        endpoint = url.request_uri 
+        url = self.url.dup
+        set_url_default_graph url unless @options[:graph].nil?
+        endpoint = url.request_uri
       else
         endpoint = @alt_endpoint
       end
+
       request = Net::HTTP::Post.new(endpoint, self.headers.merge(headers))
       case (self.options[:protocol] || DEFAULT_PROTOCOL).to_s
         when '1.1'
           request['Content-Type'] = 'application/sparql-' + (@op || :query).to_s
           request.body = query.to_s
         when '1.0'
-          request.set_form_data((@op || :query) => query.to_s)
+          form_data = {(@op || :query) => query.to_s}
+          form_data.merge!(
+            {:'default-graph-uri' => @options[:graph]}
+          ) if !@options[:graph].nil? && (@op.eql? :query)
+          form_data.merge!(
+            {:'using-graph-uri' => @options[:graph]}
+          ) if !@options[:graph].nil? && (@op.eql? :update)
+          request.set_form_data(form_data)
         else
           raise ArgumentError, "unknown SPARQL protocol version: #{self.options[:protocol].inspect}"
       end
       request
     end
+
+    ##
+    # Setup url query parameter to use a specified default graph
+    #
+    # @see    https://www.w3.org/TR/sparql11-protocol/#query-operation
+    # @see    https://www.w3.org/TR/sparql11-protocol/#update-operation
+    def set_url_default_graph url
+      if @options[:graph].is_a? Array
+        graphs = @options[:graph].map {|graph|
+          CGI::escape(graph)
+        }
+      else
+        graphs = CGI::escape(@options[:graph])
+      end
+      case @op
+      when :query
+        url.query_values = (url.query_values || {})
+          .merge(:'default-graph-uri' => graphs)
+      when :update
+        url.query_values = (url.query_values || {})
+          .merge(:'using-graph-uri' => graphs)
+      end
+    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