sparql 3.1.8 → 3.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0fc6d6745c325bd23d83fe640eb238a22406b567cf06223703afd90ea5733be1
-  data.tar.gz: 056cde1c14633aa791f492be673eb023bab95d7af4e5b19fb94c99540fc22908
+  metadata.gz: 853c52b99bab0b9455b25a81c8c946e5bcb1429dddadf010b66315f1dbafda51
+  data.tar.gz: 90d89877c031476efdaa1d0b119b2a2404925186b4e0b3de99818d75ead76bff
 SHA512:
-  metadata.gz: 32187664d7d06bd49cffa8354987ce3f11ba44b35960a92ac80353a538a15489b342f1d3e66a0ad792971489e83cc57ab05b936e93f8e04fe2f5df4a527d3d39
-  data.tar.gz: 9d8a75fd40c9ccbac6a9753d9b7a04b9e26a4504a55636d61d3d34c1d4dde77c6838d5ac45828a40d06b7c4658971c1f435da0c6812e7b2eda4aa5dfcfaa9cda
+  metadata.gz: 98816c81664147aa0fa4ccd90ed14461eb51b652b011395f38f044934c2ff335197fbc3d2d7f447771a5b1e46fa24042aef45fd1f95356b91f52bafee48d1a72
+  data.tar.gz: 5545d7ddd245d73382229ed6f9996b24bd66a4285ee18d6295f697202ad5901eb4221cbf2533ef1539b98ccc0c095519e531b541db3e1c4757d813ab888cb9fd

data/README.md

@@ -1,6 +1,6 @@
-# SPARQL for RDF.rb
+# SPARQL Query and Update library for Ruby
 
-This is a [Ruby][] implementation of [SPARQL][] for [RDF.rb][].
+An implementation of [SPARQL][] for [RDF.rb][].
 
 [![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)
@@ -17,24 +17,26 @@ This is a [Ruby][] implementation of [SPARQL][] for [RDF.rb][].
   or HTML.
 * SPARQL CONSTRUCT or DESCRIBE serialized based on Format, Extension of Mime Type
   using available RDF Writers (see [Linked Data][])
-* SPARQL Client for accessing remote SPARQL endpoints.
-* SPARQL Update
+* SPARQL Client for accessing remote SPARQL endpoints (via [sparql-client](https://github.com/ruby-rdf/sparql-client)).
+* [SPARQL 1.1 Protocol][] (via {SPARQL::Server}).
+* [SPARQL 1.1 Update][]
 * [Rack][] and [Sinatra][] middleware to perform [HTTP content negotiation][conneg] for result formats
   * Compatible with any [Rack][] or [Sinatra][] application and any Rack-based framework.
   * Helper method for describing [SPARQL Service Description][SSD]
+  * Helper method for setting up datasets as part of the [SPARQL 1.1 Protocol][].
 * Implementation Report: {file:etc/earl.html EARL}
-* Compatible with Ruby >= 2.2.2.
-* Compatible with older Ruby versions with the help of the [Backports][] gem.
+* Compatible with Ruby >= 2.6.
 * Supports Unicode query strings both on all versions of Ruby.
 * Provisional support for [SPARQL-star][].
 
 ## Description
 
-The {SPARQL} gem implements [SPARQL 1.1 Query][], and [SPARQL 1.1 Update][], and provides [Rack][] and [Sinatra][] middleware to provide results using [HTTP Content Negotiation][conneg].
+The {SPARQL} gem implements [SPARQL 1.1 Query][], and [SPARQL 1.1 Update][], and provides [Rack][] and [Sinatra][] middleware to provide results using [HTTP Content Negotiation][conneg] and to support [SPARQL 1.1 Protocol][].
 
 * {SPARQL::Grammar} implements a [SPARQL 1.1 Query][] and [SPARQL 1.1 Update][] parser generating [SPARQL S-Expressions (SSE)][SSE].
 * {SPARQL::Algebra} executes SSE against Any `RDF::Graph` or `RDF::Repository`, including compliant [RDF.rb][] repository adaptors such as [RDF::DO][] and [RDF::Mongo][].
 * {Rack::SPARQL} and {Sinatra::SPARQL} provide middleware components to format results using an appropriate format based on [HTTP content negotiation][conneg].
+* {SPARQL::Server} implements the [SPARQL 1.1 Protocol][] using {Sinatra::SPARQL}.
 
 ### [SPARQL 1.1 Query][] Extensions and Limitations
 The {SPARQL} gem uses the [SPARQL 1.1 Query][] {file:etc/sparql11.html EBNF grammar}, which provides much more capability than [SPARQL 1.0][], but has a few limitations:
@@ -63,17 +65,22 @@ The gem also includes the following [SPARQL 1.1 Update][] operations:
 Not supported:
 
 * [Federated Query][SPARQL 1.1 Federated Query],
-* [Entailment Regimes][SPARQL 1.1 Entailment Regimes],
-* [Protocol][SPARQL 1.1 Protocol], and
-* [Graph Store HTTP Protocol][SPARQL 1.1 Graph Store HTTP Protocol]
-
-either in this, or related gems.
+* [Entailment Regimes][SPARQL 1.1 Entailment Regimes], and
+* [Graph Store HTTP Protocol][SPARQL 1.1 Graph Store HTTP Protocol] but the closely related [Linked Data Platform][] implemented in [rdf-ldp](https://github.com/ruby-rdf/rdf-ldp) supports these use cases.
 
 ### 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](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 1.2
+The gem supports some of the extensions proposed by the [SPARQL 1.2 Community Group](https://github.com/w3c/sparql-12). In particular, the following extensions are now implemented:
+
+* [SEP-0002: better support for Durations, Dates, and Times](https://github.com/w3c/sparql-12/blob/main/SEP/SEP-0002/sep-0002.md)
+  * This includes full support for `xsd:date`, `xsd:time`, `xsd:duration`, `xsd:dayTimeDuration`, and `xsd:yearMonthDuration` along with associated XPath/XQuery functions including a new `ADJUST` builtin. (**Note: This feature is subject to change or elimination as the standards process progresses.**)
+* [SEP-0003: Property paths with a min/max hop](https://github.com/w3c/sparql-12/blob/main/SEP/SEP-0003/sep-0003.md)
+  * This includes support for non-counting path forms such as `rdf:rest{1,3}` to match the union of paths `rdf:rest`, `rdf:rest/rdf:rest`, and `rdf:rest/rdf:rest/rdf:rest`.  (**Note: This feature is subject to change or elimination as the standards process progresses.**)
+
 ### SPARQL Extension Functions
 Extension functions may be defined, which will be invoked during query evaluation. For example:
 
@@ -96,6 +103,10 @@ Then, use the function in a query:
 
 See {SPARQL::Algebra::Expression.register_extension} for details.
 
+### Variable Pre-binding
+
+A call to execute a parsed query can include pre-bound variables, which cause queries to be executed with matching variables bound as defined. Variable pre-binding can be done using a Hash structure, or a Query Solution.  See [Query with Binding example](#query-with-binding) and {SPARQL::Algebra::Query#execute}.
+
 ### SPARQLStar (SPARQL-star)
 
 The gem supports [SPARQL-star][] where patterns may include sub-patterns recursively, for a kind of Reification.
@@ -163,44 +174,31 @@ Note that results can be serialized only when the format supports [RDF-star][].
 
 #### SPARQL results
 
-The SPARQL results formats are extended to serialize embedded triples as described for [RDF4J](https://rdf4j.org/documentation/programming/rdfstar/):
+The SPARQL results formats are extended to serialize quoted triples as described for [RDF4J](https://rdf4j.org/documentation/programming/rdfstar/):
 
     {
       "head" : {
-        "vars" : [
-          "a",
-          "b",
-          "c"
-        ]
+        "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"
-                },
+                "s" : {"value" : "http://example.org/bob", "type": "uri"},
+                "p" : {"value" : "http://xmlns.com/foaf/0.1/name", "type": "uri"},
                 "o" : {
-                  "datatype" : "http://www.w3.org/2001/XMLSchema#integer",
+                  "value" : "23",
                   "type" : "literal",
-                  "value" : "23"
+                  "datatype" : "http://www.w3.org/2001/XMLSchema#integer"
                 }
               }
             },
-            "b": { 
-              "type": "uri",
-              "value": "http://example.org/certainty"
-            },
+            "b": {"value": "http://example.org/certainty", "type": "uri"},
             "c" : {
-              "datatype" : "http://www.w3.org/2001/XMLSchema#decimal",
+              "value" : "0.9",
               "type" : "literal",
-              "value" : "0.9"
+              "datatype" : "http://www.w3.org/2001/XMLSchema#decimal"
             }
           }
         ]
@@ -215,17 +213,23 @@ You would typically return an instance of `RDF::Graph`, `RDF::Repository` or an
 from your Rack application, and let the `Rack::SPARQL::ContentNegotiation` middleware
 take care of serializing your response into whatever format the HTTP
 client requested and understands.
+Content negotiation also transforms `application/x-www-form-urlencoded` to either `application/sparql-query`
+or `application/sparql-update` as appropriate for [SPARQL 1.1 Protocol][].
 
 {Sinatra::SPARQL} is a thin Sinatra-specific wrapper around the
 {Rack::SPARQL} middleware, which implements SPARQL
  content negotiation for Rack applications. {Sinatra::SPARQL} also supports
- [SPARQL 1.1 Service Description][].
+ [SPARQL 1.1 Service Description][] (via {Sinatra::SPARQL::Helpers.service_description} and protocol-based dataset mangement via {Sinatra::SPARQL::Helpers.dataset} for `default-graph-uri` and `named-graph-uri` The `using-graph-uri` and `using-named-graph-uri` query parameters are managed through {SPARQL::Algebra::Operator::Modify#execute}.
 
 The middleware queries [RDF.rb][] for the MIME content types of known RDF
 serialization formats, so it will work with whatever serialization extensions
 that are currently available for RDF.rb. (At present, this includes support
 for N-Triples, N-Quads, Turtle, RDF/XML, RDF/JSON, JSON-LD, RDFa, TriG and TriX.)
 
+### Server
+
+A simple [Sinatra][]-based server is implemented in {SPARQL::Server.application} using {Rack::SPARQL} and {Sinatra::SPARQL} completes the implementation of [SPARQL 1.1 Protocol][] and can be used to compose a server including other capabilities.
+
 ### Remote datasets
 
 A SPARQL query containing `FROM` or `FROM NAMED` (also `UPDATE` or `UPDATE NAMED`) will load the referenced IRI unless the repository already contains a graph with that same IRI. This is performed using [RDF.rb][] `RDF::Util::File.open_file` passing HTTP Accept headers for various available RDF formats. For best results, require [Linked Data][] to enable a full set of RDF formats in the `GET` request. Also, consider overriding `RDF::Util::File.open_file` with an implementation with support for HTTP Get headers (such as `Net::HTTP`).
@@ -248,27 +252,27 @@ a full set of RDF formats.
 ### Querying a repository with a SPARQL query
 
     queryable = RDF::Repository.load("etc/doap.ttl")
-    sse = SPARQL.parse("SELECT * WHERE { ?s ?p ?o }")
-    queryable.query(sse) do |result|
+    query = SPARQL.parse("SELECT * WHERE { ?s ?p ?o }")
+    queryable.query(query) do |result|
       result.inspect
     end
 
 ### Executing a SPARQL query against a repository
 
     queryable = RDF::Repository.load("etc/doap.ttl")
-    sse = SPARQL.parse("SELECT * WHERE { ?s ?p ?o }")
-    sse.execute(queryable) do |result|
+    query = SPARQL.parse("SELECT * WHERE { ?s ?p ?o }")
+    query.execute(queryable) do |result|
       result.inspect
     end
 
 ### Updating a repository
 
     queryable = RDF::Repository.load("etc/doap.ttl")
-    sse = SPARQL.parse(%(
+    update = SPARQL.parse(%(
       PREFIX doap: <http://usefulinc.com/ns/doap#>
       INSERT DATA { <https://rubygems> doap:implements <http://www.w3.org/TR/sparql11-update/>}
     ), update: true)
-    sse.execute(queryable)
+    update.execute(queryable)
 
 ### Rendering solutions as JSON, XML, CSV, TSV or HTML
     queryable = RDF::Repository.load("etc/doap.ttl")
@@ -277,8 +281,29 @@ a full set of RDF formats.
 
 ### Parsing a SPARQL query string to SSE
 
-    sse = SPARQL.parse("SELECT * WHERE { ?s ?p ?o }")
-    sse.to_sxp #=> (bgp (triple ?s ?p ?o))
+    query = SPARQL.parse("SELECT * WHERE { ?s ?p ?o }")
+    query.to_sxp #=> (bgp (triple ?s ?p ?o))
+
+### Parsing a SSE to SPARQL query or update string to SPARQL
+
+    # Note: if the SSE uses extension functions, they either must be XSD casting functions, or custom functions which are registered extensions. (See [SPARQL Extension Functions](#sparql-extension-functions))
+
+    query = SPARQL::Algebra.parse(%{(bgp (triple ?s ?p ?o))})
+    sparql = query.to_sparql #=> "SELECT * WHERE { ?s ?p ?o }"
+
+### Query with Binding
+
+    bindings = {page: RDF::URI("https://greggkellogg.net/")}
+    queryable = RDF::Repository.load("etc/doap.ttl")
+    query = SPARQL.parse(%(
+      PREFIX foaf: <http://xmlns.com/foaf/0.1/>
+      SELECT ?person
+      WHERE {
+        ?person foaf:homepage ?page .
+      }
+    ))
+    solutions = query.execute(queryable, bindings: bindings)
+    solutions.to_sxp #=> (((person <https://greggkellogg.net/foaf#me>)))
 
 ### Command line processing
 
@@ -289,6 +314,10 @@ a full set of RDF formats.
     sparql parse etc/input.rq
     sparql parse -e "SELECT * WHERE { ?s ?p ?o }"
 
+    # Generate SPARQL Query from SSE
+    sparql parse --sse etc/input.sse --format sparql
+    sparql parse --sse --format sparql -e "(dataset (<http://usefulinc.com/ns/doap>) (bgp (triple ?s ?p ?o))))"
+
     # Run query using SSE input
     sparql execute --dataset etc/doap.ttl --sse etc/input.sse
     sparql execute --sse -e "(dataset (<etc/doap.ttl>) (bgp (triple ?s ?p ?o))))"
@@ -368,19 +397,19 @@ Full documentation available on [Rubydoc.info][SPARQL doc]
 
 ## Dependencies
 
-* [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](https://rubygems.org/gems/nokogiri) (>= 1.7)
+* [Ruby](https://ruby-lang.org/) (>= 2.6)
+* [RDF.rb](https://rubygems.org/gems/rdf) (~> 3.2)
+* [SPARQL::Client](https://rubygems.org/gems/sparql-client) (~> 3.1)
+* [SXP](https://rubygems.org/gems/sxp) (~> 1.2)
+* [Builder](https://rubygems.org/gems/builder) (~> 3.2)
+* [JSON](https://rubygems.org/gems/json) (~> 2.6)
+* Soft dependency on [Linked Data][] (>= 3.1)
+* Soft dependency on [Nokogiri](https://rubygems.org/gems/nokogiri) (~> 1.12)
   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)
+* Soft dependency on [Equivalent XML](https://rubygems.org/gems/equivalent-xml) (>= 0.6)
   Equivalent XML performs more efficient comparisons of XML Literals when Nokogiri is included
-* Soft dependency on [Rack][] (>= 2.0)
-* Soft dependency on [Sinatra][] (>= 2.0)
+* Soft dependency on [Rack][] (~> 2.2)
+* Soft dependency on [Sinatra][] (~> 2.1)
 
 ## Installation
 
@@ -425,7 +454,7 @@ This repository uses [Git Flow](https://github.com/nvie/gitflow) to mange develo
 ## License
 
 This is free and unencumbered public domain software. For more information,
-see <https://unlicense.org/> or the accompanying {file:UNLICENSE} file.
+see <https://unlicense.org/> or the accompanying {file:UNLICENSE}.
 
 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).
 
@@ -444,15 +473,14 @@ A copy of the [SPARQL 1.0 tests][] and [SPARQL 1.1 tests][] are also included in
 [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
+[SXP]:              https://dryruby.github.io/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.rb]:           https://ruby-rdf.github.io/rdf
 [RDF-star]:             https://w3c.github.io/rdf-star/rdf-star-cg-spec.html
 [SPARQL-star]:          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 doc]:       https://ruby-rdf.github.io/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
@@ -472,4 +500,4 @@ A copy of the [SPARQL 1.0 tests][] and [SPARQL 1.1 tests][] are also included in
 [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/
-
+[Linked Data Platform]: https://www.w3.org/TR/ldp/

data/VERSION

@@ -1 +1 @@
-3.1.8
+3.2.3

data/bin/sparql

@@ -45,48 +45,28 @@ def run(input, **options)
     SPARQL::Grammar.parse(input, **options)
   end
 
-  puts ("\nSSE:\n" + query.to_sse) if options[:debug] || options[:to_sse]
+  puts ("\nSSE:\n" + query.to_sse) if options[:debug]
 
-  unless options[:to_sse]
+  if options[:parse_only]
+    case options[:format]
+    when :sparql
+      puts ("\nSPARQL:\n" + query.to_sparql)
+    when nil, :sse
+      puts ("\nSSE:\n" + query.to_sse)
+    else
+      $stderr.puts "Unknown output format for parsing: #{options[:format]}. Use 'sse' or 'sparql'"
+    end
+  else
     res = query.execute(options[:dataset], logger: options[:logger])
     display_results(res, **options)
   end
 end
 
 def server(options)
-  require 'sinatra/sparql'
-  repository = options.fetch(:dataset, RDF::Repository.new)
-
-  app = Sinatra.new do
-    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"]) : ::CGI.unescape(params["query"].to_s)
-        SPARQL.execute(query, settings.repository)
-      else
-        settings.sparql_options.replace(standard_prefixes: true)
-        settings.sparql_options.merge!(:prefixes => {
-          ssd: "http://www.w3.org/ns/sparql-service-description#",
-          void: "http://rdfs.org/ns/void#"
-        })
-        service_description(repo: settings.repository, endpoint: url)
-      end
-    end
-
-    post '/' do
-      SPARQL.execute(params['query'], settings.repository)
-    end
-  end
+  app = SPARQL::Server.application(**options)
   Rack::Server.start(app: app, Port: options.fetch(:port, 9292))
 rescue LoadError
-  $stderr.puts "Running SPARQL server requires Rack to be in environment: #{$!.message}"
+  $stderr.puts "Running SPARQL server requires Rack and Sinatra to be in environment: #{$!.message}"
 end
 
 def usage
@@ -98,7 +78,7 @@ def usage
   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 "      --format:             Output format for results (json, xml, csv, tsv, html, sparql, sse, or another RDF format)"
   puts "      --port,-p             Port on which to run server; defaults to 9292"
   puts "      --sse:                Query input is in SSE format"
   puts "      --update:             Process query as a SPARQL Update"
@@ -151,7 +131,7 @@ end
 
 case cmd
 when 'execute', 'parse'
-  options[:to_sse] = true if cmd == 'parse'
+  options[:parse_only] = true if cmd == 'parse'
   input ||= ARGV.empty? ? $stdin.read : RDF::Util::File.open_file(ARGV.first).read
   run(input, **options)
 when 'query'

data/lib/rack/sparql/conneg.rb

@@ -39,15 +39,36 @@ module Rack; module SPARQL
     # If result is `RDF::Literal::Boolean`, `RDF::Query::Results`, or `RDF::Enumerable`
     # The result is serialized using {SPARQL::Results}
     #
-    # Inserts ordered content types into the environment as `ORDERED_CONTENT_TYPES` if an Accept header is present
+    # Inserts ordered content types into the environment as `ORDERED_CONTENT_TYPES` if an Accept header is present.
+    #
+    # Normalizes `application/x-www-form-urlencoded` to either `application/sparql-query` or `application/sparql-update` forms.
     #
     # @param  [Hash{String => String}] env
     # @return [Array(Integer, Hash, #each)]
     # @see    https://www.rubydoc.info/github/rack/rack/Rack/Runtime#call-instance_method
     def call(env)
       env['ORDERED_CONTENT_TYPES'] = parse_accept_header(env['HTTP_ACCEPT']) if env.has_key?('HTTP_ACCEPT')
+      # Normalize application/x-www-form-urlencoded to application/sparql-query or application/sparql-update
+      if env['REQUEST_METHOD'] == 'POST' && env.fetch('CONTENT_TYPE', 'application/x-www-form-urlencoded').to_s.start_with?('application/x-www-form-urlencoded')
+        content = env['rack.input'].read
+        params = Rack::Utils.parse_query(content)
+        if query = params.delete('query')
+          return [406, {"Content-Type" => "text/plain"}, ["Multiple query parameters"]] unless query.is_a?(String)
+          env['rack.input'] = StringIO.new(query)
+          env['CONTENT_TYPE'] = 'application/sparql-query'
+          env['QUERY_STRING'] = Rack::Utils.build_query(params)
+        elsif update = params.delete('update')
+          return [406, {"Content-Type" => "text/plain"}, ["Multiple update parameters"]] unless update.is_a?(String)
+          env['rack.input'] = StringIO.new(update)
+          env['CONTENT_TYPE'] = 'application/sparql-update'
+          env['QUERY_STRING'] = Rack::Utils.build_query(params)
+        else
+          env['rack.input'].rewind # never mind
+        end
+      end
       response = app.call(env)
       body = response[2].respond_to?(:body) ? response[2].body : response[2]
+      body = body.first if body.is_a?(Array) && body.length == 1 && body.first.is_a?(RDF::Literal::Boolean)
       case body
       when RDF::Enumerable, RDF::Query::Solutions, RDF::Literal::Boolean
         response[2] = body  # Put it back in the response, it might have been a proxy

data/lib/sinatra/sparql/extensions.rb

@@ -11,7 +11,7 @@ class Sinatra::Response
 
     # Rack::Response#finish sometimes returns self as response body. We don't want that.
     status, headers, result = super
-    result = body if result == self
+    result = body if self == result
     [status, headers, result]
   end
 end

data/lib/sinatra/sparql.rb

@@ -1,6 +1,7 @@
 require 'sinatra/base'
 require 'sinatra/sparql/extensions'
 require 'rack/sparql'
+require 'rdf/aggregate_repo'
 
 module Sinatra
   ##
@@ -13,6 +14,7 @@ module Sinatra
     ##
     # Helper methods.
     module Helpers
+
       ##
       # This is useful when a GET request is performed against a SPARQL endpoint and no query is performed. Provide a set of datasets, including a default dataset along with optional triple count, dump location, and description of the dataset.
       #
@@ -36,23 +38,36 @@ module Sinatra
       
         node = RDF::Node.new
         g << [node, RDF.type, sd.join("#Service")]
-        g << [node, sd.join("#endpoint"), options[:endpoint] || url("/sparql")]
+        g << [node, sd.join("#endpoint"), RDF::URI(url(options.fetch(:endpoint, "/sparql")))]
+        g << [node, sd.join("#supportedLanguage"), sd.join("#SPARQL10Query")]
         g << [node, sd.join("#supportedLanguage"), sd.join("#SPARQL11Query")]
+        g << [node, sd.join("#supportedLanguage"), sd.join("#SPARQL11Update")]
+        g << [node, sd.join("#supportedLanguage"), RDF::URI('http://www.w3.org/ns/rdf-star#SPARQLStarQuery')]
+        g << [node, sd.join("#supportedLanguage"), RDF::URI('http://www.w3.org/ns/rdf-star#SPARQLStarUpdate')]
       
+        # Input formats
+        RDF::Reader.map(&:format).select(&:to_uri).each do |format|
+          g << [node, sd.join("#inputFormat"), format.to_uri]
+        end
+
         # Result formats, both RDF and SPARQL Results.
-        # FIXME: We should get this from the avaliable serializers
-        g << [node, sd.join("#resultFormat"), RDF::URI("http://www.w3.org/ns/formats/RDF_XML")]
-        g << [node, sd.join("#resultFormat"), RDF::URI("http://www.w3.org/ns/formats/Turtle")]
-        g << [node, sd.join("#resultFormat"), RDF::URI("http://www.w3.org/ns/formats/RDFa")]
-        g << [node, sd.join("#resultFormat"), RDF::URI("http://www.w3.org/ns/formats/N-Triples")]
-        g << [node, sd.join("#resultFormat"), RDF::URI("http://www.w3.org/ns/formats/SPARQL_Results_XML")]
-        g << [node, sd.join("#resultFormat"), RDF::URI("http://www.w3.org/ns/formats/SPARQL_Results_JSON")]
-        g << [node, sd.join("#resultFormat"), RDF::URI("http://www.w3.org/ns/formats/SPARQL_Results_CSV")]
-        g << [node, sd.join("#resultFormat"), RDF::URI("http://www.w3.org/ns/formats/SPARQL_Results_TSV")]
-      
+        %w(
+          http://www.w3.org/ns/formats/SPARQL_Results_XML
+          http://www.w3.org/ns/formats/SPARQL_Results_JSON
+          http://www.w3.org/ns/formats/SPARQL_Results_CSV
+          http://www.w3.org/ns/formats/SPARQL_Results_TSV
+        ).each do |uri|
+          g << [node, sd.join("#resultFormat"), uri]
+        end
+
+        RDF::Writer.map(&:format).select(&:to_uri).each do |format|
+          g << [node, sd.join("#resultFormat"), format.to_uri]
+        end
+
         # Features
         g << [node, sd.join("#feature"), sd.join("#DereferencesURIs")]
-      
+        #g << [node, sd.join("#feature"), sd.join("#BasicFederatedQuery")]
+
         # Datasets
         ds = RDF::Node.new
         g << [node, sd.join("#defaultDataset"), ds]
@@ -86,6 +101,36 @@ module Sinatra
         end
         g
       end
+
+      ##
+      # This either creates a merge repo, or uses the standard repository for performing the query, based on the parameters passed (`default-graph-uri` and `named-graph-uri`).
+      # Loads from the datasource, unless a graph named by
+      # the datasource URI already exists in the repository.
+      #
+      # @return [RDF::Dataset]
+      # @see Algebra::Operator::Dataset
+      def dataset(**options)
+        logger = options.fetch(:logger, ::Logger.new(false))
+        repo = settings.repository
+        if %i(default-graph-uri named-graph-uri).any? {|k| options.key?(k)}        
+          default_datasets = Array(options[:"default-graph-uri"]).map {|u| RDF::URI(u)}
+          named_datasets = Array(options[:"named-graph-uri"]).map {|u| RDF::URI(u)}
+
+          (default_datasets + named_datasets).each do |uri|
+            load_opts = {logger: logger, graph_name: uri, base_uri: uri}
+            unless repo.has_graph?(uri)
+              logger.debug(options) {"=> load #{uri}"}
+              repo.load(uri.to_s, **load_opts)
+            end
+          end
+
+          # Create an aggregate based on queryable having just the bits we want
+          aggregate = RDF::AggregateRepo.new(repo)
+          named_datasets.each {|name| aggregate.named(name) if repo.has_graph?(name)}
+          aggregate.default(*default_datasets.select {|name| repo.has_graph?(name)})
+          aggregate
+        end || settings.repository
+      end
     end
 
     ##