sparql 0.0.2 → 0.1.0

data/README.markdown

@@ -1,20 +1,67 @@
 # SPARQL for RDF.rb
 
-This is a [Ruby][] implementation of the [SPARQL][] algebra for [RDF.rb][].
+This is a [Ruby][] implementation of [SPARQL][] for [RDF.rb][].
 
 ## Features
 
 * 100% free and unencumbered [public domain](http://unlicense.org/) software.
 * [SPARQL 1.0][] query parsing and execution
-* SPARQL results as [XML][SPARQL XML] or [JSON][SPARQL JSON].
+* SPARQL results as [XML][SPARQL XML], [JSON][SPARQL JSON] or HTML.
 * SPARQL CONSTRUCT or DESCRIBE serialized based on Format, Extension of Mime Type
-  using available RDF Writers (see [Linked Data](http://rubygems.org/gems/linkeddata))
+  using available RDF Writers (see [Linked Data][])
 * SPARQL Client for accessing remote SPARQL endpoints.
-* Helper method for describing [SPARQL Service Description][]
-* Compatible with Ruby Ruby 1.9.x.
+* [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]
+* Compatible with Ruby 1.9.x.
 * Compatible with older Ruby versions with the help of the [Backports][] gem.
 * Supports Unicode query strings both on Ruby 1.8.x and 1.9.x.
 
+## Description
+
+The {SPARQL} gem implements [SPARQL 1.0 Query] and provides [Rack][] and [Sinatra][]
+middleware to provide results using [HTTP Content Negotiation][conneg].
+
+* {SPARQL::Grammar} implements a [SPARQL 1.0 Query] 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].
+
+### Middleware
+
+`Rack::SPARQL` is a superset of [Rack::LinkedData][] to allow content negotiated results
+to be returned any `RDF::Enumerable` or `RDF::Query::Solutions` compatible results.
+You would typically return an instance of `RDF::Graph`, `RDF::Repository` or `RDF::Query::Solutions`
+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.
+
+`Sinatra::SPARQL` is a thin Sinatra-specific wrapper around the
+{Rack::SPARQL} middleware, which implements SPARQL
+ content negotiation for Rack applications.
+
+The middleware queries [RDF.rb][] for the MIME content types of known RDF
+serialization formats, so it will work with whatever serialization plugins
+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.)
+
+### Remote datasets
+
+A SPARQL query containing `FROM` or `FROM NAMED` will load the referenced IRI unless the repository
+already contains a context 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`).
+
+### Result formats
+
+{SPARQL.serialize_results} may be used on it's own, or in conjunction with {Rack::SPARQL} or {Sinatra::SPARQL}
+to provide content-negotiated query results. For basic `SELECT` and `ASK` this includes HTML, XML and JSON formats.
+`DESCRIBE` and `CONSTRUCT` create an `RDF::Graph`, which can be serialized through [HTTP Content Netogiation][conneg]
+using available RDF writers. For best results, require [Linked Data][] to enable
+a full set of RDF formats.
+
 ## Examples
 
     require 'rubygems'
@@ -49,6 +96,42 @@ This is a [Ruby][] implementation of the [SPARQL][] algebra for [RDF.rb][].
     sparql --default-graph etc/doap.ttl --sse etc/input.sse
     sparql --sse -e "(dataset (<etc/doap.ttl>) (bgp (triple ?s ?p ?o))))"
 
+### Adding SPARQL content negotiation to a Rails 3.x application
+
+    # config/application.rb
+    require 'rack/sparql'
+    
+    class Application < Rails::Application
+      config.middleware.use Rack::SPARQL::ContentNegotiation
+    end
+
+### Adding SPARQL content negotiation to a Rackup application
+
+    #!/usr/bin/env rackup
+    require 'rack/sparql'
+    
+    repository = RDF::Repository.new do |graph|
+      graph << [RDF::Node.new, RDF::DC.title, "Hello, world!"]
+    end
+    results = SPARQL.execute("SELECT * WHERE { ?s ?p ?o }", repository)
+    
+    use Rack::SPARQL::ContentNegotiation
+    run lambda { |env| [200, {}, results] }
+
+### Adding SPARQL content negotiation to a classic Sinatra application
+
+    #!/usr/bin/env ruby -rubygems
+    require 'sinatra'
+    require 'sinatra/sparql'
+    
+    repository = RDF::Repository.new do |graph|
+      graph << [RDF::Node.new, RDF::DC.title, "Hello, world!"]
+    end
+
+    get '/sparql' do
+      SPARQL.execute("SELECT * WHERE { ?s ?p ?o }", repository)
+    end
+
 ## Documentation
 
 Full documentation available on [Rubydoc.info][SPARQL doc]
@@ -63,15 +146,19 @@ Full documentation available on [Rubydoc.info][SPARQL doc]
   * {SPARQL::Grammar}
     * {SPARQL::Grammar::Parser}
     * {SPARQL::Grammar::Lexer}
+* {Sinatra::SPARQL}
+* {Rack::SPARQL}
+  * {Rack::SPARQL::ContentNegotiation}
 
 ## Dependencies
 
 * [Ruby](http://ruby-lang.org/) (>= 1.9) or (>= 1.8.1 with [Backports][])
-* [RDF.rb](http://rubygems.org/gems/rdf) (>= 0.3.4)
+* [RDF.rb](http://rubygems.org/gems/rdf) (>= 0.3.5)
 * [SPARQL::Client](https://rubygems.org/gems/sparql-client) (>= 0.0.11)
 * [SXP](https://rubygems.org/gems/sxp) (>= 0.0.15)
 * [Builder](https://rubygems.org/gems/builder) (>= 3.0.0)
 * [JSON](https://rubygems.org/gems/json) (>= 1.5.1)
+* Soft dependency on [Linked Data][]
 
 ## Installation
 
@@ -117,6 +204,9 @@ see <http://unlicense.org/> or the accompanying {file:UNLICENSE} file.
 
 [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
@@ -131,8 +221,12 @@ see <http://unlicense.org/> or the accompanying {file:UNLICENSE} file.
 [YARD-GS]:          http://rubydoc.info/docs/yard/file/docs/GettingStarted.md
 [PDD]:              http://unlicense.org/#unlicensing-contributions
 [Backports]:        http://rubygems.org/gems/backports
+[Linked Data]:      http://rubygems.org/gems/linkeddata
 [SPARQL doc]:       http://rubydoc.info/github/gkellogg/sparql/frames
 [SPARQL XML]:       http://www.w3.org/TR/rdf-sparql-XMLres/
 [SPARQL JSON]:      http://www.w3.org/TR/rdf-sparql-json-res/
 [SPARQL Protocol]:  http://www.w3.org/TR/rdf-sparql-protocol/
-[SPARQL Service]:   http://www.w3.org/TR/sparql11-service-description/
+[SSD]:              http://www.w3.org/TR/sparql11-service-description/
+[Rack]:             http://rack.rubyforge.org/
+[Sinatra]:          http://www.sinatrarb.com/
+[conneg]:           http://en.wikipedia.org/wiki/Content_negotiation

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.1.0

data/bin/sparql

@@ -2,7 +2,11 @@
 require 'rubygems'
 $:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", 'lib')))
 require 'sparql'
-require 'linkeddata'
+begin
+  require 'linkeddata'
+rescue LoadError => e
+  require 'rdf/ntriples'
+end
 require 'getoptlong'
 
 def run(input, options = {})
@@ -22,12 +26,13 @@ def run(input, options = {})
   end
 
   if options[:to_sse]
-    puts ("\nSSE:\n" + query.to_sxp)
+    puts ("\nSSE:\n" + query.to_sse)
   else
     res = query.execute(options[:graph])
     puts res.inspect if options[:verbose]
     puts case res
     when RDF::Graph then res.dump(:ttl, :base_uri => query.base_uri, :prefixes => query.prefixes)
+    when RDF::Literal then res.inspect
     else                 res.map {|s| s.bindings.map {|k,v| "#{k}: #{v}"}}.join("\n")
     end
   end

data/lib/rack/sparql.rb

@@ -0,0 +1,38 @@
+require 'rack'
+begin
+  require 'linkeddata'
+rescue LoadError => e
+  require 'rdf/ntriples'
+end
+require 'sparql'
+
+module Rack
+  module SPARQL
+    autoload :ContentNegotiation, 'rack/sparql/conneg'
+
+    ##
+    # Registers all known RDF formats with Rack's MIME types registry.
+    #
+    # Registers both known file extensions and format symbols.
+    #
+    # @param  [Hash{Symbol => Object}] options
+    # @option options [Boolean]        :overwrite (false)
+    # @return [void]
+    def self.register_mime_types!(options = {})
+      if defined?(Rack::Mime::MIME_TYPES)
+        RDF::Format.each do |format|
+          if !Rack::Mime::MIME_TYPES.has_key?(file_ext = ".#{format.to_sym}") || options[:overwrite]
+            Rack::Mime::MIME_TYPES.merge!(file_ext => format.content_type.first)
+          end
+        end
+        RDF::Format.file_extensions.each do |file_ext, formats|
+          if !Rack::Mime::MIME_TYPES.has_key?(file_ext = ".#{file_ext}") || options[:overwrite]
+            Rack::Mime::MIME_TYPES.merge!(file_ext => formats.first.content_type.first)
+          end
+        end
+      end
+    end
+  end
+end
+
+Rack::SPARQL.register_mime_types!

data/lib/rack/sparql/conneg.rb

@@ -0,0 +1,127 @@
+require 'rack'
+require 'sparql'
+
+module Rack; module SPARQL
+  ##
+  # Rack middleware for SPARQL content negotiation.
+  #
+  # Uses HTTP Content Negotiation to find an appropriate RDF
+  # format to serialize any result with a body being `RDF::Enumerable`.
+  #
+  # Override content negotiation by setting the :format option to
+  # {#initialize}.
+  #
+  # This endpoint also serves the fuction of Rack::LinkedData, as it will serialize
+  # SPARQL results, which may be RDF Graphs
+  class ContentNegotiation
+    VARY = {'Vary' => 'Accept'}.freeze
+
+    # @return [#call]
+    attr_reader :app
+
+    # @return [Hash{Symbol => Object}]
+    attr_reader :options
+
+    ##
+    # @param  [#call]                  app
+    # @param  [Hash{Symbol => Object}] options
+    #   Other options passed to writer.
+    # @option options [RDF::Format, #to_sym] :format Specific RDF writer format to use
+    def initialize(app, options = {})
+      @app, @options = app, options
+    end
+
+    ##
+    # Handles a Rack protocol request.
+    #
+    # If result is `RDF::Literal::Boolean`, `RDF::Query::Results`, or `RDF::Enumerable`
+    # The result is serialized using {SPARQL::Results}
+    #
+    # @param  [Hash{String => String}] env
+    # @return [Array(Integer, Hash, #each)]
+    # @see    http://rack.rubyforge.org/doc/SPEC.html
+    def call(env)
+      response = app.call(env)
+      case response[2] # the body
+        when RDF::Enumerable, RDF::Query::Solutions, RDF::Literal::Boolean
+          serialize(env, *response)
+        else response
+      end
+    end
+
+    ##
+    # Serializes a SPARQL query result into a Rack protocol
+    # response using HTTP content negotiation rules or a specified Content-Type.
+    #
+    # @param  [Hash{String => String}] env
+    # @param  [Integer]                status
+    # @param  [Hash{String => Object}] headers
+    # @param  [RDF::Enumerable]        body
+    # @return [Array(Integer, Hash, #each)]
+    # @raise [RDF::WriterError] when no results are generated
+    def serialize(env, status, headers, body)
+      begin
+        serialize_options = {}
+        serialize_options[:content_types] = parse_accept_header(env['HTTP_ACCEPT']) if env.has_key?('HTTP_ACCEPT')
+        serialize_options.merge!(@options)
+        results = ::SPARQL.serialize_results(body, serialize_options)
+        raise RDF::WriterError, "can't serialize results" unless results
+        headers = headers.merge(VARY).merge('Content-Type' => results.content_type) # FIXME: don't overwrite existing Vary headers
+        [status, headers, [results]]
+      rescue RDF::WriterError => e
+        not_acceptable(e.message)
+      end
+    end
+
+    protected
+
+    ##
+    # Parses an HTTP `Accept` header, returning an array of MIME content
+    # types ordered by the precedence rules defined in HTTP/1.1 Section 14.1.
+    #
+    # @param  [String, #to_s] header
+    # @return [Array<String>]
+    # @see    http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.1
+    def parse_accept_header(header)
+      entries = header.to_s.split(',')
+      entries.map { |e| accept_entry(e) }.sort_by(&:last).map(&:first)
+    end
+
+    def accept_entry(entry)
+      type, *options = entry.delete(' ').split(';')
+      quality = 0 # we sort smallest first
+      options.delete_if { |e| quality = 1 - e[2..-1].to_f if e.start_with? 'q=' }
+      [type, [quality, type.count('*'), 1 - options.size]]
+    end
+
+    ##
+    # Outputs an HTTP `406 Not Acceptable` response.
+    #
+    # @param  [String, #to_s] message
+    # @return [Array(Integer, Hash, #each)]
+    def not_acceptable(message = nil)
+      http_error(406, message, VARY)
+    end
+
+    ##
+    # Outputs an HTTP `4xx` or `5xx` response.
+    #
+    # @param  [Integer, #to_i]         code
+    # @param  [String, #to_s]          message
+    # @param  [Hash{String => String}] headers
+    # @return [Array(Integer, Hash, #each)]
+    def http_error(code, message = nil, headers = {})
+      message = http_status(code) + (message.nil? ? "\n" : " (#{message})\n")
+      [code, {'Content-Type' => 'text/plain; charset=utf-8'}.merge(headers), [message]]
+    end
+
+    ##
+    # Returns the standard HTTP status message for the given status `code`.
+    #
+    # @param  [Integer, #to_i] code
+    # @return [String]
+    def http_status(code)
+      [code, Rack::Utils::HTTP_STATUS_CODES[code]].join(' ')
+    end
+  end # class ContentNegotiation
+end; end # module Rack::SPARQL

data/lib/sinatra/sparql.rb

@@ -0,0 +1,116 @@
+require 'sinatra/base'
+require 'sinatra/sparql/extensions'
+require 'rack/sparql'
+
+module Sinatra
+  ##
+  # The Sinatra::SPARQL module adds Rack::SPARQL} middleware support for responding to
+  # SPARQL requests. It is the responsibility of the application to manage
+  # the SPARQL endpoint and perform the query. The query results are then sent
+  # as the response body. {Rack::SPARQL} middleware uses content negotiation
+  # to format the results appropriately.
+  # @see http://www.sinatrarb.com/extensions.html
+  module SPARQL
+    ##
+    # 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.
+      #
+      # The results are serialized using content negotiation. For text/html, authors
+      # should generate RDFa for the serivce description directly.
+      #
+      # @param [Hash{Symbol => Object}] options
+      # @option options [RDF::Enumerable] :repository
+      #   An enumerable, typically a type of `RDF::Repository` containing the dataset used for
+      #   queries against the service.
+      # @option options [RDF::URI, #to_s] :endpoint
+      #   URI of the service endpoint, defaults to "/sparql" in the current realm.
+      # @return [RDF::Graph]
+      #
+      # @see http://www.w3.org/TR/sparql11-service-description
+      # @see http://www.w3.org/TR/void/
+      def service_description(options = {})
+        repository = options[:repository]
+
+        g = RDF::Graph.new
+        sd = RDF::URI("http://www.w3.org/ns/sparql-service-description#")
+        void = RDF::URI("http://rdfs.org/ns/void#")
+      
+        node = RDF::Node.new
+        g << [node, RDF.type, sd.join("#Service")]
+        g << [node, sd.join("#endpoint"), options[:endpoint] || url("/sparql")]
+        g << [node, sd.join("#supportedLanguage"), sd.join("#SPARQL10Query")]
+      
+        # 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")]
+      
+        # Features
+        g << [node, sd.join("#feature"), sd.join("#DereferencesURIs")]
+      
+        # Datasets
+        ds = RDF::Node.new
+        g << [node, sd.join("#defaultDataset"), ds]
+        g << [ds, RDF.type, sd.join("#Dataset")]
+
+        # Contexts
+        if repository.is_a?(RDF::Enumerable)
+          contexts = {}
+          repository.each do |statement|
+            contexts[statement.context] ||= 0
+            contexts[statement.context] += 1
+          end
+          
+          contexts.each do |name, count|
+            bn = RDF::Node.new
+            if name
+              # Add named contexts as namedGraphs
+              g << [ds, sd.join("#namedGraph"), bn]
+              g << [bn, RDF.type, sd.join("#NamedGraph")]
+              g << [bn, sd.join("#name"), name]
+              graph = RDF::Node.new
+              g << [bn, sd.join("#graph"), graph]
+              bn = graph
+            else
+              # Default graph
+              g << [ds, sd.join("#defaultGraph"), bn]
+              g << [bn, RDF.type, sd.join("#Graph")]
+            end
+            g << [bn, void.join("#triples"), count]
+          end
+        end
+        g
+      end
+    end
+
+    ##
+    # * Registers Rack::SPARQL::ContentNegotiation
+    # * adds helpers
+    # * includes SPARQL, RDF and LinkedData
+    # * defines `sparql_options`, which are passed to the Rack middleware
+    #   available as `settings.sparql_options` and as options within
+    #   the {Rack::SPARQL} middleware.
+    #
+    # @param  [Sinatra::Base] app
+    # @return [void]
+    def self.registered(app)
+      options = {}
+      app.set :sparql_options, options
+      app.use(Rack::SPARQL::ContentNegotiation, options)
+      app.helpers(Sinatra::SPARQL::Helpers)
+      app.send(:include, ::SPARQL)
+      app.send(:include, ::RDF)
+      app.send(:include, ::LinkedData)
+    end
+  end
+end
+
+Sinatra.register(Sinatra::SPARQL)

data/lib/sinatra/sparql/extensions.rb

@@ -0,0 +1,19 @@
+# Patch Sinatra::Response#finish to not calculate Content-Length unless
+# all members of an array are strings
+class Sinatra::Response
+  def finish
+    if status.to_i / 100 == 1
+      headers.delete "Content-Length"
+      headers.delete "Content-Type"
+    elsif RDF::Query::Solutions === body
+      # Don't calculate content-length here
+    elsif Array === body and not [204, 304].include?(status.to_i)
+      headers["Content-Length"] = body.inject(0) { |l, p| l + Rack::Utils.bytesize(p) }.to_s
+    end
+
+    # Rack::Response#finish sometimes returns self as response body. We don't want that.
+    status, headers, result = super
+    result = body if result == self
+    [status, headers, result]
+  end
+end

data/lib/sparql.rb

@@ -44,12 +44,11 @@ module SPARQL
   # presumed to be existant in `queryable` or are loaded into `queryable` depending
   # on the presense and value of the :load_datasets option.
   #
-  # Attempting to load into an immutable `queryable` will result in a RDF::TypeError.
+  # Attempting to load into an immutable `queryable` will result in a TypeError.
   #
   # @example
   #   repository = RDF::Repository.new
   #   results = SPARQL.execute("SELECT * WHERE { ?s ?p ?o }", repository)
-  #   result = parser.parse
   #
   # @param  [IO, StringIO, String, #to_s]  query
   # @param  [Hash{Symbol => Object}] options
@@ -80,7 +79,7 @@ module SPARQL
     solutions = query.execute(queryable)
   rescue SPARQL::Grammar::Parser::Error => e
     raise MalformedQuery, e.message
-  rescue RDF::TypeError => e
+  rescue TypeError => e
     raise QueryRequestRefused, e.message
   end
 

data/lib/sparql/algebra.rb

@@ -189,7 +189,7 @@ module SPARQL
   # Some very simple optimizations are currently implemented for `FILTER`
   # expressions. Use the following to obtain optimized SSE forms:
   # 
-  #     Expression.parse(sse).optimize.to_sse
+  #     Expression.parse(sse).optimize.to_sxp_bin
   # 
   # ## Constant comparison folding
   # 

data/lib/sparql/algebra/expression.rb

@@ -239,7 +239,7 @@ module SPARQL; module Algebra
     #
     # @return [Array] `self`
     # @see    http://openjena.org/wiki/SSE
-    def to_sse
+    def to_sxp_bin
       self
     end
     
@@ -274,7 +274,12 @@ module SPARQL; module Algebra
       message = args.join(": ")
       message = message + yield if block_given?
       depth = options[:depth] || 0
-      $stderr.puts("#{' ' * depth}#{message}") if options[:debug]
+      case options[:debug]
+      when Array
+        options[:debug] << "#{' ' * depth}#{message}"
+      else
+        $stderr.puts("#{' ' * depth}#{message}")
+      end
     end
     
     def debug(*args, &block)

data/lib/sparql/algebra/extensions.rb

@@ -4,12 +4,18 @@ require 'json'
 # Extensions for Ruby's `Object` class.
 class Object
   ##
-  # Returns the SXP representation of this object, defaults to `self'.
+  # Returns the SXP binary representation of this object, defaults to `self'.
   #
   # @return [String]
-  def to_sse
+  def to_sxp_bin
     self
   end
+  
+  ##
+  # Make sure the object is in SXP form and transform it to a string form
+  def to_sse
+    self.to_sxp_bin.to_sxp
+  end
 end
 
 ##
@@ -19,8 +25,8 @@ class Array
   # Returns the SXP representation of this object, defaults to `self'.
   #
   # @return [String]
-  def to_sse
-    map {|x| x.to_sse}
+  def to_sxp_bin
+    map {|x| x.to_sxp_bin}
   end
   
   ##
@@ -101,8 +107,8 @@ class RDF::Query
   # If Query is named, it's treated as a GroupGraphPattern, otherwise, a BGP
   #
   # @return [Array]
-  def to_sse
-    res = [:bgp] + patterns.map(&:to_sse)
+  def to_sxp_bin
+    res = [:bgp] + patterns.map(&:to_sxp_bin)
     (context ? [:graph, context, res] : res)
   end
 end
@@ -110,7 +116,7 @@ end
 class RDF::Query::Pattern
   # Transform Query Pattern into an SXP
   # @return [Array]
-  def to_sse
+  def to_sxp_bin
     [:triple, subject, predicate, object]
   end
 end

data/lib/sparql/algebra/operator.rb

@@ -323,9 +323,9 @@ module SPARQL; module Algebra
     #
     # @return [Array]
     # @see    http://openjena.org/wiki/SSE
-    def to_sse
+    def to_sxp_bin
       operator = [self.class.const_get(:NAME)].flatten.first
-      [operator, *(operands || []).map(&:to_sse)]
+      [operator, *(operands || []).map(&:to_sxp_bin)]
     end
 
     ##
@@ -340,7 +340,7 @@ module SPARQL; module Algebra
       end
       require 'sparql/algebra/sxp_extensions'
       
-      to_sse.to_sxp
+      to_sxp_bin.to_sxp
     end
 
     ##

data/lib/sparql/algebra/operator/dataset.rb

@@ -1,3 +1,9 @@
+begin
+  require 'linkeddata'
+rescue LoadError => e
+  require 'rdf/ntriples'
+end
+
 module SPARQL; module Algebra
   class Operator
     ##
@@ -17,6 +23,11 @@ module SPARQL; module Algebra
       include Query
       
       NAME = [:dataset]
+      # Selected accept headers, from those available
+      ACCEPTS = (%w(text/turtle application/rdf+xml;q=0.8 text/plain;q=0.4).
+        select do |content_type|
+          RDF::Format.content_types.include?(content_type.split(';').first)
+        end << ' */*;q=0.1').join(', ').freeze
 
       ##
       # Executes this query on the given `queryable` graph or repository.
@@ -35,7 +46,9 @@ module SPARQL; module Algebra
       def execute(queryable, options = {})
         debug(options) {"Dataset"}
         operand(0).each do |ds|
-          load_opts = {}
+          load_opts = {
+            :headers => {"Accept" => ACCEPTS}
+          }
           case ds
           when Array
             # Format is (named <uri>), only need the URI part

data/lib/sparql/grammar/parser.rb

@@ -95,7 +95,7 @@ module SPARQL; module Grammar
     end
     
     # @return [String]
-    def to_sse
+    def to_sxp_bin
       @result
     end
     
@@ -260,7 +260,7 @@ module SPARQL; module Grammar
     #
     # @return [HRDF::URI]
     def base_uri
-      @options[:base_uri]
+      RDF::URI(@options[:base_uri])
     end
 
     ##
@@ -1089,7 +1089,12 @@ module SPARQL; module Grammar
       message = args.join(": ")
       message = message + yield if block_given?
       depth = options[:depth] || @productions.length
-      $stderr.puts("[#{@lineno}]#{' ' * depth}#{message}") if options[:debug]
+      case options[:debug]
+      when Array
+        options[:debug] << "[#{@lineno}]#{' ' * depth}#{message}"
+      else
+        $stderr.puts("[#{@lineno}]#{' ' * depth}#{message}")
+      end
     end
 
     # [1]     Query                     ::=       Prologue ( SelectQuery | ConstructQuery | DescribeQuery | AskQuery )

data/lib/sparql/results.rb

@@ -118,22 +118,39 @@ module SPARQL
   # @param [RDF::Query::Solutions, RDF::Queryable, Boolean] solutions
   #   Solutions as either a solution set, a Queryable object (such as a graph) or a Boolean value
   # @param [Hash{Symbol => Object}] options
-  # @option options [:format]
+  # @option options [#to_sym] :format
   #   Format of results, one of :html, :json or :xml.
   #   May also be an RDF::Writer format to serialize DESCRIBE or CONSTRUCT results
-  # @option options [:content_type]
+  # @option options [String] :content_type
   #   Format of results, one of 'application/sparql-results+json' or 'application/sparql-results+xml'
   #   May also be an RDF::Writer content_type to serialize DESCRIBE or CONSTRUCT results
+  # @option options [Array<String>] :content_types
+  #   Similar to :content_type, but takes an ordered array of appropriate content types,
+  #   and serializes using the first appropriate type, including wild-cards.
   # @return [String]
   #   String with serialized results and #content_type
+  # @raise [RDF::WriterError] when inappropriate formatting options are used
   def serialize_results(solutions, options = {})
-    format = options[:format]
-    content_type = options[:content_type]
+    format = options[:format].to_sym if options[:format]
+    content_type = options[:content_type].to_s.split(';').first
+    content_types = options[:content_types] || ['*/*']
     format ||= RDF::Query::Solutions::MIME_TYPES.invert[content_type] if content_type
 
+    if !format && !content_type
+      case solutions
+      when RDF::Queryable
+        content_type = first_content_type(content_types, RDF::Format.content_types.keys) || 'text/plain'
+        format = RDF::Writer.for(:content_type => content_type).to_sym
+      else
+        content_type = first_content_type(content_types, RDF::Query::Solutions::MIME_TYPES.values) || 'application/sparql-results+xml'
+        format = RDF::Query::Solutions::MIME_TYPES.invert[content_type]
+      end
+    end
+
     serialization = case solutions
-    when TrueClass, FalseClass
-      case format ||= :xml
+    when TrueClass, FalseClass, RDF::Literal::TRUE, RDF::Literal::FALSE
+      solutions = solutions.object if solutions.is_a?(RDF::Literal)
+      case format
       when :json
         require 'json' unless defined?(::JSON)
         {:boolean => solutions}.to_json
@@ -149,18 +166,29 @@ module SPARQL
         content_type = "text/html"
         xml = ::Builder::XmlMarkup.new(:indent => 2)
         xml.div(solutions.to_s, :class => "sparql")
+      else
+        raise RDF::WriterError, "Unknown format #{(format || content_type).inspect} for #{solutions.class}"
       end
     when RDF::Queryable
+      begin
+        require 'linkeddata'
+      rescue LoadError => e
+        require 'rdf/ntriples'
+      end
       fmt = RDF::Format.for(format ? format.to_sym : {:content_type => content_type})
       fmt ||= RDF::NTriples::Format
       format ||= fmt.to_sym
-      content_type ||= fmt.content_types.first
-      fmt.writer.buffer << solutions
+      content_type ||= fmt.content_type.first
+      results = solutions.dump(format, options)
+      raise RDF::WriterError, "Unknown format #{fmt.inspect} for #{solutions.class}" unless results
+      results
     when RDF::Query::Solutions
-      case format ||= :xml
+      case format
       when :json  then solutions.to_json
       when :xml   then solutions.to_xml
       when :html  then solutions.to_html
+      else
+        raise RDF::WriterError, "Unknown format #{(format || content_type).inspect} for #{solutions.class}"
       end
     end
 
@@ -184,6 +212,26 @@ module SPARQL
 </html>
 ).freeze
   
+  ##
+  # Find a content_type from a list using an ordered list of acceptable content types
+  # using wildcard matching
+  #
+  # @param [Array<String>] acceptable
+  # @param [Array<String>] available
+  # @return [String]
+  #
+  # @see http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.1
+  def first_content_type(acceptable, available)
+    return acceptable.first if available.empty?
+    available.flatten!
+    acceptable.each do |pattern|
+      type = available.detect { |t| File.fnmatch(pattern, t) }
+      return type if type
+    end
+    nil
+  end
+  module_function :first_content_type
+
   ##
   # Serialize error results
   #

metadata

@@ -1,33 +1,32 @@
 --- !ruby/object:Gem::Specification
 name: sparql
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
 - Gregg Kellogg
 - Arto Bendiken
-- Ben Levendar
 - Pius Uzamere
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-13 00:00:00.000000000 Z
+date: 2012-01-31 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
-  requirement: &2156022280 !ruby/object:Gem::Requirement
+  requirement: &2165243520 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.3.4
+        version: 0.3.5
   type: :runtime
   prerelease: false
-  version_requirements: *2156022280
+  version_requirements: *2165243520
 - !ruby/object:Gem::Dependency
   name: builder
-  requirement: &2156020980 !ruby/object:Gem::Requirement
+  requirement: &2165242720 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -35,10 +34,10 @@ dependencies:
         version: 3.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *2156020980
+  version_requirements: *2165242720
 - !ruby/object:Gem::Dependency
   name: json
-  requirement: &2156018920 !ruby/object:Gem::Requirement
+  requirement: &2165241340 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -46,10 +45,10 @@ dependencies:
         version: 1.5.1
   type: :runtime
   prerelease: false
-  version_requirements: *2156018920
+  version_requirements: *2165241340
 - !ruby/object:Gem::Dependency
   name: sxp
-  requirement: &2156017400 !ruby/object:Gem::Requirement
+  requirement: &2165240320 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -57,43 +56,87 @@ dependencies:
         version: 0.0.14
   type: :runtime
   prerelease: false
-  version_requirements: *2156017400
+  version_requirements: *2165240320
 - !ruby/object:Gem::Dependency
   name: sparql-client
-  requirement: &2156015680 !ruby/object:Gem::Requirement
+  requirement: &2165237360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.0.9
+        version: 0.0.11
   type: :runtime
   prerelease: false
-  version_requirements: *2156015680
+  version_requirements: *2165237360
 - !ruby/object:Gem::Dependency
   name: rdf-xsd
-  requirement: &2156014600 !ruby/object:Gem::Requirement
+  requirement: &2165236080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.3.4
+        version: 0.3.5
   type: :runtime
   prerelease: false
-  version_requirements: *2156014600
+  version_requirements: *2165236080
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: &2165234460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+  type: :development
+  prerelease: false
+  version_requirements: *2165234460
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: &2165232960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.4.1
+  type: :development
+  prerelease: false
+  version_requirements: *2165232960
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: &2165230920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.6.1
+  type: :development
+  prerelease: false
+  version_requirements: *2165230920
 - !ruby/object:Gem::Dependency
   name: linkeddata
-  requirement: &2156013760 !ruby/object:Gem::Requirement
+  requirement: &2165224020 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.3.4
+        version: 0.3.5
   type: :development
   prerelease: false
-  version_requirements: *2156013760
+  version_requirements: *2165224020
+- !ruby/object:Gem::Dependency
+  name: rdf-spec
+  requirement: &2165221300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.5
+  type: :development
+  prerelease: false
+  version_requirements: *2165221300
 - !ruby/object:Gem::Dependency
   name: open-uri-cached
-  requirement: &2156011940 !ruby/object:Gem::Requirement
+  requirement: &2165218280 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -101,32 +144,43 @@ dependencies:
         version: 0.0.4
   type: :development
   prerelease: false
-  version_requirements: *2156011940
+  version_requirements: *2165218280
+- !ruby/object:Gem::Dependency
+  name: equivalent-xml
+  requirement: &2165215280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.2.8
+  type: :development
+  prerelease: false
+  version_requirements: *2165215280
 - !ruby/object:Gem::Dependency
   name: nokogiri
-  requirement: &2156010340 !ruby/object:Gem::Requirement
+  requirement: &2165202460 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.4.4
+        version: 1.5.0
   type: :development
   prerelease: false
-  version_requirements: *2156010340
+  version_requirements: *2165202460
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2156009140 !ruby/object:Gem::Requirement
+  requirement: &2165199020 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 2.5.0
+        version: 2.8.0
   type: :development
   prerelease: false
-  version_requirements: *2156009140
+  version_requirements: *2165199020
 - !ruby/object:Gem::Dependency
   name: spira
-  requirement: &2156007540 !ruby/object:Gem::Requirement
+  requirement: &2165196200 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -134,18 +188,18 @@ dependencies:
         version: 0.0.12
   type: :development
   prerelease: false
-  version_requirements: *2156007540
+  version_requirements: *2165196200
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &2156005820 !ruby/object:Gem::Requirement
+  requirement: &2165194600 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: 0.7.5
   type: :development
   prerelease: false
-  version_requirements: *2156005820
+  version_requirements: *2165194600
 description: ! "\n    Implements SPARQL grammar parsing to SPARQL Algebra, SPARQL
   Algebra processing\n    and includes SPARQL Client for accessing remote repositories."
 email: public-rdf-ruby@w3.org
@@ -160,6 +214,10 @@ files:
 - UNLICENSE
 - VERSION
 - bin/sparql
+- lib/rack/sparql/conneg.rb
+- lib/rack/sparql.rb
+- lib/sinatra/sparql/extensions.rb
+- lib/sinatra/sparql.rb
 - lib/sparql/algebra/evaluatable.rb
 - lib/sparql/algebra/expression.rb
 - lib/sparql/algebra/extensions.rb
@@ -222,7 +280,7 @@ files:
 - lib/sparql/results.rb
 - lib/sparql/version.rb
 - lib/sparql.rb
-homepage: http://sparql.rubyforge.org/
+homepage: http://github.com/gkellogg/sparql
 licenses:
 - Public Domain
 post_install_message: 
@@ -234,7 +292,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: 1.8.1
+      version: 1.8.7
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -248,3 +306,4 @@ signing_key:
 specification_version: 3
 summary: SPARQL library for Ruby.
 test_files: []
+has_rdoc: false