sparql-client 3.0.1 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b3a059f24774ca03ca4acab2ad37de9edcfbfcc8844ea0da0d7fe3d4b2a90849
-  data.tar.gz: 8aa709b83cab4ee290d3513ebb6fd90370d40587b58e8b06351b3df0f32973bb
+  metadata.gz: 25fd44467b4b7014096fea7c336164c863b3da501ee747466ed486bdfab2f93d
+  data.tar.gz: f44d3e424e8c3fb13b0a323403212134c34e8fa7fb7ebaba562ded69a9d02fd7
 SHA512:
-  metadata.gz: a7abad9a9c21cf0b8d88f9e1bf7ee98cc97ba8fa9a40c9eb06d29293202d16cb10aef0dc9edabe626709230e13511cae7a28af7bc0d48c5ece65ed7030c86022
-  data.tar.gz: fe927a99648a455a10494b839d994edae99b755512c69862e1a77418af0aad62d59132e663915ebea6f3f34c0fa6b057f7eab281fbb401bef8be30afecc63c2a
+  metadata.gz: 404e7f204b5bda734f531b29133705dcdf236a4bc7f348f32f6034595e43cd7e78814cb2d8cf66c696a9fd548496fd50b245b5bf2e705a551ef6e5012321c7d6
+  data.tar.gz: 4764b49167f0bd23e16455d9e1cf9ede6193db3dcd96eb17fd9ed4245557906dd5195424dbe88f098c8381e580ffc433f577e558b5472cb4f8f2a1756de3f911

data/README.md

@@ -30,11 +30,20 @@ This is a [Ruby][] implementation of a [SPARQL][] client for [RDF.rb][].
 require 'sparql/client'
 sparql = SPARQL::Client.new("http://dbpedia.org/sparql")
 ```
+
+### 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:
+
+```ruby
+require 'sparql/client'
+sparql = SPARQL::Client.new("http://dbpedia.org/sparql", headers: {'User-Agent' => 'MyBotName'})
+```
+
 ### Querying a remote SPARQL endpoint with a specified default graph
 
 ```ruby
 require 'sparql/client'
-sparql = SPARQL::Client.new("http://dbpedia.org/sparql", { :graph => "http://dbpedia.org" })
+sparql = SPARQL::Client.new("http://dbpedia.org/sparql", { graph: "http://dbpedia.org" })
 ```
 
 
@@ -114,11 +123,11 @@ sparql.delete_data(data)
 
 ## Dependencies
 
-* [Ruby](http://ruby-lang.org/) (>= 2.2.2)
-* [RDF.rb](http://rubygems.org/gems/rdf) (~> 3.0)
-* [Net::HTTP::Persistent](http://rubygems.org/gems/net-http-persistent) (>= 1.4)
-* Soft dependency on [SPARQL](http://rubygems.org/gems/sparql) (~> 3.0)
-* Soft dependency on [Nokogiri](http://rubygems.org/gems/nokogiri) (>= 1.7)
+* [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
 

data/VERSION

@@ -1 +1 @@
-3.0.1
+3.1.0

data/lib/sparql/client.rb

@@ -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
 
     ##
@@ -161,15 +179,15 @@ module SPARQL
     #   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
 
     ##
@@ -182,15 +200,15 @@ module SPARQL
     #   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,8 +559,8 @@ 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
@@ -615,7 +636,7 @@ module SPARQL
           RDF::Statement.from(pattern).to_triple.each_with_index.map do |v, i|
             if i == 1
               SPARQL::Client.serialize_predicate(v)
-           else
+            else
               SPARQL::Client.serialize_value(v, use_vars)
             end
           end
@@ -658,11 +679,7 @@ module SPARQL
           value = ENV['https_proxy']
           proxy_url = URI.parse(value) unless value.nil? || value.empty?
       end
-      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 = 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
@@ -673,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
@@ -686,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)
 
@@ -693,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)
@@ -725,7 +750,7 @@ 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

data/lib/sparql/client/query.rb

@@ -26,8 +26,8 @@ class SPARQL::Client
     # @param  [Hash{Symbol => Object}] options (see {#initialize})
     # @return [Query]
     # @see    http://www.w3.org/TR/sparql11-query/#ask
-    def self.ask(options = {})
-      self.new(:ask, options)
+    def self.ask(**options)
+      self.new(:ask, **options)
     end
 
     ##
@@ -45,14 +45,13 @@ class SPARQL::Client
     # @param  [Array<Symbol>]          variables
     # @return [Query]
     #
-    # @overload self.select(*variables, options)
+    # @overload self.select(*variables, **options)
     #   @param  [Array<Symbol>]          variables
     #   @param  [Hash{Symbol => Object}] options (see {#initialize})
     #   @return [Query]
     # @see    http://www.w3.org/TR/sparql11-query/#select
-    def self.select(*variables)
-      options = variables.last.is_a?(Hash) ? variables.pop : {}
-      self.new(:select, options).select(*variables)
+    def self.select(*variables, **options)
+      self.new(:select, **options).select(*variables)
     end
 
     ##
@@ -64,14 +63,13 @@ class SPARQL::Client
     # @param  [Array<Symbol, RDF::URI>] variables
     # @return [Query]
     #
-    # @overload self.describe(*variables, options)
+    # @overload self.describe(*variables, **options)
     #   @param  [Array<Symbol, RDF::URI>] variables
     #   @param  [Hash{Symbol => Object}] options (see {#initialize})
     #   @return [Query]
     # @see    http://www.w3.org/TR/sparql11-query/#describe
-    def self.describe(*variables)
-      options = variables.last.is_a?(Hash) ? variables.pop : {}
-      self.new(:describe, options).describe(*variables)
+    def self.describe(*variables, **options)
+      self.new(:describe, **options).describe(*variables)
     end
 
     ##
@@ -83,19 +81,18 @@ class SPARQL::Client
     # @param  [Array<RDF::Query::Pattern, Array>] patterns
     # @return [Query]
     #
-    # @overload self.construct(*variables, options)
+    # @overload self.construct(*variables, **options)
     #   @param  [Array<RDF::Query::Pattern, Array>] patterns
     #   @param  [Hash{Symbol => Object}] options (see {#initialize})
     #   @return [Query]
     # @see    http://www.w3.org/TR/sparql11-query/#construct
-    def self.construct(*patterns)
-      options = patterns.last.is_a?(Hash) ? patterns.pop : {}
-      self.new(:construct, options).construct(*patterns) # FIXME
+    def self.construct(*patterns, **options)
+      self.new(:construct, **options).construct(*patterns) # FIXME
     end
 
     ##
     # @param  [Symbol, #to_s]          form
-    # @overload self.construct(*variables, options)
+    # @overload self.construct(*variables, **options)
     #   @param  [Symbol, #to_s]          form
     #   @param  [Hash{Symbol => Object}] options (see {Client#initialize})
     #   @option options [Hash{Symbol => Symbol}] :count
@@ -104,10 +101,10 @@ class SPARQL::Client
     #     
     # @yield  [query]
     # @yieldparam [Query]
-    def initialize(form = :ask, options = {}, &block)
+    def initialize(form = :ask, **options, &block)
       @subqueries = []
       @form = form.respond_to?(:to_sym) ? form.to_sym : form.to_s.to_sym
-      super([], options, &block)
+      super([], **options, &block)
     end
 
     ##
@@ -131,11 +128,15 @@ class SPARQL::Client
     # @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
+    # @param  [Array<Symbol>, Hash{Symbol => RDF::Query::Variable}] variables
     # @return [Query]
     # @see    http://www.w3.org/TR/sparql11-query/#select
     def select(*variables)
-      @values = variables.map { |var| [var, RDF::Query::Variable.new(var)] }
+      @values = if variables.length == 1 && variables.first.is_a?(Hash)
+        variables.to_a
+      else
+        variables.map { |var| [var, RDF::Query::Variable.new(var)] }
+      end
       self
     end
 
@@ -240,7 +241,7 @@ class SPARQL::Client
     #   query.select.where([:s, :p, :o]).order_by(:o, :p)
     #
     # @example SELECT * WHERE { ?s ?p ?o . } ORDER BY ASC(?o) DESC(?p)
-    #   query.select.where([:s, :p, :o]).order_by(:o => :asc, :p => :desc)
+    #   query.select.where([:s, :p, :o]).order_by(o: :asc, p: :desc)
     #
     # @param  [Array<Symbol, String>] variables
     # @return [Query]
@@ -727,7 +728,7 @@ class SPARQL::Client
         buffer << 'ORDER BY'
         options[:order_by].map { |elem|
           case elem
-            # .order_by({ :var1 => :asc, :var2 => :desc})
+            # .order_by({ var1: :asc, var2: :desc})
             when Hash
               elem.each { |key, val|
                 # check provided values

data/lib/sparql/client/repository.rb

@@ -14,9 +14,9 @@ class SPARQL::Client
     def initialize(uri: nil, **options, &block)
       raise ArgumentError, "uri is a required parameter" unless uri
       @options = options.merge(uri: uri)
-      @update_client = SPARQL::Client.new(options.delete(:update_endpoint), options) if options[:update_endpoint]
-      @client  = SPARQL::Client.new(uri, options)
-      super(@options, &block)
+      @update_client = SPARQL::Client.new(options.delete(:update_endpoint), **options) if options[:update_endpoint]
+      @client  = SPARQL::Client.new(uri, **options)
+      super(**@options, &block)
     end
 
     ##
@@ -115,7 +115,7 @@ class SPARQL::Client
     # @see    RDF::Repository#each_subject?
     def each_subject(&block)
       if block_given?
-        client.select(:s, :distinct => true).where([:s, :p, :o]).each_solution { |solution| block.call(solution[:s]) }
+        client.select(:s, distinct: true).where([:s, :p, :o]).each_solution { |solution| block.call(solution[:s]) }
       end
       enum_subject
     end
@@ -129,7 +129,7 @@ class SPARQL::Client
     # @see    RDF::Repository#each_predicate?
     def each_predicate(&block)
       if block_given?
-        client.select(:p, :distinct => true).where([:s, :p, :o]).each_solution { |solution| block.call(solution[:p]) }
+        client.select(:p, distinct: true).where([:s, :p, :o]).each_solution { |solution| block.call(solution[:p]) }
       end
       enum_predicate
     end
@@ -143,7 +143,7 @@ class SPARQL::Client
     # @see    RDF::Repository#each_object?
     def each_object(&block)
       if block_given?
-        client.select(:o, :distinct => true).where([:s, :p, :o]).each_solution { |solution| block.call(solution[:o]) }
+        client.select(:o, distinct: true).where([:s, :p, :o]).each_solution { |solution| block.call(solution[:o]) }
       end
       enum_object
     end
@@ -262,10 +262,10 @@ class SPARQL::Client
     # @return [void] ignored
     # @see    RDF::Queryable#query
     # @see    RDF::Query#execute
-    def query_execute(query, options = {}, &block)
+    def query_execute(query, **options, &block)
       return nil unless block_given?
-      q = SPARQL::Client::Query.select(query.variables).where(*query.patterns)
-      client.query(q, options).each do |solution|
+      q = SPARQL::Client::Query.select(query.variables, **{}).where(*query.patterns)
+      client.query(q, **options).each do |solution|
         yield solution
       end
     end
@@ -275,7 +275,7 @@ class SPARQL::Client
     #
     # @example
     #     repository.query([nil, RDF::DOAP.developer, nil])
-    #     repository.query(:predicate => RDF::DOAP.developer)
+    #     repository.query({predicate: RDF::DOAP.developer})
     #
     # @todo This should use basic SPARQL query mechanism.
     #
@@ -284,7 +284,7 @@ class SPARQL::Client
     # @yield  [statement]
     # @yieldparam [Statement]
     # @return [Enumerable<Statement>]
-    def query_pattern(pattern, options = {}, &block)
+    def query_pattern(pattern, **options, &block)
       pattern = pattern.dup
       pattern.subject   ||= RDF::Query::Variable.new
       pattern.predicate ||= RDF::Query::Variable.new

data/lib/sparql/client/update.rb

@@ -12,12 +12,12 @@ class SPARQL::Client
     #   insert_data(data)
     #
     # @example INSERT DATA \{ GRAPH <http://example.org/> \{\}\}
-    #   insert_data(RDF::Graph.new, :graph => 'http://example.org/')
+    #   insert_data(RDF::Graph.new, graph: 'http://example.org/')
     #   insert_data(RDF::Graph.new).graph('http://example.org/')
     #
     # @param (see InsertData#initialize)
-    def self.insert_data(*arguments)
-      InsertData.new(*arguments)
+    def self.insert_data(*arguments, **options)
+      InsertData.new(*arguments, **options)
     end
 
     ##
@@ -30,12 +30,12 @@ class SPARQL::Client
     #   delete_data(data)
     #
     # @example DELETE DATA \{ GRAPH <http://example.org/> \{\}\}
-    #   delete_data(RDF::Graph.new, :graph => 'http://example.org/')
+    #   delete_data(RDF::Graph.new, graph: 'http://example.org/')
     #   delete_data(RDF::Graph.new).graph('http://example.org/')
     #
     # @param (see DeleteData#initialize)
-    def self.delete_data(*arguments)
-      DeleteData.new(*arguments)
+    def self.delete_data(*arguments, **options)
+      DeleteData.new(*arguments, **options)
     end
 
     ##
@@ -53,8 +53,8 @@ class SPARQL::Client
     #   load(RDF::URI(http://example.org/data.rdf), into: RDF::URI(http://example.org/data.rdf))
     #
     # @param (see Load#initialize)
-    def self.load(*arguments)
-      Load.new(*arguments)
+    def self.load(*arguments, **options)
+      Load.new(*arguments, **options)
     end
 
     ##
@@ -81,8 +81,8 @@ class SPARQL::Client
     #   clear(:all, silent: true)
     #
     # @param (see Clear#initialize)
-    def self.clear(*arguments)
-      Clear.new(*arguments)
+    def self.clear(*arguments, **options)
+      Clear.new(*arguments, **options)
     end
 
     ##
@@ -96,8 +96,8 @@ class SPARQL::Client
     #   create(RDF::URI(http://example.org/data.rdf), silent: true)
     #
     # @param (see Create#initialize)
-    def self.create(*arguments)
-      Create.new(*arguments)
+    def self.create(*arguments, **options)
+      Create.new(*arguments, **options)
     end
 
     ##
@@ -124,15 +124,15 @@ class SPARQL::Client
     #   drop(:all, silent: true)
     #
     # @param (see Drop#initialize)
-    def self.drop(*arguments)
-      Drop.new(*arguments)
+    def self.drop(*arguments, **options)
+      Drop.new(*arguments, **options)
     end
 
     class Operation
       attr_reader :options
 
-      def initialize(*arguments)
-        @options = arguments.last.is_a?(Hash) ? arguments.pop.dup : {}
+      def initialize(*arguments, **options)
+        @options = options.dup
         unless arguments.empty?
           send(arguments.shift, *arguments)
         end
@@ -171,9 +171,9 @@ class SPARQL::Client
       #   
       # @param [Array<RDF::Statement>, RDF::Enumerable] data
       # @param  [Hash{Symbol => Object}] options
-      def initialize(data, options = {})
+      def initialize(data, **options)
         @data = data
-        super(options)
+        super(**options)
       end
 
       ##
@@ -221,9 +221,9 @@ class SPARQL::Client
       #   
       # @param [Array<RDF::Statement>, RDF::Enumerable] data
       # @param  [Hash{Symbol => Object}] options
-      def initialize(data, options = {})
+      def initialize(data, **options)
         @data = data
-        super(options)
+        super(**options)
       end
 
       ##
@@ -253,11 +253,11 @@ class SPARQL::Client
       attr_reader :delete_graph
       attr_reader :where_graph
 
-      def initialize(_delete_graph, _insert_graph = nil, _where_graph = nil, options = {})
+      def initialize(_delete_graph, _insert_graph = nil, _where_graph = nil, **options)
         @delete_graph = _delete_graph
         @insert_graph = _insert_graph
         @where_graph = _where_graph
-        super(options)
+        super(**options)
       end
 
       ##
@@ -324,11 +324,10 @@ class SPARQL::Client
       # @param  [Hash{Symbol => Object}] options
       # @option [RDF::URI] :into
       # @option [Boolean] :silent
-      def initialize(from, options = {})
-        options = options.dup
+      def initialize(from, into: nil,**options)
         @from = RDF::URI(from)
-        @into = RDF::URI(options.delete(:into)) if options[:into]
-        super(options)
+        @into = RDF::URI(into) if into
+        super(**options)
       end
 
       ##
@@ -420,9 +419,9 @@ class SPARQL::Client
       attr_reader :uri
 
       # @param  [Hash{Symbol => Object}] options
-      def initialize(uri, options = {})
+      def initialize(uri, **options)
         @uri = RDF::URI(uri)
-        super(options)
+        super(**options)
       end
 
       def to_s

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sparql-client
 version: !ruby/object:Gem::Version
-  version: 3.0.1
+  version: 3.1.0
 platform: ruby
 authors:
 - Arto Bendiken
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-03 00:00:00.000000000 Z
+date: 2019-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
@@ -18,118 +18,112 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
 - !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'
+        version: '3.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.9'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '4'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: rdf-spec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: sparql
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.7'
+        version: '3.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.7'
+        version: '3.9'
 - !ruby/object:Gem::Dependency
   name: rspec-its
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: webmock
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.7'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.12
+        version: 0.9.20
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.12
+        version: 0.9.20
 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.
@@ -162,15 +156,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.2.2
+      version: '2.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: SPARQL client for RDF.rb.