sparql-client 3.2.0 → 3.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91430f8e6c63118569f32b193b274fe8f19ca59728af08591177bdd5795ff05e
-  data.tar.gz: 3e0da28e7522a09004e2ac4bcd1b42e17cc943f02fd242d3a9e399597baa33e1
+  metadata.gz: 2c9eca6a3f6e57b16150e55c6a595c616c4b8b58778772e619168e5dd19c05a5
+  data.tar.gz: 5c383ab056d6f28951a366a5cb546f3aa900e7c81170b2f42a04ce72167deea8
 SHA512:
-  metadata.gz: 21e38994cd92126304d4a481a3ee471018c9dd99206d537340b2c91eb49bd853bd76fa3bf558e795ed18110b6d639f97cb5288d2b520f5196739d7bb9cc0f095
-  data.tar.gz: 75a14ccdce74d985fb83f541853e4e8d95edfeb9c8d59a5f5fbc988cf378c985623df574585480e30945791327ce9f99ab5da2178b5c886c8cc91152d7174442
+  metadata.gz: 12f686f4d066f3539de0fd3924895bbd854d2998f4b666d60e58df2efac33343c214588ff19b5ed759d8f2c481f8c3ff5a02f9f432fe55977a56e4080029d8c1
+  data.tar.gz: 4168b202c647758fffb13ad0a6445b46d797a34482764cdc5efb3a9e36a258c0157e03f958eaf5a96530453210afbbcc986aa0b3374a849dde73a9f090d15b6d

data/README.md

@@ -2,9 +2,9 @@
 
 This is a [Ruby][] implementation of a [SPARQL][] client for [RDF.rb][].
 
-* <https://ruby-rdf.github.com/sparql-client/>
+* <https://ruby-rdf.github.io/sparql-client/>
 
-[![Gem Version](https://badge.fury.io/rb/sparql-client.png)](https://badge.fury.io/rb/sparql-client)
+[![Gem Version](https://badge.fury.io/rb/sparql-client.svg)](https://badge.fury.io/rb/sparql-client)
 [![Build Status](https://github.com/ruby-rdf/sparql-client/workflows/CI/badge.svg?branch=develop)](https://github.com/ruby-rdf/sparql-client/actions?query=workflow%3ACI)
 [![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)
 [![Gitter chat](https://badges.gitter.im/ruby-rdf/rdf.png)](https://gitter.im/ruby-rdf/rdf)
@@ -44,7 +44,7 @@ sparql = SPARQL::Client.new("http://dbpedia.org/sparql", headers: {'User-Agent'
 
 ```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")
 ```
 
 
@@ -117,10 +117,10 @@ sparql.delete_data(data)
 
 ## Documentation
 
-* [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)
+* [SPARQL::Client](https://ruby-rdf.github.io/sparql-client/SPARQL/Client)
+  * [SPARQL::Client::Query](https://ruby-rdf.github.io/sparql-client/SPARQL/Client/Query)
+  * [SPARQL::Client::Repository](https://ruby-rdf.github.io/sparql-client/SPARQL/Client/Repository)
+  * [SPARQL::Client::Update](https://ruby-rdf.github.io/sparql-client/SPARQL/Client/Update)
 
 ## Dependencies
 
@@ -191,7 +191,7 @@ This repository uses [Git Flow](https://github.com/nvie/gitflow) to mange develo
 
 ## Resources
 
-* <https://ruby-rdf.github.com/sparql-client/>
+* <https://ruby-rdf.github.io/sparql-client/>
 * <https://github.com/ruby-rdf/sparql-client>
 * <https://rubygems.org/gems/sparql-client>
 * <https://raa.ruby-lang.org/project/sparql-client/>
@@ -207,7 +207,7 @@ see <https://unlicense.org/> or the accompanying {file:UNLICENSE} file.
 [SPARQL]:          https://en.wikipedia.org/wiki/SPARQL
 [SPARQL JSON]:     https://www.w3.org/TR/rdf-sparql-json-res/
 [RDF.rb]:          https://rubygems.org/gems/rdf
-[RDF::Repository]: https://rubydoc.info/github/ruby-rdf/rdf/RDF/Repository
+[RDF::Repository]: https://ruby-rdf.github.io/rdf/RDF/Repository
 [DSL]:             https://en.wikipedia.org/wiki/Domain-specific_language
                    "domain-specific language"
 [YARD]:            https://yardoc.org/

data/VERSION

@@ -1 +1 @@
-3.2.0
+3.2.2

data/lib/sparql/client/query.rb

@@ -111,7 +111,7 @@ class SPARQL::Client
 
     ##
     # @example ASK WHERE { ?s ?p ?o . }
-    #   query.ask.where([:s, :p, :o])
+    #   Query.ask.where([:s, :p, :o])
     #
     # @return [Query]
     # @see    https://www.w3.org/TR/sparql11-query/#ask
@@ -122,13 +122,13 @@ class SPARQL::Client
 
     ##
     # @example `SELECT * WHERE { ?s ?p ?o . }`
-    #   query.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])
+    #   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])
+    #   Query.select(count: {uri: :c}).where([:uri, RDF.type, RDF::OWL.Class])
     #
     # @param  [Array<Symbol>, Hash{Symbol => RDF::Query::Variable}] variables
     # @return [Query]
@@ -144,7 +144,7 @@ class SPARQL::Client
 
     ##
     # @example DESCRIBE * WHERE { ?s ?p ?o . }
-    #   query.describe.where([:s, :p, :o])
+    #   Query.describe.where([:s, :p, :o])
     #
     # @param  [Array<Symbol>] variables
     # @return [Query]
@@ -158,7 +158,7 @@ class SPARQL::Client
 
     ##
     # @example CONSTRUCT { ?s ?p ?o . } WHERE { ?s ?p ?o . }
-    #   query.construct([:s, :p, :o]).where([:s, :p, :o])
+    #   Query.construct([:s, :p, :o]).where([:s, :p, :o])
     #
     # @param  [Array<RDF::Query::Pattern, Array>] patterns
     # @return [Query]
@@ -170,7 +170,7 @@ class SPARQL::Client
 
     ##
     # @example SELECT * FROM <a> WHERE \{ ?s ?p ?o . \}
-    #   query.select.from(RDF::URI.new(a)).where([:s, :p, :o])
+    #   Query.select.from(RDF::URI.new(a)).where([:s, :p, :o])
     #
     # @param [RDF::URI] uri
     # @return [Query]
@@ -182,22 +182,22 @@ class SPARQL::Client
 
     ##
     # @example SELECT * WHERE { ?s ?p ?o . }
-    #   query.select.where([:s, :p, :o])
-    #   query.select.whether([:s, :p, :o])
+    #   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)
+    #   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|
+    #   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
+    #   Query.select.where([:s, :p, :o]) do
     #     order(:o)
     #   end
     #
@@ -236,14 +236,14 @@ class SPARQL::Client
 
     ##
     # @example SELECT * WHERE { ?s ?p ?o . } ORDER BY ?o
-    #   query.select.where([:s, :p, :o]).order(:o)
-    #   query.select.where([:s, :p, :o]).order_by(:o)
+    #   Query.select.where([:s, :p, :o]).order(:o)
+    #   Query.select.where([:s, :p, :o]).order_by(:o)
     #
     # @example SELECT * WHERE { ?s ?p ?o . } ORDER BY ?o ?p
-    #   query.select.where([:s, :p, :o]).order_by(:o, :p)
+    #   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]
@@ -257,8 +257,8 @@ class SPARQL::Client
 
     ##
     # @example SELECT * WHERE { ?s ?p ?o . } ORDER BY ASC(?o)
-    #   query.select.where([:s, :p, :o]).order.asc(:o)
-    #   query.select.where([:s, :p, :o]).asc(:o)
+    #   Query.select.where([:s, :p, :o]).order.asc(:o)
+    #   Query.select.where([:s, :p, :o]).asc(:o)
     #
     # @param  [Array<Symbol, String>] var
     # @return [Query]
@@ -270,8 +270,8 @@ class SPARQL::Client
 
     ##
     # @example SELECT * WHERE { ?s ?p ?o . } ORDER BY DESC(?o)
-    #   query.select.where([:s, :p, :o]).order.desc(:o)
-    #   query.select.where([:s, :p, :o]).desc(:o)
+    #   Query.select.where([:s, :p, :o]).order.desc(:o)
+    #   Query.select.where([:s, :p, :o]).desc(:o)
     #
     # @param  [Array<Symbol, String>] var
     # @return [Query]
@@ -283,7 +283,7 @@ class SPARQL::Client
 
     ##
     # @example SELECT ?s WHERE { ?s ?p ?o . } GROUP BY ?s
-    #   query.select(:s).where([:s, :p, :o]).group_by(:s)
+    #   Query.select(:s).where([:s, :p, :o]).group_by(:s)
     #
     # @param  [Array<Symbol, String>] variables
     # @return [Query]
@@ -297,7 +297,7 @@ class SPARQL::Client
 
     ##
     # @example SELECT DISTINCT ?s WHERE { ?s ?p ?o . }
-    #   query.select(:s).distinct.where([:s, :p, :o])
+    #   Query.select(:s).distinct.where([:s, :p, :o])
     #
     # @return [Query]
     # @see    https://www.w3.org/TR/sparql11-query/#modDuplicates
@@ -308,7 +308,7 @@ class SPARQL::Client
 
     ##
     # @example SELECT REDUCED ?s WHERE { ?s ?p ?o . }
-    #   query.select(:s).reduced.where([:s, :p, :o])
+    #   Query.select(:s).reduced.where([:s, :p, :o])
     #
     # @return [Query]
     # @see    https://www.w3.org/TR/sparql11-query/#modDuplicates
@@ -319,7 +319,8 @@ class SPARQL::Client
 
     ##
     # @example SELECT * WHERE { GRAPH ?g { ?s ?p ?o . } }
-    #   query.select.graph(:g).where([:s, :p, :o])
+    #   Query.select.graph(:g).where([:s, :p, :o])
+    #
     # @param  [RDF::Value] graph_uri_or_var
     # @return [Query]
     # @see    https://www.w3.org/TR/sparql11-query/#queryDataset
@@ -335,7 +336,7 @@ class SPARQL::Client
 
     ##
     # @example SELECT * WHERE { ?s ?p ?o . } OFFSET 100
-    #   query.select.where([:s, :p, :o]).offset(100)
+    #   Query.select.where([:s, :p, :o]).offset(100)
     #
     # @param  [Integer, #to_i] start
     # @return [Query]
@@ -346,7 +347,7 @@ class SPARQL::Client
 
     ##
     # @example SELECT * WHERE { ?s ?p ?o . } LIMIT 10
-    #   query.select.where([:s, :p, :o]).limit(10)
+    #   Query.select.where([:s, :p, :o]).limit(10)
     #
     # @param  [Integer, #to_i] length
     # @return [Query]
@@ -357,7 +358,7 @@ class SPARQL::Client
 
     ##
     # @example SELECT * WHERE { ?s ?p ?o . } OFFSET 100 LIMIT 10
-    #   query.select.where([:s, :p, :o]).slice(100, 10)
+    #   Query.select.where([:s, :p, :o]).slice(100, 10)
     #
     # @param  [Integer, #to_i] start
     # @param  [Integer, #to_i] length
@@ -371,7 +372,7 @@ class SPARQL::Client
     ##
     # @overload prefix(prefix: uri)
     #   @example PREFIX dc: <http://purl.org/dc/elements/1.1/> PREFIX foaf: <http://xmlns.com/foaf/0.1/> SELECT * WHERE \{ ?s ?p ?o . \}
-    #     query.select.
+    #     Query.select.
     #       prefix(dc: RDF::URI("http://purl.org/dc/elements/1.1/")).
     #       prefix(foaf: RDF::URI("http://xmlns.com/foaf/0.1/")).
     #       where([:s, :p, :o])
@@ -382,7 +383,7 @@ class SPARQL::Client
     #
     # @overload prefix(string)
     #   @example PREFIX dc: <http://purl.org/dc/elements/1.1/> PREFIX foaf: <http://xmlns.com/foaf/0.1/> SELECT * WHERE \{ ?s ?p ?o . \}
-    #     query.select.
+    #     Query.select.
     #       prefix("dc: <http://purl.org/dc/elements/1.1/>").
     #       prefix("foaf: <http://xmlns.com/foaf/0.1/>").
     #       where([:s, :p, :o])
@@ -406,13 +407,13 @@ class SPARQL::Client
 
     ##
     # @example SELECT * WHERE \{ ?s ?p ?o . OPTIONAL \{ ?s a ?o . ?s \<http://purl.org/dc/terms/abstract\> ?o . \} \}
-    #   query.select.where([:s, :p, :o]).
+    #   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
+    #   Query.ask.where([:s, :p, :o]).optional([:s, :p, :o]) do
     #     filter("regex(?s, 'Abiline, Texas')")
     #   end
     #
@@ -441,22 +442,89 @@ class SPARQL::Client
       self
     end
 
+    ##
+    # Federated Queries via the SERVICE keyword.
+    #
+    # Supports limited use of the SERVICE keyword with an endpoint term, a sequence of patterns, a query, or a block.
+    #
+    # @example SELECT * WHERE \{ ?s ?p1 ?o1 . SERVICE ?l \{ ?s ?p2 ?o2 \} \}
+    #   Query.select.where([:s, :p1, :o1]).
+    #     service(:l, [:s, :p2, :o2])
+    #
+    # @example SELECT * WHERE \{ ?book <http://purl.org/dc/terms/title> ?title . SERVICE ?l \{ ?book <http://purl.org/dc/elements/1.1/title> ?title . FILTER(langmatches(?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]).service(?l, 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 \} SERVICE ?l \{ ?book dc11:title ?title \}
+    #   query1 = SPARQL::Client::Query.select.where([:book, RDF::Vocab::DC11.title, :title])
+    #   Query.select.where([:book, RDF::Vocab::DC.title, :title]).service :l do |q|
+    #     q.select.
+    #       where([:book, RDF::Vocab::DC11.title, :title])
+    #   end
+    #
+    # @example SELECT * WHERE \{ ?s ?p1 ?o1 . SERVICE SILENT ?l \{ ?s ?p2 ?o2 \} \}
+    #   Query.select.where([:s, :p1, :o1]).
+    #     service(:l, [:s, :p2, :o2], silent: true)
+    #
+    # @param  [Array<RDF::Query::Pattern, Array>] patterns
+    #   splat of zero or more patterns followed by zero or more queries.
+    # @param [Boolean] silent
+    # @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    https://www.w3.org/TR/sparql11-federated-query/
+    def service(endpoint, *patterns, silent: false, &block)
+      service = {
+        endpoint: (endpoint.is_a?(Symbol) ? RDF::Query::Variable.new(endpoint) : endpoint),
+        silent: silent,
+        query: nil
+      }
+      (options[:services] ||= []) << service
+
+      if block_given?
+        raise ArgumentError, "#service requires either arguments or a block, not both." unless patterns.empty?
+        # Evaluate calls in a new query instance
+        query = self.class.select.where
+        case block.arity
+          when 1 then block.call(query)
+          else query.instance_eval(&block)
+        end
+        service[:query] = query
+      elsif patterns.all? {|p| p.is_a?(SPARQL::Client::Query)}
+        # With argument form, all must be patterns or queries
+        raise ArgumentError, "#service arguments are triple patterns or a query, not both." if patterns.length != 1
+        service[:query] = patterns.first
+      elsif patterns.all? {|p| p.is_a?(Array)}
+        # With argument form, all must be patterns, or queries
+        service[:query] = self.class.select.where(*patterns)
+      else
+        raise ArgumentError, "#service arguments are triple patterns a query, not both."
+      end
+
+      self
+    end
+
     ##
     # @example SELECT * WHERE \{ ?book dc:title ?title \} UNION \{ ?book dc11:title ?title \}
-    #   query.select.where([:book, RDF::Vocab::DC.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)
+    #   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|
+    #   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')")
@@ -468,7 +536,7 @@ class SPARQL::Client
     #   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    https://www.w3.org/TR/sparql11-query/#optionals
+    # @see    https://www.w3.org/TR/sparql11-query/#alternatives
     def union(*patterns, &block)
       options[:unions] ||= []
 
@@ -488,7 +556,7 @@ class SPARQL::Client
         # 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."
+        raise ArgumentError, "#union arguments are triple patterns or queries, not both."
       end
 
       self
@@ -496,20 +564,20 @@ class SPARQL::Client
 
     ##
     # @example SELECT * WHERE \{ ?book dc:title ?title . MINUS \{ ?book dc11:title ?title \} \}
-    #   query.select.where([:book, RDF::Vocab::DC.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)
+    #   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|
+    #   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')")
@@ -521,7 +589,7 @@ class SPARQL::Client
     #   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    https://www.w3.org/TR/sparql11-query/#optionals
+    # @see    https://www.w3.org/TR/sparql11-query/#negation
     def minus(*patterns, &block)
       options[:minuses] ||= []
 
@@ -541,7 +609,7 @@ class SPARQL::Client
         # 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."
+        raise ArgumentError, "#minus arguments are triple patterns or queries, not both."
       end
 
       self
@@ -557,12 +625,12 @@ class SPARQL::Client
     #
     # @overload values(vars, *data)
     #   @example single variable with multiple values
-    #     query.select
+    #     Query.select
     #      .where([:s, RDF::URI('http://purl.org/dc/terms/title'), :title])
     #      .values(:title, "This title", "Another title")
     #
     #   @example multiple variables with multiple values
-    #     query.select
+    #     Query.select
     #      .where([:s, RDF::URI('http://purl.org/dc/terms/title'), :title],
     #             [:s, RDF.type, :type])
     #      .values([:type, :title],
@@ -570,7 +638,7 @@ class SPARQL::Client
     #              [RDF::URI('http://pcdm.org/models#Collection', 'Another title'])
     #
     #   @example multiple variables with UNDEF
-    #     query.select
+    #     Query.select
     #      .where([:s, RDF::URI('http://purl.org/dc/terms/title'), :title],
     #             [:s, RDF.type, :type])
     #      .values([:type, :title],
@@ -626,7 +694,7 @@ class SPARQL::Client
 
     ##
     # @example ASK WHERE { ?s ?p ?o . FILTER(regex(?s, 'Abiline, Texas')) }
-    #   query.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] ||= []) << Filter.new(string)) if string and not string.empty?
@@ -796,6 +864,16 @@ class SPARQL::Client
       if options[:filters]
         buffer += options[:filters].map(&:to_s)
       end
+
+      if options[:services]
+        options[:services].each do |service|
+          buffer << 'SERVICE'
+          buffer << 'SILENT' if service[:silent]
+          buffer << SPARQL::Client.serialize_value(service[:endpoint])
+          buffer << service[:query].to_s_ggp
+        end
+      end
+
       if options[:values]
         vars = options[:values].first.map {|var| SPARQL::Client.serialize_value(var)}
         buffer << "VALUES (#{vars.join(' ')}) {"

data/lib/sparql/client.rb

@@ -116,7 +116,14 @@ module SPARQL
     # Close the http connection when object is deallocated
     def self.finalize(klass)
       proc do
-        klass.shutdown if klass.respond_to?(:shutdown)
+        if klass.respond_to?(:shutdown)
+          begin
+            # Attempt asynchronous shutdown
+            Thread.new {klass.shutdown}
+          rescue ThreadError
+            klass.shutdown
+          end
+        end
       end
     end
 
@@ -423,7 +430,13 @@ module SPARQL
             end
             RDF::Query::Solution.new(row)
           end
-          RDF::Query::Solutions.new(solutions)
+          solns = RDF::Query::Solutions.new(solutions)
+
+          # Set variable names explicitly
+          if json.fetch('head', {}).has_key?('vars')
+            solns.variable_names = json['head']['vars'].map(&:to_sym)
+          end
+          solns
       end
     end
 
@@ -484,20 +497,23 @@ module SPARQL
       vars = tsv.shift.map {|h| h.sub(/^\?/, '')}
       solutions = RDF::Query::Solutions.new
       tsv.each do |row|
+        # Flesh out columns which may be missing
+        vars.each_with_index do |_, i|
+          row[i] ||= ""
+        end
         solution = RDF::Query::Solution.new
         row.each_with_index do |v, i|
-          if !v.empty?
-            term = RDF::NTriples.unserialize(v) || case v
-            when /^\d+\.\d*[eE][+-]?[0-9]+$/  then RDF::Literal::Double.new(v)
-            when /^\d*\.\d+[eE][+-]?[0-9]+$/  then RDF::Literal::Double.new(v)
-            when /^\d*\.\d+$/                 then RDF::Literal::Decimal.new(v)
-            when /^\d+$/                      then RDF::Literal::Integer.new(v)
-            else
-              RDF::Literal(v)
-            end
-            nodes[term.id] = term if term.is_a? RDF::Node
-            solution[vars[i].to_sym] = term
+          term = case v
+          when ""                           then RDF::Literal("")
+          when /^\d+\.\d*[eE][+-]?[0-9]+$/  then RDF::Literal::Double.new(v)
+          when /^\d*\.\d+[eE][+-]?[0-9]+$/  then RDF::Literal::Double.new(v)
+          when /^\d*\.\d+$/                 then RDF::Literal::Decimal.new(v)
+          when /^\d+$/                      then RDF::Literal::Integer.new(v)
+          else
+            RDF::NTriples.unserialize(v) || RDF::Literal(v)
           end
+          nodes[term.id] = term if term.is_a? RDF::Node
+          solution[vars[i].to_sym] = term
         end
         solutions << solution
       end
@@ -506,45 +522,57 @@ module SPARQL
 
     ##
     # @param  [String, IO, Nokogiri::XML::Node, REXML::Element] xml
+    # @param  [Symbol] library (:nokogiri)
+    #   One of :nokogiri or :rexml.
     # @return [<RDF::Query::Solutions>]
     # @see    https://www.w3.org/TR/rdf-sparql-json-res/#results
-    def self.parse_xml_bindings(xml, nodes = {})
+    def self.parse_xml_bindings(xml, nodes = {}, library: :nokogiri)
       xml.force_encoding(::Encoding::UTF_8) if xml.respond_to?(:force_encoding)
 
-      if defined?(::Nokogiri)
+      if defined?(::Nokogiri) && library == :nokogiri
         xml = Nokogiri::XML(xml).root unless xml.is_a?(Nokogiri::XML::Document)
         case
-          when boolean = xml.xpath("//sparql:boolean", XMLNS)[0]
-            boolean.text == 'true'
-          when results = xml.xpath("//sparql:results", XMLNS)[0]
-            solutions = results.elements.map do |result|
-              row = {}
-              result.elements.each do |binding|
-                name  = binding.attr('name').to_sym
-                value = binding.elements.first
-                row[name] = parse_xml_value(value, nodes)
-              end
-              RDF::Query::Solution.new(row)
+        when boolean = xml.xpath("//sparql:boolean", XMLNS)[0]
+          boolean.text == 'true'
+        when results = xml.xpath("//sparql:results", XMLNS)[0]
+          solutions = results.elements.map do |result|
+            row = {}
+            result.elements.each do |binding|
+              name  = binding.attr('name').to_sym
+              value = binding.elements.first
+              row[name] = parse_xml_value(value, nodes) if value
             end
-            RDF::Query::Solutions.new(solutions)
+            RDF::Query::Solution.new(row)
+          end
+          solns = RDF::Query::Solutions.new(solutions)
+
+          # Set variable names explicitly
+          var_names = xml.xpath("//sparql:head/sparql:variable/@name", XMLNS)
+          solns.variable_names = var_names.map(&:to_s)
+          solns
         end
       else
         # REXML
         xml = REXML::Document.new(xml).root unless xml.is_a?(REXML::Element)
         case
-          when boolean = xml.elements['boolean']
-            boolean.text == 'true'
-          when results = xml.elements['results']
-            solutions = results.elements.map do |result|
-              row = {}
-              result.elements.each do |binding|
-                name  = binding.attributes['name'].to_sym
-                value = binding.select { |node| node.kind_of?(::REXML::Element) }.first
-                row[name] = parse_xml_value(value, nodes)
-              end
-              RDF::Query::Solution.new(row)
+        when boolean = xml.elements['boolean']
+          boolean.text == 'true'
+        when results = xml.elements['results']
+          solutions = results.elements.map do |result|
+            row = {}
+            result.elements.each do |binding|
+              name  = binding.attributes['name'].to_sym
+              value = binding.select { |node| node.kind_of?(::REXML::Element) }.first
+              row[name] = parse_xml_value(value, nodes) if value
             end
-            RDF::Query::Solutions.new(solutions)
+            RDF::Query::Solution.new(row)
+          end
+          solns = RDF::Query::Solutions.new(solutions)
+
+          # Set variable names explicitly
+          var_names = xml.elements['head'].elements.map {|e| e.attributes['name']}
+          solns.variable_names = var_names.map(&:to_sym)
+          solns
         end
       end
     end
@@ -578,7 +606,7 @@ module SPARQL
     # @return [RDF::Enumerable]
     def parse_rdf_serialization(response, **options)
       options = {content_type: response.content_type} unless options[:content_type]
-      if reader = RDF::Reader.for(options)
+      if reader = RDF::Reader.for(**options)
         reader.new(response.body)
       else
         raise RDF::ReaderError, "no RDF reader was found for #{options}."

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sparql-client
 version: !ruby/object:Gem::Version
-  version: 3.2.0
+  version: 3.2.2
 platform: ruby
 authors:
 - Arto Bendiken
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-13 00:00:00.000000000 Z
+date: 2023-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
@@ -19,6 +19,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.11
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,6 +29,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.11
 - !ruby/object:Gem::Dependency
   name: net-http-persistent
   requirement: !ruby/object:Gem::Requirement
@@ -35,7 +41,7 @@ dependencies:
         version: '4.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.1
+        version: 4.0.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -45,7 +51,7 @@ dependencies:
         version: '4.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.1
+        version: 4.0.2
 - !ruby/object:Gem::Dependency
   name: rdf-spec
   requirement: !ruby/object:Gem::Requirement
@@ -80,14 +86,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.10'
+        version: '3.12'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.10'
+        version: '3.12'
 - !ruby/object:Gem::Dependency
   name: rspec-its
   requirement: !ruby/object:Gem::Requirement
@@ -150,10 +156,15 @@ files:
 - lib/sparql/client/repository.rb
 - lib/sparql/client/update.rb
 - lib/sparql/client/version.rb
-homepage: https://github.com/ruby-rdf/sparql-client/
+homepage: https://github.com/ruby-rdf/sparql-client
 licenses:
 - Unlicense
-metadata: {}
+metadata:
+  documentation_uri: https://ruby-rdf.github.io/sparql-client
+  bug_tracker_uri: https://github.com/ruby-rdf/sparql-client/issues
+  homepage_uri: https://github.com/ruby-rdf/sparql-client
+  mailing_list_uri: https://lists.w3.org/Archives/Public/public-rdf-ruby/
+  source_code_uri: https://github.com/ruby-rdf/sparql-client
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -169,7 +180,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.3.26
 signing_key:
 specification_version: 4
 summary: SPARQL client for RDF.rb.