sparql 3.0.1 → 3.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 900c6694040cb2734dd37b95a0ef83d4472b15dab000b9a46d906826e704eb42
-  data.tar.gz: deb1166c8c7dd97955fbf9365db30c704d91f568581e12a9eac898a69cb8319a
+  metadata.gz: 7ddc77cee587255c81cfcb3cd9d05759a3c98398821e23a25c3111f71e9b44c9
+  data.tar.gz: 48290eb8ba7ab1539c73c2fc3477b4004b8a15c5f09624ef24de5e3fe692ab03
 SHA512:
-  metadata.gz: b43b92f8a74e1e05531af98e98565341e7e2514f2fbcc517e06d46658f0067845c992f998c919f375ace373ac56e75d3427e772330dd45657e61718d55eb5961
-  data.tar.gz: 3aa55a0112712092b6fdf21d2e26c52d8ee5719bc128e511caf8dee371e916c891517e6dc8acf0bddf030bf71b6fba540b1798ff417a2490d62dd2d471c4874a
+  metadata.gz: 71b0e62c9d8d418e508befea92ca5723a24a0ccce9fcebf43f40ce7ee4a8299c81fdad5ae4302465defd04708abd04ef10c863ef1538f25c71c5a24ea45e826a
+  data.tar.gz: 6c1b568ed72dcdda4f68f613bcbf3de38512b8cde4b1c6b2a20d51370fb5bd4efce7dee766e3cfde64222853c52937890d5fcbeb48d4448a2694f0dce0729d0c

data/README.md

@@ -2,15 +2,14 @@
 
 This is a [Ruby][] implementation of [SPARQL][] for [RDF.rb][].
 
-[![Gem Version](https://badge.fury.io/rb/sparql.png)](http://badge.fury.io/rb/sparql)
-
-[![Build Status](https://travis-ci.org/ruby-rdf/sparql.png?branch=master)](http://travis-ci.org/ruby-rdf/sparql)
-
+[![Gem Version](https://badge.fury.io/rb/sparql.png)](https://badge.fury.io/rb/sparql)
+[![Build Status](https://github.com/ruby-rdf/sparql/workflows/CI/badge.svg?branch=develop)](https://github.com/ruby-rdf/sparql/actions?query=workflow%3ACI)
 [![Coverage Status](https://coveralls.io/repos/ruby-rdf/sparql/badge.svg)](https://coveralls.io/r/ruby-rdf/sparql)
+[![Gitter chat](https://badges.gitter.im/ruby-rdf/rdf.png)](https://gitter.im/ruby-rdf/rdf)
 
 ## Features
 
-* 100% free and unencumbered [public domain](http://unlicense.org/) software.
+* 100% free and unencumbered [public domain](https://unlicense.org/) software.
 * Complete [SPARQL 1.1 Query][] parsing and execution
 * SPARQL results as [XML][SPARQL XML], [JSON][SPARQL JSON],
   [CSV][SPARQL 1.1 Query Results CSV and TSV Formats],
@@ -27,6 +26,7 @@ This is a [Ruby][] implementation of [SPARQL][] for [RDF.rb][].
 * Compatible with Ruby >= 2.2.2.
 * Compatible with older Ruby versions with the help of the [Backports][] gem.
 * Supports Unicode query strings both on all versions of Ruby.
+* Provisional support for [SPARQL*][].
 
 ## Description
 
@@ -45,20 +45,20 @@ The {SPARQL} gem uses the [SPARQL 1.1 Query][] {file:etc/sparql11.html EBNF gram
 
 The SPARQL gem now implements the following [SPARQL 1.1 Query][] operations:
 
-* [Functions](http://www.w3.org/TR/sparql11-query/#SparqlOps)
-* [BIND](http://www.w3.org/TR/sparql11-query/#bind)
-* [GROUP BY](http://www.w3.org/TR/sparql11-query/#groupby)
-* [Aggregates](http://www.w3.org/TR/sparql11-query/#aggregates)
-* [Subqueries](http://www.w3.org/TR/sparql11-query/#subqueries)
-* [Inline Data](http://www.w3.org/TR/2013/REC-sparql11-query-20130321/#inline-data)
-* [Inline Data](http://www.w3.org/TR/2013/REC-sparql11-query-20130321/#inline-data)
-* [Exists](http://www.w3.org/TR/2013/REC-sparql11-query-20130321/#func-filter-exists)
-* [Negation](http://www.w3.org/TR/2013/REC-sparql11-query-20130321/#negation)
-* [Property Paths](http://www.w3.org/TR/2013/REC-sparql11-query-20130321/#propertypaths)
+* [Functions](https://www.w3.org/TR/sparql11-query/#SparqlOps)
+* [BIND](https://www.w3.org/TR/sparql11-query/#bind)
+* [GROUP BY](https://www.w3.org/TR/sparql11-query/#groupby)
+* [Aggregates](https://www.w3.org/TR/sparql11-query/#aggregates)
+* [Subqueries](https://www.w3.org/TR/sparql11-query/#subqueries)
+* [Inline Data](https://www.w3.org/TR/2013/REC-sparql11-query-20130321/#inline-data)
+* [Inline Data](https://www.w3.org/TR/2013/REC-sparql11-query-20130321/#inline-data)
+* [Exists](https://www.w3.org/TR/2013/REC-sparql11-query-20130321/#func-filter-exists)
+* [Negation](https://www.w3.org/TR/2013/REC-sparql11-query-20130321/#negation)
+* [Property Paths](https://www.w3.org/TR/2013/REC-sparql11-query-20130321/#propertypaths)
 
 The gem also includes the following [SPARQL 1.1 Update][] operations:
-* [Graph Update](http://www.w3.org/TR/sparql11-update/#graphUpdate)
-* [Graph Management](http://www.w3.org/TR/sparql11-update/#graphManagement)
+* [Graph Update](https://www.w3.org/TR/sparql11-update/#graphUpdate)
+* [Graph Management](https://www.w3.org/TR/sparql11-update/#graphManagement)
 
 Not supported:
 
@@ -70,15 +70,15 @@ Not supported:
 either in this, or related gems.
 
 ### Updates for RDF 1.1
-Starting with version 1.1.2, the SPARQL gem uses the 1.1 version of the [RDF.rb][], which adheres to [RDF 1.1 Concepts](http://www.w3.org/TR/rdf11-concepts/) rather than [RDF 1.0](http://www.w3.org/TR/rdf-concepts/). The main difference is that there is now no difference between a _Simple Literal_ (a literal with no datatype or language) and a Literal with datatype _xsd:string_; this causes some minor differences in the way in which queries are understood, and when expecting different results.
+Starting with version 1.1.2, the SPARQL gem uses the 1.1 version of the [RDF.rb][], which adheres to [RDF 1.1 Concepts](https://www.w3.org/TR/rdf11-concepts/) rather than [RDF 1.0](https://www.w3.org/TR/rdf-concepts/). The main difference is that there is now no difference between a _Simple Literal_ (a literal with no datatype or language) and a Literal with datatype _xsd:string_; this causes some minor differences in the way in which queries are understood, and when expecting different results.
 
 Additionally, queries now take a block, or return an `Enumerator`; this is in keeping with much of the behavior of [RDF.rb][] methods, including `Queryable#query`, and with version 1.1 or [RDF.rb][], Query#execute. As a consequence, all queries which used to be of the form `query.execute(repository)` may equally be called as `repository.query(query)`. Previously, results were returned as a concrete class implementing `RDF::Queryable` or `RDF::Query::Solutions`, these are now `Enumerators`.
 
 ### SPARQL Extension Functions
 Extension functions may be defined, which will be invoked during query evaluation. For example:
 
-    # Register a function using the IRI <http://rubygems.org/gems/sparql#crypt>
-    crypt_iri = RDF::URI("http://rubygems.org/gems/sparql#crypt")
+    # Register a function using the IRI <https://rubygems#crypt>
+    crypt_iri = RDF::URI("https://rubygems#crypt")
     SPARQL::Algebra::Expression.register_extension(crypt_iri) do |literal|
       raise TypeError, "argument must be a literal" unless literal.literal?
       RDF::Literal(literal.to_s.crypt)
@@ -86,7 +86,7 @@ Extension functions may be defined, which will be invoked during query evaluatio
 
 Then, use the function in a query:
 
-    PREFIX rsp: <http://rubygems.org/gems/sparql#>
+    PREFIX rsp: <https://rubygems#>
     PREFIX schema: <http://schema.org/>
     SELECT ?crypted
     {
@@ -96,6 +96,117 @@ Then, use the function in a query:
 
 See {SPARQL::Algebra::Expression.register_extension} for details.
 
+### SPARQLStar (SPARQL*)
+
+The gem supports [SPARQL*][] where patterns may include sub-patterns recursively, for a kind of Reification.
+
+For example, the following Turtle* file uses a statement as the subject of another statement:
+
+    @prefix : <http://bigdata.com/> .
+    @prefix foaf: <http://xmlns.com/foaf/0.1/> .
+    @prefix ex:  <http://example.org/> .
+
+    :bob foaf:name "Bob" .
+    <<:bob foaf:age 23>> ex:certainty 0.9 .
+
+This can be queried using the following query:
+
+    PREFIX : <http://bigdata.com/>
+    PREFIX foaf: <http://xmlns.com/foaf/0.1/>
+    PREFIX ex:  <http://example.org/>
+
+    SELECT ?age ?c WHERE {
+       ?bob foaf:name "Bob" .
+       <<?bob foaf:age ?age>> ex:certainty ?c .
+    }
+
+This treats `<<:bob foaf:age 23>>` as a subject resource, and the pattern `<<?bob foaf:age ?age>>` to match that resource and bind the associated variables.
+
+**Note: This feature is subject to change or elimination as the standards process progresses.**
+
+#### BIND
+
+There is an alternate syntax using the `BIND` operator:
+
+    PREFIX : <http://bigdata.com>
+    PREFIX foaf: <http://xmlns.com/foaf/0.1/>
+    PREFIX dct:  <http://purl.org/dc/elements/1.1/>
+
+    SELECT ?a ?b ?c WHERE {
+       ?bob foaf:name "Bob" .
+       BIND( <<?bob foaf:age ?age>> AS ?a ) .
+       ?t ?b ?c .
+    }
+
+When binding, the triple can be either in Property Graph (`:PG`) or Separate Assertions (`:SA`) mode, as the query matches based on the pattern matching as a subject (or object) and does not need to be specifically asserted in the graph. When parsing in Property Graph mode, such triples will also be added to the enclosing graph. Thus, querying for `<<?bob foaf:age ?age>>` and `?bob foaf:age ?age` may not represent the same results.
+
+When binding an embedded triple to a variable, it is the matched triples which are bound, not the pattern. Thus, the example above with `SELECT ?a ?b ?c` would end up binding `?a` to `:bob foaf:name 23`.
+
+#### Construct
+
+As well as a `CONSTRUCT`:
+
+    PREFIX : <http://bigdata.com>
+    PREFIX foaf: <http://xmlns.com/foaf/0.1/>
+    PREFIX dct:  <http://purl.org/dc/elements/1.1/>
+
+    CONSTRUCT {
+      ?bob foaf:name "Bob" .
+      <<?bob foaf:age ?age>> ?b ?c .
+    }
+    WHERE {
+      ?bob foaf:name "Bob" .
+      <<?bob foaf:age ?age>> ?b ?c .
+    }
+
+Note that results can be serialized only when the format supports [RDF*][].
+
+#### SPARQL results
+
+The SPARQL results formats are extended to serialize embedded triples as described for [RDF4J](https://rdf4j.org/documentation/programming/rdfstar/):
+
+    {
+      "head" : {
+        "vars" : [
+          "a",
+          "b",
+          "c"
+        ]
+      },
+      "results" : {
+        "bindings": [
+          { "a" : {
+              "type" : "triple",
+              "value" : {
+                "s" : {
+                  "type" : "uri",
+                  "value" : "http://example.org/bob"
+                },
+                "p" : {
+                  "type" : "uri",
+                  "value" : "http://xmlns.com/foaf/0.1/name"
+                },
+                "o" : {
+                  "datatype" : "http://www.w3.org/2001/XMLSchema#integer",
+                  "type" : "literal",
+                  "value" : "23"
+                }
+              }
+            },
+            "b": { 
+              "type": "uri",
+              "value": "http://example.org/certainty"
+            },
+            "c" : {
+              "datatype" : "http://www.w3.org/2001/XMLSchema#decimal",
+              "type" : "literal",
+              "value" : "0.9"
+            }
+          }
+        ]
+      }
+    }
+
 ### Middleware
 
 {Rack::SPARQL} is a superset of [Rack::LinkedData][] to allow content negotiated results
@@ -150,12 +261,12 @@ a full set of RDF formats.
       result.inspect
     end
 
-### Updating a respository
+### Updating a repository
 
     queryable = RDF::Repository.load("etc/doap.ttl")
     sse = SPARQL.parse(%(
       PREFIX doap: <http://usefulinc.com/ns/doap#>
-      INSERT DATA { <http://rubygems.org/gems/sparql> doap:implements <http://www.w3.org/TR/sparql11-update/>}
+      INSERT DATA { <https://rubygems> doap:implements <http://www.w3.org/TR/sparql11-update/>}
     ), update: true)
     sse.execute(queryable)
 
@@ -257,14 +368,14 @@ Full documentation available on [Rubydoc.info][SPARQL doc]
 
 ## Dependencies
 
-* [Ruby](http://ruby-lang.org/) (>= 2.2.2)
-* [RDF.rb](http://rubygems.org/gems/rdf) (~> 3.0)
+* [Ruby](https://ruby-lang.org/) (>= 2.2.2)
+* [RDF.rb](https://rubygems.org/gems/rdf) (~> 3.0)
 * [SPARQL::Client](https://rubygems.org/gems/sparql-client) (~> 3.0)
 * [SXP](https://rubygems.org/gems/sxp) (~> 1.0)
 * [Builder](https://rubygems.org/gems/builder) (>= 3.0.0)
 * [JSON](https://rubygems.org/gems/json) (>= 1.8.2)
 * Soft dependency on [Linked Data][] (>= 3.0)
-* Soft dependency on [Nokogiri](http://rubygems.org/gems/nokogiri) (>= 1.7)
+* Soft dependency on [Nokogiri](https://rubygems.org/gems/nokogiri) (>= 1.7)
   Falls back to REXML for XML parsing Builder for XML serializing. Nokogiri is much more efficient
 * Soft dependency on [Equivalent XML](https://rubygems.org/gems/equivalent-xml) (>= 0.3.0)
   Equivalent XML performs more efficient comparisons of XML Literals when Nokogiri is included
@@ -273,7 +384,7 @@ Full documentation available on [Rubydoc.info][SPARQL doc]
 
 ## Installation
 
-The recommended installation method is via [RubyGems](http://rubygems.org/).
+The recommended installation method is via [RubyGems](https://rubygems.org/).
 To install the latest official release of the `SPARQL` gem, do:
 
     % [sudo] gem install sparql
@@ -286,13 +397,13 @@ To get a local working copy of the development repository, do:
 
 ## Mailing List
 
-* <http://lists.w3.org/Archives/Public/public-rdf-ruby/>
+* <https://lists.w3.org/Archives/Public/public-rdf-ruby/>
 
 ## Authors
 
-* [Gregg Kellogg](http://github.com/gkellogg) - <http://greggkellogg.net/>
-* [Arto Bendiken](http://github.com/bendiken) - <http://ar.to/>
-* [Pius Uzamere](http://github.com/pius) - <http://pius.me/>
+* [Gregg Kellogg](https://github.com/gkellogg) - <https://greggkellogg.net/>
+* [Arto Bendiken](https://github.com/artob) - <https://ar.to/>
+* [Pius Uzamere](https://github.com/pius) - <https://pius.me/>
 
 ## 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.
@@ -307,54 +418,58 @@ This repository uses [Git Flow](https://github.com/nvie/gitflow) to mange develo
   list in the the `README`. Alphabetical order applies.
 * Do note that in order for us to merge any non-trivial changes (as a rule
   of thumb, additions larger than about 15 lines of code), we need an
-  explicit [public domain dedication][PDD] on record from you.
+  explicit [public domain dedication][PDD] on record from you,
+  which you will be asked to agree to on the first commit to a repo within the organization.
+  Note that the agreement applies to all repos in the [Ruby RDF](https://github.com/ruby-rdf/) organization.
 
 ## License
 
 This is free and unencumbered public domain software. For more information,
-see <http://unlicense.org/> or the accompanying {file:UNLICENSE} file.
+see <https://unlicense.org/> or the accompanying {file:UNLICENSE} file.
 
-A copy of the [SPARQL EBNF][] and derived parser files are included in the repository, which are not covered under the UNLICENSE. These files are covered via the [W3C Document License](http://www.w3.org/Consortium/Legal/2002/copyright-documents-20021231).
+A copy of the [SPARQL EBNF][] and derived parser files are included in the repository, which are not covered under the UNLICENSE. These files are covered via the [W3C Document License](https://www.w3.org/Consortium/Legal/2002/copyright-documents-20021231).
 
 A copy of the [SPARQL 1.0 tests][] and [SPARQL 1.1 tests][] are also included in the repository, which are not covered under the UNLICENSE; see the references for test copyright information.
 
-[Ruby]:             http://ruby-lang.org/
-[RDF]:              http://www.w3.org/RDF/
-[RDF::DO]:          http://rubygems.org/gems/rdf-do
-[RDF::Mongo]:       http://rubygems.org/gems/rdf-mongo
-[Rack::LinkedData]: http://rubygems.org/gems/rack-linkeddata
-[YARD]:             http://yardoc.org/
-[YARD-GS]:          http://rubydoc.info/docs/yard/file/docs/GettingStarted.md
-[PDD]:              http://lists.w3.org/Archives/Public/public-rdf-ruby/2010May/0013.html
-[SPARQL]:           http://en.wikipedia.org/wiki/SPARQL
-[SPARQL 1.0]:       http://www.w3.org/TR/sparql11-query/
-[SPARQL 1.0 tests]:http://www.w3.org/2001/sw/DataAccess/tests/
-[SPARQL 1.1 tests]: http://www.w3.org/2009/sparql/docs/tests/
-[SSE]:              http://openjena.org/wiki/SSE
-[SXP]:              http://www.rubydoc.info/github/bendiken/sxp-ruby
-[grammar]:          http://www.w3.org/TR/sparql11-query/#grammar
-[RDF 1.1]:          http://www.w3.org/TR/rdf11-concepts
-[RDF.rb]:           http://rubydoc.info/github/ruby-rdf/rdf
-[Backports]:        http://rubygems.org/gems/backports
-[Linked Data]:      http://rubygems.org/gems/linkeddata
-[SPARQL doc]:       http://rubydoc.info/github/ruby-rdf/sparql/frames
-[SPARQL XML]:       http://www.w3.org/TR/rdf-sparql-XMLres/
-[SPARQL JSON]:      http://www.w3.org/TR/rdf-sparql-json-res/
-[SPARQL EBNF]:      http://www.w3.org/TR/sparql11-query/#sparqlGrammar
-
-[SSD]:              http://www.w3.org/TR/sparql11-service-description/
-[Rack]:             http://rack.github.io
-[Sinatra]:          http://www.sinatrarb.com/
-[conneg]:           http://en.wikipedia.org/wiki/Content_negotiation
-
-[SPARQL 1.1 Query]:                             http://www.w3.org/TR/sparql11-query/
-[SPARQL 1.1 Update]:                            http://www.w3.org/TR/sparql11-update/
-[SPARQL 1.1 Service Description]:               http://www.w3.org/TR/sparql11-service-description/
-[SPARQL 1.1 Federated Query]:                   http://www.w3.org/TR/sparql11-federated-query/
-[SPARQL 1.1 Query Results JSON Format]:         http://www.w3.org/TR/sparql11-results-json/
-[SPARQL 1.1 Query Results CSV and TSV Formats]: http://www.w3.org/TR/sparql11-results-csv-tsv/
-[SPARQL Query Results XML Format]:              http://www.w3.org/TR/rdf-sparql-XMLres/
-[SPARQL 1.1 Entailment Regimes]:                http://www.w3.org/TR/sparql11-entailment/
-[SPARQL 1.1 Protocol]:                          http://www.w3.org/TR/sparql11-protocol/
-[SPARQL 1.1 Graph Store HTTP Protocol]:         http://www.w3.org/TR/sparql11-http-rdf-update/
+[Ruby]:             https://ruby-lang.org/
+[RDF]:              https://www.w3.org/RDF/
+[RDF::DO]:          https://rubygems.org/gems/rdf-do
+[RDF::Mongo]:       https://rubygems.org/gems/rdf-mongo
+[Rack::LinkedData]: https://rubygems.org/gems/rack-linkeddata
+[YARD]:             https://yardoc.org/
+[YARD-GS]:          https://rubydoc.info/docs/yard/file/docs/GettingStarted.md
+[PDD]:              https://unlicense.org/#unlicensing-contributions
+[SPARQL]:           https://en.wikipedia.org/wiki/SPARQL
+[SPARQL 1.0]:       https://www.w3.org/TR/sparql11-query/
+[SPARQL 1.0 tests]:https://www.w3.org/2001/sw/DataAccess/tests/
+[SPARQL 1.1 tests]: https://www.w3.org/2009/sparql/docs/tests/
+[SSE]:              https://jena.apache.org/documentation/notes/sse.html
+[SXP]:              https://www.rubydoc.info/github/dryruby/sxp
+[grammar]:          https://www.w3.org/TR/sparql11-query/#grammar
+[RDF 1.1]:          https://www.w3.org/TR/rdf11-concepts
+[RDF.rb]:           https://rubydoc.info/github/ruby-rdf/rdf
+[RDF*]:             https://w3c.github.io/rdf-star/rdf-star-cg-spec.html
+[SPARQL*]:          https://w3c.github.io/rdf-star/rdf-star-cg-spec.html#sparql-query-language
+[Backports]:        https://rubygems.org/gems/backports
+[Linked Data]:      https://rubygems.org/gems/linkeddata
+[SPARQL doc]:       https://rubydoc.info/github/ruby-rdf/sparql/frames
+[SPARQL XML]:       https://www.w3.org/TR/rdf-sparql-XMLres/
+[SPARQL JSON]:      https://www.w3.org/TR/rdf-sparql-json-res/
+[SPARQL EBNF]:      https://www.w3.org/TR/sparql11-query/#sparqlGrammar
+
+[SSD]:              https://www.w3.org/TR/sparql11-service-description/
+[Rack]:             https://rack.github.io
+[Sinatra]:          https://www.sinatrarb.com/
+[conneg]:           https://en.wikipedia.org/wiki/Content_negotiation
+
+[SPARQL 1.1 Query]:                             https://www.w3.org/TR/sparql11-query/
+[SPARQL 1.1 Update]:                            https://www.w3.org/TR/sparql11-update/
+[SPARQL 1.1 Service Description]:               https://www.w3.org/TR/sparql11-service-description/
+[SPARQL 1.1 Federated Query]:                   https://www.w3.org/TR/sparql11-federated-query/
+[SPARQL 1.1 Query Results JSON Format]:         https://www.w3.org/TR/sparql11-results-json/
+[SPARQL 1.1 Query Results CSV and TSV Formats]: https://www.w3.org/TR/sparql11-results-csv-tsv/
+[SPARQL Query Results XML Format]:              https://www.w3.org/TR/rdf-sparql-XMLres/
+[SPARQL 1.1 Entailment Regimes]:                https://www.w3.org/TR/sparql11-entailment/
+[SPARQL 1.1 Protocol]:                          https://www.w3.org/TR/sparql11-protocol/
+[SPARQL 1.1 Graph Store HTTP Protocol]:         https://www.w3.org/TR/sparql11-http-rdf-update/
 

data/UNLICENSE

@@ -21,4 +21,4 @@ OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 OTHER DEALINGS IN THE SOFTWARE.
 
-For more information, please refer to <http://unlicense.org/>
+For more information, please refer to <https://unlicense.org/>

data/VERSION

@@ -1 +1 @@
-3.0.1
+3.1.4

data/bin/sparql

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 require 'rubygems'
-$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", 'lib')))
+$:.unshift("../../lib", __FILE__)
 require 'sparql'
 begin
   require 'linkeddata'
@@ -9,16 +9,24 @@ rescue LoadError
 end
 require 'getoptlong'
 
-def display_results(res, options)
+def display_results(res, **options)
   puts res.inspect if options[:verbose]
   puts case res
-  when RDF::Graph   then res.dump(:ttl, base_uri: query.base_uri, prefixes: query.prefixes, standard_prefixes: true)
+  when RDF::Graph   then res.dump(options.fetch(:format, :ttl), base_uri: query.base_uri, prefixes: query.prefixes, standard_prefixes: true)
   when RDF::Literal then res.inspect
-  else                   res.map {|s| s.bindings.map {|k,v| "#{k}: #{v}"}}.join("\n")
+  else
+    case options[:format]
+    when :json then res.to_json
+    when :html  then res.to_html
+    when :xml  then res.to_xml
+    when :csv  then res.to_csv
+    when :tsv  then res.to_tsv
+    else            res.map {|s| s.bindings.map {|k,v| "#{k}: #{v}"}}.join("\n")
+    end
   end
 end
 
-def run(input, options = {})
+def run(input, **options)
   if options[:debug]
     puts "input graph:\n#{options[:dataset].dump(:trig, standard_prefixes: true)}\n" if options[:dataset]
     puts "query:\n#{input}\n"
@@ -30,17 +38,17 @@ def run(input, options = {})
   end
 
   query = if options[:sse]
-    SPARQL::Algebra.parse(input, {debug: options[:debug], update: options[:update]})
+    SPARQL::Algebra.parse(input, logger: options[:logger], update: options[:update])
   else
     # Only do grammar debugging if we're generating SSE
-    SPARQL::Grammar.parse(input, options)
+    SPARQL::Grammar.parse(input, **options)
   end
 
   puts ("\nSSE:\n" + query.to_sse) if options[:debug] || options[:to_sse]
 
   unless options[:to_sse]
-    res = query.execute(options[:dataset], debug: options[:debug])
-    display_results(res, options)
+    res = query.execute(options[:dataset], logger: options[:logger])
+    display_results(res, **options)
   end
 end
 
@@ -52,9 +60,14 @@ def server(options)
     register Sinatra::SPARQL
     set :repository, repository
 
+    before do
+      options[:logger].info "#{request.request_method} [#{request.path_info}], " +
+        params.merge(Accept: request.accept.map(&:to_s)).map {|k,v| "#{k}=#{v}" unless k.to_s == "content"}.join(" ")
+    end
+
     get '/' do
       if params["query"]
-        query = params["query"].to_s.match(/^http:/) ? RDF::Util::File.open_file(params["query"]) : ::URI.decode(params["query"].to_s)
+        query = params["query"].to_s.match(/^http:/) ? RDF::Util::File.open_file(params["query"]) : ::CGI.unescape(params["query"].to_s)
         SPARQL.execute(query, settings.repository)
       else
         settings.sparql_options.replace(standard_prefixes: true)
@@ -70,23 +83,23 @@ def server(options)
       SPARQL.execute(params['query'], settings.repository)
     end
   end
-  Rack::Server.start(app: app)
+  Rack::Server.start(app: app, Port: options.fetch(:port, 9292))
 rescue LoadError
   $stderr.puts "Running SPARQL server requires Rack to be in environment: #{$!.message}"
 end
 
 def usage
-  puts "Usage: #{$0} execute [options] query-file         Execute a query against the specified dataset"
-  puts "       #{$0} parse [options] query-file           Parse a query into SPARQL S-Expressions (SSE)"
-  puts "       #{$0} query [options] end-point query-file Run the query against a remote end-point"
-  puts "       #{$0} server [options] dataset-file        Start a server initialized from the specified dataset"
+  puts "Usage: #{File.basename($0)} execute [options] query-file         Execute a query against the specified dataset"
+  puts "       #{File.basename($0)} parse [options] query-file           Parse a query into SPARQL S-Expressions (SSE)"
+  puts "       #{File.basename($0)} query [options] end-point query-file Run the query against a remote end-point"
+  puts "       #{File.basename($0)} server [options] dataset-file        Start a server initialized from the specified dataset"
   puts "Options:"
-  puts "      --execute,-e:         Use option argument as the SPARQL input if no query-file given"
   puts "      --dataset:            File containing RDF graph or dataset"
   puts "      --debug:              Display detailed debug output"
+  puts "      --execute,-e:         Use option argument as the SPARQL input if no query-file given"
+  puts "      --format:             Output format for results"
   puts "      --port,-p             Port on which to run server; defaults to 9292"
   puts "      --sse:                Query input is in SSE format"
-  puts "      --debug:              Display detailed debug output"
   puts "      --update:             Process query as a SPARQL Update"
   puts "      --verbose:            Display details of processing"
   puts "      --help,-?:            This message"
@@ -98,27 +111,34 @@ cmd, input = ARGV.shift, nil
 opts = GetoptLong.new(
   ["--dataset", GetoptLong::REQUIRED_ARGUMENT],
   ["--debug", GetoptLong::NO_ARGUMENT],
+  ["--execute", "-e", GetoptLong::REQUIRED_ARGUMENT],
+  ["--format", GetoptLong::REQUIRED_ARGUMENT],
   ["--port", "-p", GetoptLong::REQUIRED_ARGUMENT],
-  ["--verbose", GetoptLong::NO_ARGUMENT],
   ["--sse", GetoptLong::NO_ARGUMENT],
   ["--update", GetoptLong::NO_ARGUMENT],
-  ["--execute", "-e", GetoptLong::REQUIRED_ARGUMENT],
+  ["--verbose", GetoptLong::NO_ARGUMENT],
   ["--help", "-?", GetoptLong::NO_ARGUMENT]
 )
 
+logger = Logger.new(STDERR)
+logger.level = Logger::WARN
+logger.formatter = lambda {|severity, datetime, progname, msg| "%5s %s\n" % [severity, msg]}
+
 options = {
   dataset: RDF::Repository.new,
+  logger: logger,
 }
 
 opts.each do |opt, arg|
   case opt
-  when '--dataset'       then options[:dataset].load(arg)
+  when '--dataset'       then options[:dataset].load(arg, rdfstar: true)
+  when '--debug'         then options[:debug] = true ; logger.level = Logger::DEBUG
   when '--execute'       then input = arg
+  when '--format'        then options[:format] = arg.to_sym
   when '--port'          then options[:port] = arg.to_i
   when '--sse'           then options[:sse] = true
-  when '--debug'         then options[:debug] = true
   when '--update'        then options[:update] = true
-  when '--verbose'       then options[:verbose] = true
+  when '--verbose'       then options[:verbose] = true ; logger.level = Logger::INFO
   when "--help"          then usage
   end
 end
@@ -132,7 +152,7 @@ case cmd
 when 'execute', 'parse'
   options[:to_sse] = true if cmd == 'parse'
   input ||= ARGV.empty? ? $stdin.read : RDF::Util::File.open_file(ARGV.first).read
-  run(input, options)
+  run(input, **options)
 when 'query'
   endpoint = ARGV.shift
   unless endpoint
@@ -142,7 +162,7 @@ when 'query'
   input ||= ARGV.empty? ? $stdin.read : RDF::Util::File.open_file(ARGV.first).read
   SPARQL::Client.new(endpoint) do |client|
     res = client.query(input)
-    display_results(res, options)
+    display_results(res, **options)
   end
 when 'server'
   if data_file = ARGV.shift