rack-accept 0.1

data/CHANGES

@@ -0,0 +1,3 @@
+## 0.1 / April 2010
+
+  * Initial release

data/README

@@ -0,0 +1,70 @@
+Rack::Accept
+============
+
+rack-accept is a suite of tools for Rack/Ruby applications that eases the
+complexity of reading and writing Accept, Accept-Charset, Accept-Encoding, and
+Accept-Language HTTP request headers.
+
+Installation
+------------
+
+Using RubyGems:
+
+    $ sudo gem install rack-accept
+
+From a local copy:
+
+    $ git clone git://github.com/mjijackson/rack-accept.git
+    $ rake package && sudo rake install
+
+Usage
+-----
+
+rack-accept implements the Rack middleware interface and may be used with any
+Rack-based application. Simply insert the Rack::Accept module in your Rack
+middleware pipeline and access the Rack::Accept::Request object in the
+"rack-accept.request" environment key, as in the following example:
+
+    require 'rack/accept'
+
+    use Rack::Accept
+
+    app = lambda {|env|
+        accept = env['rack-accept.request']
+        response = Rack::Response.new
+
+        if accept.media_type?('text/html')
+            response['Content-Type'] = 'text/html'
+            response.write "<p>Hello. You accept text/html!</p>"
+        else
+            response['Content-Type'] = 'text/plain'
+            response.write "Apparently you don't accept text/html. Too bad."
+        end
+
+        response.finish
+    }
+
+    run app
+
+License
+-------
+
+Copyright 2010 Michael J. I. Jackson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+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 OR COPYRIGHT HOLDERS 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.

data/Rakefile

@@ -0,0 +1,78 @@
+require 'rake/clean'
+require 'rake/testtask'
+
+task :default => :test
+
+CLEAN.include %w< doc/api >
+CLOBBER.include %w< dist >
+
+# TESTS #######################################################################
+
+Rake::TestTask.new(:test) do |t|
+  t.test_files = FileList['test/*_test.rb']
+end
+
+# DOCS ########################################################################
+
+desc "Generate all documentation"
+task :doc => %w< doc:api doc:etc >
+
+namespace :doc do
+
+  desc "Generate API documentation (in doc/api)"
+  task :api => FileList['lib/**/*.rb'] do |t|
+    rm_rf 'doc/api'
+    sh((<<-SH).gsub(/[\s\n]+/, ' ').strip)
+    hanna
+      --op doc/api
+      --promiscuous
+      --charset utf8
+      --fmt html
+      --inline-source
+      --line-numbers
+      --accessor option_accessor=RW
+      --main Rack::Accept
+      --title 'Rack::Accept API Documentation'
+      #{t.prerequisites.join(' ')}
+    SH
+  end
+
+  desc "Generate extra documentation"
+  task :etc do
+  end
+
+end
+
+# PACKAGING ###################################################################
+
+if defined?(Gem)
+  $spec = eval("#{File.read('rack-accept.gemspec')}")
+
+  def package(ext='')
+    "dist/rack-accept-#{$spec.version}" + ext
+  end
+
+  desc "Build packages"
+  task :package => %w< .gem .tar.gz >.map {|e| package(e) }
+
+  desc "Build and install as local gem"
+  task :install => package('.gem') do
+    sh "gem install #{package('.gem')}"
+  end
+
+  directory 'dist/'
+
+  file package('.gem') => %w< dist/ rack-accept.gemspec > + $spec.files do |f|
+    sh "gem build rack-accept.gemspec"
+    mv File.basename(f.name), f.name
+  end
+
+  file package('.tar.gz') => %w< dist/ > + $spec.files do |f|
+    sh "git archive --format=tar HEAD | gzip > #{f.name}"
+  end
+
+  desc "Upload gem to rubygems.org"
+  task :release => package('.gem') do |t|
+    sh "gem push #{package('.gem')}"
+  end
+end

data/lib/rack/accept.rb

@@ -0,0 +1,24 @@
+module Rack::Accept
+
+  # The current version of rack-accept.
+  VERSION = [0, 1]
+
+  # Returns the current version of rack-accept as a string.
+  def self.version
+    VERSION.join('.')
+  end
+
+  # Enables Rack::Accept to be used as a Rack middleware.
+  def self.new(app, &block)
+    Context.new(app, &block)
+  end
+
+  autoload :Charset,    'rack/accept/charset'
+  autoload :Context,    'rack/accept/context'
+  autoload :Encoding,   'rack/accept/encoding'
+  autoload :Header,     'rack/accept/header'
+  autoload :Language,   'rack/accept/language'
+  autoload :MediaType,  'rack/accept/media_type'
+  autoload :Request,    'rack/accept/request'
+
+end

data/lib/rack/accept/charset.rb

@@ -0,0 +1,63 @@
+module Rack::Accept
+
+  # Represents an HTTP Accept-Charset header according to the HTTP 1.1
+  # specification, and provides several convenience methods for determining
+  # acceptable character sets.
+  #
+  # See http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html for more
+  # information.
+  class Charset
+
+    include Header
+
+    attr_reader :qvalues
+
+    def initialize(header)
+      @qvalues = parse(header)
+    end
+
+    # The name of this header.
+    def name
+      'Accept-Charset'
+    end
+
+    # The value of this header, built from its internal representation.
+    def value
+      join(@qvalues)
+    end
+
+    # Returns an array of all character set values that were specified in the
+    # original header, in no particular order.
+    def values
+      @qvalues.keys
+    end
+
+    # Determines the quality factor (qvalue) of the given +charset+,
+    # according to the specifications of the original header.
+    def qvalue(charset)
+      m = matches(charset)
+      if m.empty?
+        charset == 'iso-8859-1' ? 1 : 0
+      else
+        @qvalues[m.first]
+      end
+    end
+
+    # Returns an array of character sets from the original header that match
+    # the given +charset+, ordered by precedence.
+    def matches(charset)
+      values.select {|v|
+        v == charset || v == '*'
+      }.sort {|a, b|
+        # "*" gets least precedence, any others should be equal.
+        a == '*' ? 1 : (b == '*' ? -1 : 0)
+      }
+    end
+
+    # Returns a string representation of this header.
+    def to_s
+      [name, value].join(': ')
+    end
+
+  end
+end

data/lib/rack/accept/context.rb

@@ -0,0 +1,21 @@
+module Rack::Accept
+
+  # Implements the Rack middleware interface.
+  class Context
+
+    attr_reader :app
+
+    def initialize(app)
+      @app = app
+      yield self if block_given?
+    end
+
+    # Inserts a new Rack::Accept::Request object into the environment before
+    # handing the request to the app immediately downstream.
+    def call(env)
+      env['rack-accept.request'] ||= Request.new(env)
+      @app.call(env)
+    end
+
+  end
+end

data/lib/rack/accept/encoding.rb

@@ -0,0 +1,63 @@
+module Rack::Accept
+
+  # Represents an HTTP Accept-Encoding header according to the HTTP 1.1
+  # specification, and provides several convenience methods for determining
+  # acceptable content encodings.
+  #
+  # See http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html for more
+  # information.
+  class Encoding
+
+    include Header
+
+    attr_reader :qvalues
+
+    def initialize(header)
+      @qvalues = parse(header)
+    end
+
+    # The name of this header.
+    def name
+      'Accept-Encoding'
+    end
+
+    # The value of this header, built from its internal representation.
+    def value
+      join(@qvalues)
+    end
+
+    # Returns an array of all encoding values that were specified in the
+    # original header, in no particular order.
+    def values
+      @qvalues.keys
+    end
+
+    # Determines the quality factor (qvalue) of the given +encoding+,
+    # according to the specifications of the original header.
+    def qvalue(encoding)
+      m = matches(encoding)
+      if m.empty?
+        encoding == 'identity' ? 1 : 0
+      else
+        @qvalues[m.first]
+      end
+    end
+
+    # Returns an array of encodings from the original header that match
+    # the given +encoding+, ordered by precedence.
+    def matches(encoding)
+      values.select {|v|
+        v == encoding || v == '*'
+      }.sort {|a, b|
+        # "*" gets least precedence, any others should be equal.
+        a == '*' ? 1 : (b == '*' ? -1 : 0)
+      }
+    end
+
+    # Returns a string representation of this header.
+    def to_s
+      [name, value].join(': ')
+    end
+
+  end
+end

data/lib/rack/accept/header.rb

@@ -0,0 +1,96 @@
+module Rack::Accept
+
+  # Contains methods that are useful for working with Accept-style HTTP
+  # headers. The MediaType, Charset, Encoding, and Language classes all mixin
+  # this module.
+  module Header
+
+    # Parses the value of an Accept-style request header into a hash of
+    # acceptable values and their respective quality factors (qvalues). The
+    # +join+ method may be used on the resulting hash to obtain a header
+    # string that is the semantic equivalent of the one provided.
+    def parse(header)
+      qvalues = {}
+
+      header.to_s.split(/,\s*/).map do |part|
+        m = /^([^\s,]+?)(?:;\s*q=(\d+(?:\.\d+)?))?$/.match(part) # From WEBrick
+
+        if m
+          qvalues[m[1]] = (m[2] || 1).to_f
+        else
+          raise "Invalid header value: #{part.inspect}"
+        end
+      end
+
+      qvalues
+    end
+    module_function :parse
+
+    # Returns a string suitable for use as the value of an Accept-style HTTP
+    # header from the map of acceptable values to their respective quality
+    # factors (qvalues). The +parse+ method may be used on the resulting string
+    # to obtain a hash that is the equivalent of the one provided.
+    def join(qvalues)
+      qvalues.map {|k, v| k + (v == 1 ? '' : ";q=#{v}") }.join(', ')
+    end
+    module_function :join
+
+    # Parses a media type string into its relevant pieces. The return value
+    # will be an array with three values: 1) the content type, 2) the content
+    # subtype, and 3) the media type parameters. An empty array is returned if
+    # no match can be made.
+    def parse_media_type(media_type)
+      m = media_type.to_s.match(/^([a-z*]+)\/([a-z*-]+)(?:;([a-z0-9=]+))?$/)
+      m ? [m[1], m[2], m[3] || ''] : []
+    end
+    module_function :parse_media_type
+
+    module PublicInstanceMethods
+      # Returns the quality factor (qvalue) of the given +value+. This method
+      # is the only method that must be overridden in child classes in order
+      # for them to be able to use all other methods of this module.
+      def qvalue(value)
+        1
+      end
+
+      # Determines if the given +value+ is acceptable (does not have a qvalue
+      # of 0) according to this header.
+      def accept?(value)
+        qvalue(value) != 0
+      end
+
+      # Returns a copy of the given +values+ array, sorted by quality factor
+      # (qvalue). Each element of the returned array is itself an array
+      # containing two objects: 1) the value's qvalue and 2) the original
+      # value.
+      #
+      # It is important to note that when performing this sort the order of
+      # the original values is preserved so long as the qvalue for each input
+      # value is the same. This expectation can be useful for example when
+      # trying to determine which of a variety of options has the highest
+      # qvalue. If the user prefers using one option over another (for any
+      # number of reasons), he should put it first in +values+. He may then
+      # use the first result with confidence that it is both most acceptable
+      # to the user and most convenient for him as well.
+      def sort(values)
+        values.map {|v| [ qvalue(v), v ] }.sort.reverse
+      end
+
+      # Determines the most preferred value to use of those provided in
+      # +values+. See the documentation for #sort for more information on
+      # exactly how the sorting is done.
+      #
+      # If +keep_unacceptables+ is false (the default) and no values are
+      # acceptable the return value will be +nil+. Otherwise, the most
+      # acceptable value will be returned.
+      def best_of(values, keep_unacceptables=false)
+        s = sort(values)
+        s.reject! {|q, v| q == 0 } unless keep_unacceptables
+        s.first && s.first[1]
+      end
+    end
+
+    include PublicInstanceMethods
+
+  end
+end

data/lib/rack/accept/language.rb

@@ -0,0 +1,61 @@
+module Rack::Accept
+
+  # Represents an HTTP Accept-Language header according to the HTTP 1.1
+  # specification, and provides several convenience methods for determining
+  # acceptable content languages.
+  #
+  # See http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html for more
+  # information.
+  class Language
+
+    include Header
+
+    attr_reader :qvalues
+
+    def initialize(header)
+      @qvalues = parse(header)
+    end
+
+    # The name of this header.
+    def name
+      'Accept-Language'
+    end
+
+    # The value of this header, built from its internal representation.
+    def value
+      join(@qvalues)
+    end
+
+    # Returns an array of all language values that were specified in the
+    # original header, in no particular order.
+    def values
+      @qvalues.keys
+    end
+
+    # Determines the quality factor (qvalue) of the given +language+,
+    # according to the specifications of the original header.
+    def qvalue(language)
+      return 1 if @qvalues.empty?
+      m = matches(language)
+      return 0 if m.empty?
+      @qvalues[m.first]
+    end
+
+    # Returns an array of languages from the original header that match
+    # the given +language+, ordered by precedence.
+    def matches(language)
+      values.select {|v|
+        v == language || v == '*' || (language.match(/^(.+?)-/) && v == $1)
+      }.sort {|a, b|
+        # "*" gets least precedence, any others are compared based on length.
+        a == '*' ? -1 : (b == '*' ? 1 : a.length <=> b.length)
+      }.reverse
+    end
+
+    # Returns a string representation of this header.
+    def to_s
+      [name, value].join(': ')
+    end
+
+  end
+end

data/lib/rack/accept/media_type.rb

@@ -0,0 +1,67 @@
+module Rack::Accept
+
+  # Represents an HTTP Accept header according to the HTTP 1.1 specification,
+  # and provides several convenience methods for determining acceptable media
+  # types.
+  #
+  # See http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html for more
+  # information.
+  class MediaType
+
+    include Header
+
+    attr_reader :qvalues
+
+    def initialize(header)
+      @qvalues = parse(header)
+    end
+
+    # The name of this header.
+    def name
+      'Accept'
+    end
+
+    # The value of this header, built from its internal representation.
+    def value
+      join(@qvalues)
+    end
+
+    # Returns an array of all media type values that were specified in the
+    # original header, in no particular order.
+    def values
+      @qvalues.keys
+    end
+
+    # Determines the quality factor (qvalue) of the given +media_type+,
+    # according to the specifications of the original header.
+    def qvalue(media_type)
+      return 1 if @qvalues.empty?
+      m = matches(media_type)
+      return 0 if m.empty?
+      @qvalues[m.first]
+    end
+
+    # Returns an array of media types from the original header that match
+    # the given +media_type+, ordered by precedence.
+    def matches(media_type)
+      type, subtype, params = parse_media_type(media_type)
+      values.select {|v|
+        if v == media_type || v == '*/*'
+          true
+        else
+          t, s, p = parse_media_type(v)
+          t == type && (s == subtype || s == '*') && (p == params || p == '')
+        end
+      }.sort_by {|v|
+        # Most specific gets precedence.
+        v.length
+      }.reverse
+    end
+
+    # Returns a string representation of this header.
+    def to_s
+      [name, value].join(': ')
+    end
+
+  end
+end

data/lib/rack/accept/request.rb

@@ -0,0 +1,96 @@
+module Rack::Accept
+
+  # A container class for convenience methods when rack-accept is used on the
+  # request level (as a Rack middleware, for example). This class manages a
+  # lightweight cache of various header instances to speed up execution.
+  #
+  # This class currently does not extend Rack::Request because that class
+  # currently provides some limited functionality when it comes to determining
+  # the proper encoding to use with a request and I didn't want to confuse the
+  # user.
+  class Request
+
+    attr_reader :env
+
+    def initialize(env)
+      @env = env
+    end
+
+    # Provides access to the Rack::Accept::MediaType instance for this request.
+    def media_type
+      @media_type ||= MediaType.new(env['HTTP_ACCEPT'])
+    end
+
+    # Provides access to the Rack::Accept::Charset instance for this request.
+    def charset
+      @charset ||= Charset.new(env['HTTP_ACCEPT_CHARSET'])
+    end
+
+    # Provides access to the Rack::Accept::Encoding instance for this request.
+    def encoding
+      @encoding ||= Encoding.new(env['HTTP_ACCEPT_ENCODING'])
+    end
+
+    # Provides access to the Rack::Accept::Language instance for this request.
+    def language
+      @language ||= Language.new(env['HTTP_ACCEPT_LANGUAGE'])
+    end
+
+    # Returns true if the +Accept+ request header indicates the given media
+    # type is acceptable, false otherwise.
+    def media_type?(value)
+      media_type.accept?(value)
+    end
+
+    # Returns true if the +Accept-Charset+ request header indicates the given
+    # character set is acceptable, false otherwise.
+    def charset?(value)
+      charset.accept?(value)
+    end
+
+    # Returns true if the +Accept-Encoding+ request header indicates the given
+    # encoding is acceptable, false otherwise.
+    def encoding?(value)
+      encoding.accept?(value)
+    end
+
+    # Returns true if the +Accept-Language+ request header indicates the given
+    # language is acceptable, false otherwise.
+    def language?(value)
+      language.accept?(value)
+    end
+
+    # Determines the best media type to use in a response from the given media
+    # types, if any is acceptable. For more information on how this value is
+    # determined, see the documentation for
+    # Rack::Accept::Header::PublicInstanceMethods#sort.
+    def best_media_type(values)
+      media_type.best_of(values)
+    end
+
+    # Determines the best character set to use in a response from the given
+    # character sets, if any is acceptable. For more information on how this
+    # value is determined, see the documentation for
+    # Rack::Accept::Header::PublicInstanceMethods#sort.
+    def best_charset(values)
+      charset.best_of(values)
+    end
+
+    # Determines the best encoding to use in a response from the given
+    # encodings, if any is acceptable. For more information on how this value
+    # is determined, see the documentation for
+    # Rack::Accept::Header::PublicInstanceMethods#sort.
+    def best_encoding(values)
+      encoding.best_of(values)
+    end
+
+    # Determines the best language to use in a response from the given
+    # languages, if any is acceptable. For more information on how this value
+    # is determined, see the documentation for
+    # Rack::Accept::Header::PublicInstanceMethods#sort.
+    def best_language(values)
+      language.best_of(values)
+    end
+
+  end
+end

data/rack-accept.gemspec

@@ -0,0 +1,29 @@
+Gem::Specification.new do |s|
+  s.name = 'rack-accept'
+  s.version = '0.1'
+  s.date = '2010-04-01'
+
+  s.summary = 'HTTP Accept* tools for Rack'
+  s.description = 'HTTP Accept, Accept-Charset, Accept-Encoding, and Accept-Language tools for Rack'
+
+  s.author = 'Michael J. I. Jackson'
+  s.email = 'mjijackson@gmail.com'
+
+  s.require_paths = %w< lib >
+
+  s.files = Dir['lib/**/*.rb'] +
+    Dir['test/*.rb'] +
+    %w< CHANGES rack-accept.gemspec Rakefile README >
+
+  s.test_files = s.files.select {|path| path =~ /^test\/.*_test.rb/ }
+
+  s.add_dependency('rack', '>= 0.4')
+  s.add_development_dependency 'rake'
+
+  s.has_rdoc = true
+  s.rdoc_options = %w< --line-numbers --inline-source --title Rack::Accept --main Rack::Accept >
+  s.extra_rdoc_files = %w< CHANGES README >
+
+  s.homepage = 'http://github.com/mjijackson/rack-accept'
+
+end

data/test/charset_test.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/helper'
+
+class CharsetTest < Test::Unit::TestCase
+
+  C = Rack::Accept::Charset
+
+  def test_qvalue
+    c = C.new('')
+    assert_equal(0, c.qvalue('unicode-1-1'))
+    assert_equal(1, c.qvalue('iso-8859-1'))
+
+    c = C.new('unicode-1-1')
+    assert_equal(1, c.qvalue('unicode-1-1'))
+    assert_equal(0, c.qvalue('iso-8859-5'))
+    assert_equal(1, c.qvalue('iso-8859-1'))
+
+    c = C.new('unicode-1-1, *;q=0.5')
+    assert_equal(1, c.qvalue('unicode-1-1'))
+    assert_equal(0.5, c.qvalue('iso-8859-5'))
+    assert_equal(0.5, c.qvalue('iso-8859-1'))
+
+    c = C.new('iso-8859-1;q=0, *;q=0.5')
+    assert_equal(0.5, c.qvalue('iso-8859-5'))
+    assert_equal(0, c.qvalue('iso-8859-1'))
+  end
+
+  def test_matches
+    c = C.new('iso-8859-1, iso-8859-5, *')
+    assert_equal(%w{*}, c.matches(''))
+    assert_equal(%w{iso-8859-1 *}, c.matches('iso-8859-1'))
+    assert_equal(%w{*}, c.matches('unicode-1-1'))
+  end
+
+end

data/test/encoding_test.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/helper'
+
+class EncodingTest < Test::Unit::TestCase
+
+  E = Rack::Accept::Encoding
+
+  def test_qvalue
+    e = E.new('')
+    assert_equal(0, e.qvalue('gzip'))
+    assert_equal(1, e.qvalue('identity'))
+
+    e = E.new('gzip, *;q=0.5')
+    assert_equal(1, e.qvalue('gzip'))
+    assert_equal(0.5, e.qvalue('identity'))
+  end
+
+  def test_matches
+    e = E.new('gzip, identity, *')
+    assert_equal(%w{*}, e.matches(''))
+    assert_equal(%w{gzip *}, e.matches('gzip'))
+    assert_equal(%w{*}, e.matches('compress'))
+  end
+
+end

data/test/header_test.rb

@@ -0,0 +1,49 @@
+require File.dirname(__FILE__) + '/helper'
+
+class HeaderTest < Test::Unit::TestCase
+
+  H = Rack::Accept::Header
+
+  def test_parse_and_join
+    # Accept
+    header = 'text/plain; q=0.5, text/html, text/html;level=2, text/html;level=1;q=0.3, text/x-c, image/*; q=0.2'
+    expect = {
+      'text/plain'        => 0.5,
+      'text/html'         => 1,
+      'text/html;level=2' => 1,
+      'text/html;level=1' => 0.3,
+      'text/x-c'          => 1,
+      'image/*'           => 0.2
+    }
+    assert_equal(expect, H.parse(header))
+    assert_equal(expect, H.parse(H.join(expect)))
+
+    # Accept-Charset
+    header = 'iso-8859-5, unicode-1-1;q=0.8'
+    expect = { 'iso-8859-5' => 1, 'unicode-1-1' => 0.8 }
+    assert_equal(expect, H.parse(header))
+    assert_equal(expect, H.parse(H.join(expect)))
+
+    # Accept-Encoding
+    header = 'gzip;q=1.0, identity; q=0.5, *;q=0'
+    expect = { 'gzip' => 1, 'identity' => 0.5, '*' => 0 }
+    assert_equal(expect, H.parse(header))
+    assert_equal(expect, H.parse(H.join(expect)))
+
+    # Accept-Language
+    header = 'da, en-gb;q=0.8, en;q=0.7'
+    expect = { 'da' => 1, 'en-gb' => 0.8, 'en' => 0.7 }
+    assert_equal(expect, H.parse(header))
+    assert_equal(expect, H.parse(H.join(expect)))
+  end
+
+  def test_parse_media_type
+    assert_equal([], H.parse_media_type(''))
+    assert_equal(['*', '*', ''], H.parse_media_type('*/*'))
+    assert_equal(['text', '*', ''], H.parse_media_type('text/*'))
+    assert_equal(['text', 'html', ''], H.parse_media_type('text/html'))
+    assert_equal(['text', 'html', 'level=1'], H.parse_media_type('text/html;level=1'))
+    assert_equal(['text', 'x-dvi', ''], H.parse_media_type('text/x-dvi'))
+  end
+
+end

data/test/helper.rb

@@ -0,0 +1,17 @@
+ENV['RACK_ENV'] = 'test'
+
+begin
+  require 'rack'
+rescue LoadError
+  require 'rubygems'
+  require 'rack'
+end
+
+testdir = File.dirname(__FILE__)
+$LOAD_PATH.unshift(testdir) unless $LOAD_PATH.include?(testdir)
+
+libdir = File.dirname(File.dirname(__FILE__)) + '/lib'
+$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
+
+require 'test/unit'
+require 'rack/accept'

data/test/language_test.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/helper'
+
+class LanguageTest < Test::Unit::TestCase
+
+  L = Rack::Accept::Language
+
+  def test_qvalue
+    l = L.new('')
+    assert_equal(1, l.qvalue('en'))
+
+    l = L.new('en;q=0.5, en-gb')
+    assert_equal(0.5, l.qvalue('en'))
+    assert_equal(1, l.qvalue('en-gb'))
+    assert_equal(0, l.qvalue('da'))
+  end
+
+  def test_matches
+    l = L.new('da, *, en')
+    assert_equal(%w{*}, l.matches(''))
+    assert_equal(%w{da *}, l.matches('da'))
+    assert_equal(%w{en *}, l.matches('en'))
+    assert_equal(%w{en *}, l.matches('en-gb'))
+    assert_equal(%w{*}, l.matches('eng'))
+
+    l = L.new('en, en-gb')
+    assert_equal(%w{en-gb en}, l.matches('en-gb'))
+  end
+
+end

data/test/media_type_test.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/helper'
+
+class MediaTypeTest < Test::Unit::TestCase
+
+  M = Rack::Accept::MediaType
+
+  def test_qvalue
+    m = M.new('text/html, text/*;q=0.3, */*;q=0.5')
+    assert_equal(0.5, m.qvalue('image/png'))
+    assert_equal(0.3, m.qvalue('text/plain'))
+    assert_equal(1, m.qvalue('text/html'))
+
+    m = M.new('text/html')
+    assert_equal(0, m.qvalue('image/png'))
+
+    m = M.new('')
+    assert_equal(1, m.qvalue('text/html'))
+  end
+
+  def test_matches
+    m = M.new('text/*, text/html, text/html;level=1, */*')
+    assert_equal(%w{*/*}, m.matches(''))
+    assert_equal(%w{*/*}, m.matches('image/jpeg'))
+    assert_equal(%w{text/* */*}, m.matches('text/plain'))
+    assert_equal(%w{text/html text/* */*}, m.matches('text/html'))
+    assert_equal(%w{text/html;level=1 text/html text/* */*}, m.matches('text/html;level=1'))
+  end
+
+end

data/test/request_test.rb

@@ -0,0 +1,93 @@
+require File.dirname(__FILE__) + '/helper'
+
+class RequestTest < Test::Unit::TestCase
+
+  R = Rack::Accept::Request
+
+  def test_media_type
+    request = R.new('HTTP_ACCEPT' => 'text/*;q=0, text/html')
+    assert(request.media_type?('text/html'))
+    assert(request.media_type?('text/html;level=1'))
+    assert(!request.media_type?('text/plain'))
+    assert(!request.media_type?('image/png'))
+
+    request = R.new('HTTP_ACCEPT' => '*/*')
+    assert(request.media_type?('image/png'))
+  end
+
+  def test_best_media_type
+    request = R.new('HTTP_ACCEPT' => 'text/*;q=0.5, text/html')
+    assert_equal('text/html', request.best_media_type(%w< text/plain text/html >))
+    assert_equal('text/plain', request.best_media_type(%w< text/plain image/png >))
+    assert_equal('text/plain', request.best_media_type(%w< text/plain text/javascript >))
+    assert_equal(nil, request.best_media_type(%w< image/png >))
+  end
+
+  def test_charset
+    request = R.new('HTTP_ACCEPT_CHARSET' => 'iso-8859-5, unicode-1-1;q=0.8')
+    assert(request.charset?('iso-8859-5'))
+    assert(request.charset?('unicode-1-1'))
+    assert(request.charset?('iso-8859-1'))
+    assert(!request.charset?('utf-8'))
+
+    request = R.new('HTTP_ACCEPT_CHARSET' => 'iso-8859-1;q=0')
+    assert(!request.charset?('iso-8859-1'))
+  end
+
+  def test_best_charset
+    request = R.new('HTTP_ACCEPT_CHARSET' => 'iso-8859-5, unicode-1-1;q=0.8')
+    assert_equal('iso-8859-5', request.best_charset(%w< iso-8859-5 unicode-1-1 >))
+    assert_equal('iso-8859-5', request.best_charset(%w< iso-8859-5 utf-8 >))
+    assert_equal('iso-8859-1', request.best_charset(%w< iso-8859-1 utf-8 >))
+    assert_equal(nil, request.best_charset(%w< utf-8 >))
+  end
+
+  def test_encoding
+    request = R.new('HTTP_ACCEPT_ENCODING' => '')
+    assert(request.encoding?('identity'))
+    assert(!request.encoding?('gzip'))
+
+    request = R.new('HTTP_ACCEPT_ENCODING' => 'gzip')
+    assert(request.encoding?('identity'))
+    assert(request.encoding?('gzip'))
+    assert(!request.encoding?('compress'))
+
+    request = R.new('HTTP_ACCEPT_ENCODING' => 'gzip;q=0, *')
+    assert(request.encoding?('compress'))
+    assert(request.encoding?('identity'))
+    assert(!request.encoding?('gzip'))
+
+    request = R.new('HTTP_ACCEPT_ENCODING' => 'identity;q=0')
+    assert(!request.encoding?('identity'))
+
+    request = R.new('HTTP_ACCEPT_ENCODING' => '*;q=0')
+    assert(!request.encoding?('identity'))
+  end
+
+  def test_best_encoding
+    request = R.new('HTTP_ACCEPT_ENCODING' => 'gzip, compress')
+    assert_equal('gzip', request.best_encoding(%w< gzip compress >))
+    assert_equal('identity', request.best_encoding(%w< identity compress >))
+    assert_equal(nil, request.best_encoding(%w< zip >))
+  end
+
+  def test_language
+    request = R.new({})
+    assert(request.language?('en'))
+    assert(request.language?('da'))
+
+    request = R.new('HTTP_ACCEPT_LANGUAGE' => 'en;q=0.5, en-gb')
+    assert(request.language?('en'))
+    assert(request.language?('en-gb'))
+    assert(!request.language?('da'))
+  end
+
+  def test_best_language
+    request = R.new('HTTP_ACCEPT_LANGUAGE' => 'en;q=0.5, en-gb')
+    assert_equal('en-gb', request.best_language(%w< en en-gb >))
+    assert_equal('en', request.best_language(%w< en da >))
+    assert_equal('en-us', request.best_language(%w< en-us en-au >))
+    assert_equal(nil, request.best_language(%w< da >))
+  end
+
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification 
+name: rack-accept
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- Michael J. I. Jackson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-01 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 4
+        version: "0.4"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: HTTP Accept, Accept-Charset, Accept-Encoding, and Accept-Language tools for Rack
+email: mjijackson@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- CHANGES
+- README
+files: 
+- lib/rack/accept/charset.rb
+- lib/rack/accept/context.rb
+- lib/rack/accept/encoding.rb
+- lib/rack/accept/header.rb
+- lib/rack/accept/language.rb
+- lib/rack/accept/media_type.rb
+- lib/rack/accept/request.rb
+- lib/rack/accept.rb
+- test/charset_test.rb
+- test/encoding_test.rb
+- test/header_test.rb
+- test/helper.rb
+- test/language_test.rb
+- test/media_type_test.rb
+- test/request_test.rb
+- CHANGES
+- rack-accept.gemspec
+- Rakefile
+- README
+has_rdoc: true
+homepage: http://github.com/mjijackson/rack-accept
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Rack::Accept
+- --main
+- Rack::Accept
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: HTTP Accept* tools for Rack
+test_files: 
+- test/charset_test.rb
+- test/encoding_test.rb
+- test/header_test.rb
+- test/language_test.rb
+- test/media_type_test.rb
+- test/request_test.rb