rack-linkeddata 0.1.0

data/AUTHORS

@@ -0,0 +1 @@
+* Arto Bendiken <arto.bendiken@gmail.com>

data/README

@@ -0,0 +1,121 @@
+Linked Data Content Negotiation for Rack Applications
+=====================================================
+
+This is [Rack][] middleware that provides [Linked Data][] content
+negotiation for Rack applications. You can use `Rack::LinkedData` with any
+Ruby web framework based on Rack, including with Ruby on Rails 3.0 and with
+Sinatra.
+
+* <http://github.com/datagraph/rack-linkeddata>
+
+Features
+--------
+
+* Implements [HTTP content negotiation][conneg] for RDF content types.
+* Supports all [RDF.rb][]-compatible serialization formats.
+* Compatible with any Rack application and any Rack-based framework.
+
+Examples
+--------
+
+### Adding Linked Data content negotiation to a Rack application
+
+    #!/usr/bin/env rackup
+    require 'rack/linkeddata'
+    
+    rdf = RDF::Graph.new do
+      self << [RDF::Node.new, RDF::DC.title, "Hello, world!"]
+    end
+    
+    use Rack::LinkedData::ContentNegotiation
+    run lambda { |env| [200, {}, rdf] }
+
+### Defining a default Linked Data content type
+
+    use Rack::LinkedData::ContentNegotiation, :default => "text/turtle"
+
+### Testing Linked Data content negotiation using `rackup` and `curl`
+
+    $ rackup doc/examples/hello.ru
+    
+    $ curl -iH "Accept: text/plain" http://localhost:9292/hello
+    $ curl -iH "Accept: text/turtle" http://localhost:9292/hello
+    $ curl -iH "Accept: application/rdf+xml" http://localhost:9292/hello
+    $ curl -iH "Accept: application/json" http://localhost:9292/hello
+    $ curl -iH "Accept: application/trix" http://localhost:9292/hello
+    $ curl -iH "Accept: */*" http://localhost:9292/hello
+
+Description
+-----------
+
+`Rack::LinkedData` implements content negotiation for any [Rack][] response
+object that implements the `RDF::Enumerable` mixin. You would typically
+return an instance of `RDF::Graph` or `RDF::Repository` from your Rack
+application, and let the `Rack::LinkedData::ContentNegotiation` middleware
+take care serializing your response into whatever RDF format the HTTP client
+requested and understands.
+
+The middleware works by querying [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, Turtle, RDF/XML, RDF/JSON and TriX.)
+
+Documentation
+-------------
+
+<http://datagraph.rubyforge.org/rack-linkeddata/>
+
+* {Rack::LinkedData}
+  * {Rack::LinkedData::ContentNegotiation}
+
+Dependencies
+------------
+
+* [Rack](http://rubygems.org/gems/rack) (>= 1.0.0)
+* [Linked Data](http://rubygems.org/gems/linkeddata) (>= 0.1.10)
+
+Installation
+------------
+
+The recommended installation method is via [RubyGems](http://rubygems.org/).
+To install the latest official release of the gem, do:
+
+    % [sudo] gem install rack-linkeddata
+
+Download
+--------
+
+To get a local working copy of the development repository, do:
+
+    % git clone git://github.com/datagraph/rack-linkeddata.git
+
+Alternatively, you can download the latest development version as a tarball
+as follows:
+
+    % wget http://github.com/datagraph/rack-linkeddata/tarball/master
+
+References
+----------
+
+* <http://www.w3.org/DesignIssues/LinkedData.html>
+* <http://linkeddata.org/docs/how-to-publish>
+* <http://linkeddata.org/conneg-303-redirect-code-samples>
+* <http://www.w3.org/TR/cooluris/>
+* <http://www.w3.org/TR/swbp-vocab-pub/>
+* <http://patterns.dataincubator.org/book/publishing-patterns.html>
+
+Authors
+-------
+
+* [Arto Bendiken](mailto:arto.bendiken@gmail.com) - <http://ar.to/>
+
+License
+-------
+
+`Rack::LinkedData` is free and unencumbered public domain software. For more
+information, see <http://unlicense.org/> or the accompanying UNLICENSE file.
+
+[Rack]:           http://rack.rubyforge.org/
+[RDF.rb]:         http://rdf.rubyforge.org/
+[Linked Data]:    http://linkeddata.org/
+[conneg]:         http://en.wikipedia.org/wiki/Content_negotiation

data/UNLICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+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/>

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/rack/linkeddata/conneg.rb

@@ -0,0 +1,150 @@
+module Rack; module LinkedData
+  ##
+  # Rack middleware for Linked Data content negotiation.
+  #
+  # @see http://www4.wiwiss.fu-berlin.de/bizer/pub/LinkedDataTutorial/
+  class ContentNegotiation
+    DEFAULT_CONTENT_TYPE = "text/plain" # N-Triples
+
+    # @return [#call]
+    attr_reader :app
+
+    # @return [Hash{Symbol => Object}]
+    attr_reader :options
+
+    ##
+    # @param  [#call]                  app
+    # @param  [Hash{Symbol => Object}] options
+    # @option options [String] :default (DEFAULT_CONTENT_TYPE)
+    def initialize(app, options = {})
+      @app, @options = app, options.to_hash.dup
+      @options[:default] = (@options[:default] || DEFAULT_CONTENT_TYPE).to_s
+    end
+
+    ##
+    # Handles a Rack protocol request.
+    #
+    # @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 env['REQUEST_METHOD'].to_sym
+        when :GET, :HEAD
+          case response[2] # the body
+            when RDF::Enumerable
+              serialize(env, *response)
+            else response
+          end
+        else response
+      end
+    end
+
+    ##
+    # Serializes an `RDF::Enumerable` response into a Rack protocol
+    # response using HTTP content negotiation rules.
+    #
+    # @param  [Hash{String => String}] env
+    # @param  [Integer]                status
+    # @param  [Hash{String => Object}] headers
+    # @param  [RDF::Enumerable]        body
+    # @return [Array(Integer, Hash, #each)]
+    def serialize(env, status, headers, body)
+      writer, content_type = find_writer(env)
+      writer ? [status, headers.merge('Content-Type' => content_type), [writer.dump(body)]] : not_acceptable
+    end
+
+    ##
+    # Returns an `RDF::Writer` class for the given `env`.
+    #
+    # @param  [Hash{String => String}] env
+    # @return [Array(Class, String)]
+    # @see    http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html
+    def find_writer(env)
+      unless env.has_key?('HTTP_ACCEPT')
+        # HTTP/1.1 §14.1: "If no Accept header field is present, then it is
+        # assumed that the client accepts all media types"
+        find_writer_for_content_type(options[:default])
+      else
+        content_types = parse_accept_header(env['HTTP_ACCEPT'])
+        content_types.each do |content_type|
+          writer, content_type = find_writer_for_content_type(content_type)
+          return [writer, content_type] if writer
+        end
+        return nil
+      end
+    end
+
+    ##
+    # Returns an `RDF::Writer` class for the given `content_type`.
+    #
+    # @param  [String, #to_s] content_type
+    # @return [Array(Class, String)]
+    def find_writer_for_content_type(content_type)
+      writer = case content_type.to_s
+        when '*/*'
+          RDF::Writer.for(:content_type => (content_type = options[:default]))
+        when /^([^\/]+)\/\*$/
+          nil # TODO: match subtype wildcards
+        else
+          RDF::Writer.for(:content_type => content_type)
+      end
+      writer ? [writer, content_type] : nil
+    end
+
+    protected
+
+    ##
+    # Parses an HTTP `Accept` header, returning an array of MIME content
+    # types ordered by the precedence rules defined in HTTP/1.1 §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)
+      content_types = header.to_s.split(',').map do |content_type_and_weight|
+        content_type_and_weight.strip!
+        case content_type_and_weight
+          when /^([^;]+);\s*q=(\d+\.\d+)$/
+            [[1.0, $2.to_f].min, $1, content_type_and_weight]
+          when /(\S+)/
+            [1.0, $1, content_type_and_weight]
+          else nil
+        end
+      end
+      content_types.compact! # remove nils
+      content_types = content_types.sort_by { |elem| [elem[0], elem[2].size] }
+      content_types.reverse.map { |elem| elem[1] }
+    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)
+    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::LinkedData

data/lib/rack/linkeddata/version.rb

@@ -0,0 +1,23 @@
+module Rack; module LinkedData
+  module VERSION
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 0
+    EXTRA = nil
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+    STRING << ".#{EXTRA}" if EXTRA
+
+    ##
+    # @return [String]
+    def self.to_s() STRING end
+
+    ##
+    # @return [String]
+    def self.to_str() STRING end
+
+    ##
+    # @return [Array(Integer, Integer, Integer)]
+    def self.to_a() [MAJOR, MINOR, TINY] end
+  end
+end; end

data/lib/rack/linkeddata.rb

@@ -0,0 +1,9 @@
+require 'rack'
+require 'linkeddata'
+
+module Rack
+  module LinkedData
+    autoload :ContentNegotiation, 'rack/linkeddata/conneg'
+    autoload :VERSION,            'rack/linkeddata/version'
+  end
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification 
+name: rack-linkeddata
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Datagraph
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-26 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rack-test
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 5
+        - 3
+        version: 0.5.3
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 3
+        - 0
+        version: 1.3.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 5
+        - 5
+        version: 0.5.5
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rack
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: linkeddata
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 1
+        - 10
+        version: 0.1.10
+  type: :runtime
+  version_requirements: *id005
+description: Rack middleware for Linked Data content negotiation.
+email: datagraph@googlegroups.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- AUTHORS
+- README
+- UNLICENSE
+- VERSION
+- lib/rack/linkeddata/conneg.rb
+- lib/rack/linkeddata/version.rb
+- lib/rack/linkeddata.rb
+has_rdoc: false
+homepage: http://github.com/datagraph
+licenses: 
+- Public Domain
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 8
+      - 2
+      version: 1.8.2
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: datagraph
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Linked Data content negotiation for Rack applications.
+test_files: []
+