rack-rdf 3.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 13652453e2d12d1f8513353295d36488e73e9b60c4e7e163bbc47eb680ae1ad9
+  data.tar.gz: 5fe0fe7c64b5f4580cf17b483fa66ffce192e8f96959b93b921ac0fc2aae9f4a
+SHA512:
+  metadata.gz: bb4db0ef155289c5685ea22c8c83efd7c41fb9936c93623792fe1156b2ec2b763e3af6428ecb2f4d21769bb0f8e17df894974327ef91036e6499e37553bf1af3
+  data.tar.gz: bc5baef7ae1c96331288f23ea6743d3a1dd3e1731855b72a6d53122566fbbf8e0e0ba126bfb4aff95104940f5407eb7e370732afc1d4b1d8c019e2e40926edc8

data/AUTHORS

@@ -0,0 +1,2 @@
+* Arto Bendiken <arto.bendiken@gmail.com>
+* Gregg Kellogg <gregg@greggkellogg.net>

data/CREDITS

@@ -0,0 +1 @@
+* Gregg Kellogg <gregg@greggkellogg.net>

data/README.md

@@ -0,0 +1,161 @@
+# Linked Data Content Negotiation for Rack Applications
+
+This is [Rack][] middleware that provides [Linked Data][] content
+negotiation for Rack applications. You can use `Rack::RDF` with any
+Ruby web framework based on Rack, including with Ruby on Rails 3.0 and with
+Sinatra.
+
+This version is based on [rack-linkeddata][] without the hard dependency on the [linkeddata][] gem, to allow applications to better manage their dependencies
+
+* <http://github.com/datagraph/rack-rdf>
+
+[![Gem Version](https://badge.fury.io/rb/rack-rdf.png)](http://badge.fury.io/rb/rack-rdf)
+[![Build Status](https://travis-ci.org/ruby-rdf/rack-rdf.png?branch=master)](http://travis-ci.org/ruby-rdf/rack-rdf)
+
+## 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 RDF content negotiation to a Rails 3.x application
+
+    # config/application.rb
+    require 'rack/rdf'
+    
+    class Application < Rails::Application
+      config.middleware.use Rack::RDF::ContentNegotiation
+    end
+
+### Adding RDF content negotiation to a Sinatra application
+
+    #!/usr/bin/env ruby -rubygems
+    require 'sinatra'
+    require 'rack/linkeddata'
+    
+    use Rack::LinkedData::ContentNegotiation
+    
+    get '/hello' do
+      RDF::Graph.new do |graph|
+        graph << [RDF::Node.new, RDF::DC.title, "Hello, world!"]
+      end
+    end
+
+### Adding RDF content negotiation to a Rackup application
+
+    #!/usr/bin/env rackup
+    require 'rack/rdf'
+    
+    rdf = RDF::Graph.new do |graph|
+      graph << [RDF::Node.new, RDF::DC.title, "Hello, world!"]
+    end
+    
+    use Rack::RDF::ContentNegotiation
+    run lambda { |env| [200, {}, rdf] }
+
+### Defining a default RDF content type
+
+    use Rack::RDF::ContentNegotiation, default: "text/turtle"
+
+Options are also passed to the writer, which can allow options to be shared among the application
+and different components.
+
+    shared_options = {:default => "text/turtle", :standard_prefixes => true, }
+    use Rack::RDF::ContentNegotiation, shared_options
+    run MyApplication, shared_options
+
+### Testing RDF 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: */*" http://localhost:9292/hello
+
+## Description
+
+`Rack::RDF` 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::RDF::ContentNegotiation` middleware
+take care of serializing your response into whatever RDF format the HTTP
+client requested and understands.
+
+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.)
+
+##Documentation
+
+<http://http://rubydoc.info/github/ruby-rdf/rack-rdf/>
+
+* {Rack::RDF}
+  * {Rack::RDF::ContentNegotiation}
+
+## Dependencies
+
+* [Rack](http://rubygems.org/gems/rack) (~> 2.0)
+* [RDF](http://rubygems.org/gems/rdf) (~> 3.1)
+
+## 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-rdf
+
+## Download
+
+To get a local working copy of the development repository, do:
+
+    % git clone git://github.com/ruby-rdf/rack-rdf.git
+
+Alternatively, download the latest development version as a tarball as
+follows:
+
+    % wget http://github.com/ruby-rdf/rack-rdf/tarball/master
+
+## 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.
+
+* Do your best to adhere to the existing coding conventions and idioms.
+* Don't use hard tabs, and don't leave trailing whitespace on any line.
+* Do document every method you add using [YARD][] annotations. Read the
+  [tutorial][YARD-GS] or just look at the existing code for examples.
+* Don't touch the `.gemspec`, `VERSION` or `AUTHORS` files. If you need to
+  change them, do so on your private branch only.
+* Do feel free to add yourself to the `CREDITS` file and the corresponding
+  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.
+
+## 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](http://github.com/bendiken) - <http://ar.to/>
+* [Gregg Kellogg](http://github.com/gkellogg) - <http://greggkellogg.net/>
+
+## License
+
+This is free and unencumbered public domain software. For more information,
+see <http://unlicense.org/> or the accompanying {file:UNLICENSE} file.
+
+[Rack]:           http://rack.github.com/
+[RDF.rb]:         http://ruby-rdf.github.com/rdf/
+[Linked Data]:    http://linkeddata.org/
+[conneg]:         http://en.wikipedia.org/wiki/Content_negotiation
+[YARD]:           http://yardoc.org/
+[YARD-GS]:        http://rubydoc.info/docs/yard/file/docs/GettingStarted.md
+[PDD]:            http://unlicense.org/#unlicensing-contributions

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 @@
+3.1.0

data/lib/rack/rdf.rb

@@ -0,0 +1,34 @@
+require 'rack'
+require 'rdf'
+require 'rdf/ntriples'
+require 'rdf/nquads'
+
+module Rack
+  module RDF
+    autoload :ContentNegotiation, 'rack/rdf/conneg'
+    autoload :VERSION,            'rack/rdf/version'
+
+    ##
+    # Registers all known RDF formats with Rack's MIME types registry.
+    #
+    # @param [Boolean]        :overwrite (false)
+    # @param  [Hash{Symbol => Object}] options
+    # @return [void]
+    def self.register_mime_types!(overwrite: false, **options)
+      if defined?(Rack::Mime::MIME_TYPES)
+        ::RDF::Format.each do |format|
+          if !Rack::Mime::MIME_TYPES.has_key?(file_ext = ".#{format.to_sym}") || 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}") || overwrite
+            Rack::Mime::MIME_TYPES.merge!(file_ext => formats.first.content_type.first)
+          end
+        end
+      end
+    end
+  end
+end
+
+Rack::RDF.register_mime_types!

data/lib/rack/rdf/conneg.rb

@@ -0,0 +1,239 @@
+module Rack; module RDF
+  ##
+  # Rack middleware for Linked Data 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}.
+  #
+  # Add a :default option to set a content type to use when nothing else
+  # is found.
+  #
+  # @example
+  #     use Rack::RDF::ContentNegotation, :format => :ttl
+  #     use Rack::RDF::ContentNegotiation, :format => RDF::NTriples::Format
+  #     use Rack::RDF::ContentNegotiation, :default => 'application/rdf+xml'
+  #
+  # @see http://www4.wiwiss.fu-berlin.de/bizer/pub/LinkedDataTutorial/
+  # @see https://www.rubydoc.info/github/rack/rack/master/file/SPEC
+  class ContentNegotiation
+    DEFAULT_CONTENT_TYPE = "application/n-triples" # N-Triples
+    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.
+    # @param [String] :default (DEFAULT_CONTENT_TYPE) Specific content type
+    # @option options [RDF::Format, #to_sym] :format Specific RDF writer format to use
+    def initialize(app, options)
+      @app, @options = app, options
+      @options[:default] = (@options[:default] || DEFAULT_CONTENT_TYPE).to_s
+    end
+
+    ##
+    # Handles a Rack protocol request.
+    # Parses Accept header to find appropriate mime-type and sets content_type accordingly.
+    #
+    # Inserts ordered content types into the environment as `ORDERED_CONTENT_TYPES` if an Accept header is present
+    #
+    # @param  [Hash{String => String}] env
+    # @return [Array(Integer, Hash, #each)] Status, Headers and Body
+    # @see    http://rack.rubyforge.org/doc/SPEC.html
+    def call(env)
+      env['ORDERED_CONTENT_TYPES'] = parse_accept_header(env['HTTP_ACCEPT']) if env.has_key?('HTTP_ACCEPT')
+      response = app.call(env)
+      body = response[2].respond_to?(:body) ? response[2].body : response[2]
+      case body
+        when ::RDF::Enumerable
+          response[2] = body  # Put it back in the response, it might have been a proxy
+          serialize(env, *response)
+        else response
+      end
+    end
+
+    ##
+    # Serializes an `RDF::Enumerable` response into a Rack protocol
+    # response using HTTP content negotiation rules or a specified Content-Type.
+    #
+    # Passes parameters from Accept header, and Link header to writer.
+    #
+    # @param  [Hash{String => String}] env
+    # @param  [Integer]                status
+    # @param  [Hash{String => Object}] headers
+    # @param  [RDF::Enumerable]        body
+    # @return [Array(Integer, Hash, #each)] Status, Headers and Body
+    def serialize(env, status, headers, body)
+      result, content_type = nil, nil
+      find_writer(env, headers) do |writer, ct, accept_params = {}|
+        begin
+          # Passes content_type as writer option to allow parameters to be extracted.
+          writer_options = @options.merge(
+            accept_params: accept_params,
+            link: env['HTTP_LINK']
+          )
+          result, content_type = writer.dump(body, nil, **writer_options), ct.split(';').first
+          break
+        rescue ::RDF::WriterError
+          # Continue to next writer
+          ct
+        rescue
+          ct
+        end
+      end
+
+      if result
+        headers = headers.merge(VARY).merge('Content-Type' => content_type)
+        [status, headers, [result]]
+      else
+        not_acceptable
+      end
+    end
+
+    protected
+    ##
+    # Yields an `RDF::Writer` class for the given `env`.
+    #
+    # If options contain a `:format` key, it identifies the specific format to use;
+    # otherwise, if the environment has an HTTP_ACCEPT header, use it to find a writer;
+    # otherwise, use the default content type
+    #
+    # @param  [Hash{String => String}] env
+    # @param  [Hash{String => Object}] headers
+    # @yield |writer, content_type|
+    # @yield_param [RDF::Writer] writer
+    # @yield_param [String] content_type from accept media-range without parameters
+    # @yield_param [Hash{Symbol => String}] accept_params from accept media-range
+    # @see    http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html
+    def find_writer(env, headers)
+      if @options[:format]
+        format = @options[:format]
+        writer = ::RDF::Writer.for(format.to_sym)
+        yield(writer, writer.format.content_type.first) if writer
+      elsif env.has_key?('HTTP_ACCEPT')
+        content_types = parse_accept_header(env['HTTP_ACCEPT'])
+        content_types.each do |content_type|
+          find_writer_for_content_type(content_type) do |writer, ct, accept_params|
+            # Yields content type with parameters
+            yield(writer, ct, accept_params)
+          end
+        end
+      else
+        # 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]) do |writer, ct|
+          # Yields content type with parameters
+          yield(writer, ct)
+        end
+      end
+    end
+
+    ##
+    # Yields an `RDF::Writer` class for the given `content_type`.
+    #
+    # Calls `Writer#accept?(content_type)` for matched content type to allow writers to further discriminate on how if to accept content-type with specified parameters.
+    #
+    # @param  [String, #to_s] content_type
+    # @yield |writer, content_type|
+    # @yield_param [RDF::Writer] writer
+    # @yield_param [String] content_type (including media-type parameters)
+    def find_writer_for_content_type(content_type)
+      ct, *params = content_type.split(';').map(&:strip)
+      accept_params = params.inject({}) do |memo, pv|
+        p, v = pv.split('=').map(&:strip)
+        memo.merge(p.downcase.to_sym => v.sub(/^["']?([^"']*)["']?$/, '\1'))
+      end
+      formats = ::RDF::Format.each(content_type: ct, has_writer: true).to_a.reverse
+      formats.each do |format|
+        yield format.writer, (ct || format.content_type.first), accept_params if
+          format.writer.accept?(accept_params)
+      end
+    end
+
+    ##
+    # 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)
+      entries = header.to_s.split(',')
+      entries = entries.map { |e| accept_entry(e) }.sort_by(&:last).map(&:first)
+      entries.map { |e| find_content_type_for_media_range(e) }.flatten.compact
+    end
+
+    # Returns pair of content_type (including non-'q' parameters)
+    # and array of quality, number of '*' in content-type, and number of non-'q' parameters
+    def accept_entry(entry)
+      type, *options = entry.split(';').map(&:strip)
+      quality = 0 # we sort smallest first
+      options.delete_if { |e| quality = 1 - e[2..-1].to_f if e.start_with? 'q=' }
+      [options.unshift(type).join(';'), [quality, type.count('*'), 1 - options.size]]
+    end
+
+    ##
+    # Returns a content type appropriate for the given `media_range`,
+    # returns `nil` if `media_range` contains a wildcard subtype
+    # that is not mapped.
+    #
+    # @param  [String, #to_s] media_range
+    # @return [String, nil]
+    def find_content_type_for_media_range(media_range)
+      case media_range.to_s
+      when '*/*'
+        options[:default]
+      when 'text/*'
+        'text/turtle'
+      when 'application/*'
+        'application/ld+json'
+      when 'application/json'
+        'application/ld+json'
+      when 'application/xml'
+        'application/rdf+xml'
+      when /^([^\/]+)\/\*$/
+        nil
+      else
+        media_range.to_s
+      end
+    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"}.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::RDF

data/lib/rack/rdf/version.rb

@@ -0,0 +1,20 @@
+module Rack; module RDF
+  module VERSION
+    VERSION_FILE = ::File.expand_path("../../../../VERSION", __FILE__)
+    MAJOR, MINOR, TINY, EXTRA = ::File.read(VERSION_FILE).chomp.split(".")
+
+    STRING = [MAJOR, MINOR, TINY, EXTRA].compact.join('.')
+
+    ##
+    # @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

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: rack-rdf
+version: !ruby/object:Gem::Version
+  version: 3.1.0
+platform: ruby
+authors:
+- Arto Bendiken
+- Gregg Kellogg
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-02-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rdf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+description: Rack middleware for Linked Data content negotiation.
+email: public-rdf-ruby@w3.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- AUTHORS
+- CREDITS
+- README.md
+- UNLICENSE
+- VERSION
+- lib/rack/rdf.rb
+- lib/rack/rdf/conneg.rb
+- lib/rack/rdf/version.rb
+homepage: http://ruby-rdf.github.com/rack-rdf
+licenses:
+- Unlicense
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Linked Data content negotiation for Rack applications.
+test_files: []