rack-accept 0.3 → 0.4.1

data/.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name = 'rack-accept'
-  s.version = '0.3'
-  s.date = '2010-04-02'
+  s.version = '0.4.1'
+  s.date = '2010-04-05'
 
   s.summary = 'HTTP Accept* for Ruby/Rack'
   s.description = 'HTTP Accept, Accept-Charset, Accept-Encoding, and Accept-Language for Ruby/Rack'

data/CHANGES

@@ -1,3 +1,9 @@
+## 0.4 / April 5, 2010
+
+  * Added support for media type queries with multiple range parameters
+  * Changed Rack::Accept::Header#sort method to return only single values
+    and moved previous functionality to Rack::Accept::Header#sort_with_qvalues
+
 ## 0.3 / April 3, 2010
 
   * Enhanced Rack middleware component to be able to automatically send a 406

data/README

@@ -56,27 +56,25 @@ middleware pipeline and access the Rack::Accept::Request object in the
 
 Rack::Accept can also construct automatic 406 responses if you set up the types
 of media, character sets, encoding, or languages your server is able to serve
-ahead of time.
+ahead of time. If you pass a configuration block to your `use` statement it will
+yield the Rack::Accept::Context object that is used for that invocation.
 
     require 'rack/accept'
 
-    use(Rack::Accept) do |accept|
+    use(Rack::Accept) do |context|
       # We only ever serve content in English or Japanese from this site, so if
       # the user doesn't accept either of these we will respond with a 406.
-      #
-      # Note: +accept+ is an instance of Rack::Accept::Context.
-      accept.languages = %w< en jp >
+      context.languages = %w< en jp >
     end
 
     app = ...
 
     run app
 
-Note: You should probably think about this very carefully before you use
-Rack::Accept in this way. Many user agents are careless about the types of
-Accept headers they send, and depend on apps not being too picky. Instead of
-automatically sending a 406, you should probably only send one when absolutely
-necessary.
+Note: You should think carefully before using Rack::Accept in this way.
+Many user agents are careless about the types of Accept headers they send, and
+depend on apps not being too picky. Instead of automatically sending a 406, you
+should probably only send one when absolutely necessary.
 
 Additionally, Rack::Accept may be used outside of a Rack context to provide
 any Ruby app the ability to construct and interpret Accept headers.

data/doc/usage.markdown

@@ -3,7 +3,7 @@ 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][req] object in the
+middleware pipeline and access the [Request][req] object in the
 "rack-accept.request" environment key, as in the following example:
 
     require 'rack/accept'
@@ -27,29 +27,28 @@ middleware pipeline and access the [Rack::Accept::Request][req] object in the
 
     run app
 
-Rack::Accept can also construct a [406][406] response automatically if you set
-up the types of media, character sets, encoding, or languages your server is
-able to serve ahead of time.
+Rack::Accept can also construct automatic [406][406] responses if you set up
+the types of media, character sets, encoding, or languages your server is able
+to serve ahead of time. If you pass a configuration block to your `use`
+statement it will yield the [Context][ctx] object that is used for that
+invocation.
 
     require 'rack/accept'
 
-    use(Rack::Accept) do |accept|
+    use(Rack::Accept) do |context|
       # We only ever serve content in English or Japanese from this site, so if
       # the user doesn't accept either of these we will respond with a 406.
-      #
-      # Note: +accept+ is an instance of Rack::Accept::Context.
-      accept.languages = %w< en jp >
+      context.languages = %w< en jp >
     end
 
     app = ...
 
     run app
 
-__Note:__ You should probably think about this very carefully before you use
-Rack::Accept in this way. Many user agents are careless about the types of
-Accept headers they send, and depend on apps not being too picky. Instead of
-automatically sending a 406, you should probably only send one when absolutely
-necessary.
+__Note:__ You should think carefully before using Rack::Accept in this way.
+Many user agents are careless about the types of Accept headers they send, and
+depend on apps not being too picky. Instead of automatically sending a 406, you
+should probably only send one when absolutely necessary.
 
 Additionally, Rack::Accept may be used outside of a Rack context to provide
 any Ruby app the ability to construct and interpret Accept headers.
@@ -71,4 +70,5 @@ don't have to worry about these kinds of details.
 
 [req]: api/classes/Rack/Accept/Request.html
 [406]: http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7
+[ctx]: api/classes/Rack/Accept/Context.html
 [sec14-3]: http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.3

data/lib/rack/accept.rb

@@ -3,7 +3,7 @@ require 'rack'
 module Rack::Accept
 
   # The current version of rack-accept.
-  VERSION = [0, 3]
+  VERSION = [0, 4, 1]
 
   # Returns the current version of rack-accept as a string.
   def self.version

data/lib/rack/accept/charset.rb

@@ -21,7 +21,7 @@ module Rack::Accept
       if m.empty?
         charset == 'iso-8859-1' ? 1 : 0
       else
-        @qvalues[m.first]
+        normalize_qvalue(@qvalues[m.first])
       end
     end
 

data/lib/rack/accept/encoding.rb

@@ -21,7 +21,7 @@ module Rack::Accept
       if m.empty?
         encoding == 'identity' ? 1 : 0
       else
-        @qvalues[m.first]
+        normalize_qvalue(@qvalues[m.first])
       end
     end
 

data/lib/rack/accept/header.rb

@@ -16,7 +16,7 @@ module Rack::Accept
         m = /^([^\s,]+?)(?:;\s*q=(\d+(?:\.\d+)?))?$/.match(part) # From WEBrick
 
         if m
-          qvalues[m[1]] = (m[2] || 1).to_f
+          qvalues[m[1]] = normalize_qvalue((m[2] || 1).to_f)
         else
           raise "Invalid header value: #{part.inspect}"
         end
@@ -40,11 +40,29 @@ module Rack::Accept
     # 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 = 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
 
+    # Parses a string of media type range parameters into a hash of parameters
+    # to their respective values.
+    def parse_range_params(params)
+      params.split(';').inject({}) do |m, p|
+        k, v = p.split('=', 2)
+        m[k] = v if v
+        m
+      end
+    end
+    module_function :parse_range_params
+
+    # Converts 1.0 and 0.0 qvalues to 1 and 0 respectively. Used to maintain
+    # consistency across qvalue methods.
+    def normalize_qvalue(q)
+      (q == 1 || q == 0) && q.is_a?(Float) ? q.to_i : q
+    end
+    module_function :normalize_qvalue
+
     module PublicInstanceMethods
       # A table of all values of this header to their respective quality
       # factors (qvalues).
@@ -87,29 +105,37 @@ module Rack::Accept
       # 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
+      # It is important to note that this sort is a "stable sort". In other
+      # words, the order of the original values is preserved so long as the
+      # qvalue for each is the same. This expectation can be useful 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
+      # to the client and most convenient for him as well.
+      def sort_with_qvalues(values, keep_unacceptables=true)
+        qvalues = {}
+        values.each do |v|
+          q = qvalue(v)
+          if q != 0 || keep_unacceptables
+            qvalues[q] ||= []
+            qvalues[q] << v
+          end
+        end
+        order = qvalues.keys.sort.reverse
+        order.inject([]) {|m, q| m.concat(qvalues[q].map {|v| [q, v] }) }
       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.
+      # Sorts the given +values+ according to the qvalue of each while
+      # preserving the original order. See #sort_with_qvalues for more
+      # information on exactly how the sort is performed.
+      def sort(values, keep_unacceptables=false)
+        sort_with_qvalues(values, keep_unacceptables).map {|q, v| v }
+      end
+
+      # A shortcut for retrieving the first result of #sort.
       def best_of(values, keep_unacceptables=false)
-        s = sort(values)
-        s.reject! {|q, v| q == 0 } unless keep_unacceptables
-        s.first && s.first[1]
+        sort(values, keep_unacceptables).first
       end
 
       # Returns a string representation of this header.

data/lib/rack/accept/language.rb

@@ -20,7 +20,7 @@ module Rack::Accept
       return 1 if @qvalues.empty?
       m = matches(language)
       return 0 if m.empty?
-      @qvalues[m.first]
+      normalize_qvalue(@qvalues[m.first])
     end
 
     # Returns an array of languages from this header that match the given

data/lib/rack/accept/media_type.rb

@@ -20,7 +20,7 @@ module Rack::Accept
       return 1 if @qvalues.empty?
       m = matches(media_type)
       return 0 if m.empty?
-      @qvalues[m.first]
+      normalize_qvalue(@qvalues[m.first])
     end
 
     # Returns an array of media types from this header that match the given
@@ -32,7 +32,7 @@ module Rack::Accept
           true
         else
           t, s, p = parse_media_type(v)
-          t == type && (s == subtype || s == '*') && (p == params || p == '')
+          t == type && (s == '*' || s == subtype) && (p == '' || params_match?(params, p))
         end
       }.sort_by {|v|
         # Most specific gets precedence.
@@ -40,5 +40,14 @@ module Rack::Accept
       }.reverse
     end
 
+  private
+
+    # Returns true if all parameters and values in +match+ are also present in
+    # +params+.
+    def params_match?(params, match)
+      return true if params == match
+      parsed = parse_range_params(params)
+      parsed == parsed.merge(parse_range_params(match))
+    end
   end
 end

data/test/charset_test.rb

@@ -34,4 +34,12 @@ class CharsetTest < Test::Unit::TestCase
     assert_equal(%w{*}, c.matches('unicode-1-1'))
   end
 
+  def test_best_of
+    c = C.new('iso-8859-5, unicode-1-1;q=0.8')
+    assert_equal('iso-8859-5', c.best_of(%w< iso-8859-5 unicode-1-1 >))
+    assert_equal('iso-8859-5', c.best_of(%w< iso-8859-5 utf-8 >))
+    assert_equal('iso-8859-1', c.best_of(%w< iso-8859-1 utf-8 >))
+    assert_equal(nil, c.best_of(%w< utf-8 >))
+  end
+
 end

data/test/encoding_test.rb

@@ -21,4 +21,11 @@ class EncodingTest < Test::Unit::TestCase
     assert_equal(%w{*}, e.matches('compress'))
   end
 
+  def test_best_of
+    e = E.new('gzip, compress')
+    assert_equal('gzip', e.best_of(%w< gzip compress >))
+    assert_equal('identity', e.best_of(%w< identity compress >))
+    assert_equal(nil, e.best_of(%w< zip >))
+  end
+
 end

data/test/header_test.rb

@@ -43,7 +43,23 @@ class HeaderTest < Test::Unit::TestCase
     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', 'html', 'level=1;answer=42'], H.parse_media_type('text/html;level=1;answer=42'))
     assert_equal(['text', 'x-dvi', ''], H.parse_media_type('text/x-dvi'))
   end
 
+  def test_parse_range_params
+    assert_equal({}, H.parse_range_params(''))
+    assert_equal({}, H.parse_range_params('a'))
+    assert_equal({'a' => 'a'}, H.parse_range_params('a=a'))
+    assert_equal({'a' => 'a', 'b' => 'b'}, H.parse_range_params('a=a;b=b'))
+  end
+
+  def test_normalize_qvalue
+    assert_equal(1, H.normalize_qvalue(1.0))
+    assert_equal(0, H.normalize_qvalue(0.0))
+    assert_equal(1, H.normalize_qvalue(1))
+    assert_equal(0, H.normalize_qvalue(0))
+    assert_equal(0.5, H.normalize_qvalue(0.5))
+  end
+
 end

data/test/language_test.rb

@@ -26,4 +26,12 @@ class LanguageTest < Test::Unit::TestCase
     assert_equal(%w{en-gb en}, l.matches('en-gb'))
   end
 
+  def test_best_of
+    l = L.new('en;q=0.5, en-gb')
+    assert_equal('en-gb', l.best_of(%w< en en-gb >))
+    assert_equal('en', l.best_of(%w< en da >))
+    assert_equal('en-us', l.best_of(%w< en-us en-au >))
+    assert_equal(nil, l.best_of(%w< da >))
+  end
+
 end

data/test/media_type_test.rb

@@ -24,6 +24,19 @@ class MediaTypeTest < Test::Unit::TestCase
     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'))
+    assert_equal(%w{text/html;level=1 text/html text/* */*}, m.matches('text/html;level=1;answer=42'))
+  end
+
+  def test_best_of
+    m = M.new('text/*;q=0.5, text/html')
+    assert_equal('text/html', m.best_of(%w< text/plain text/html >))
+    assert_equal('text/plain', m.best_of(%w< text/plain image/png >))
+    assert_equal('text/plain', m.best_of(%w< text/plain text/javascript >))
+    assert_equal(nil, m.best_of(%w< image/png >))
+
+    m = M.new('text/*')
+    assert_equal('text/html', m.best_of(%w< text/html text/xml >))
+    assert_equal('text/xml', m.best_of(%w< text/xml text/html >))
   end
 
 end

data/test/request_test.rb

@@ -5,70 +5,47 @@ 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'))
+    r = R.new('HTTP_ACCEPT' => 'text/*;q=0, text/html')
+    assert(r.media_type?('text/html'))
+    assert(r.media_type?('text/html;level=1'))
+    assert(!r.media_type?('text/plain'))
+    assert(!r.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'))
+    r = R.new('HTTP_ACCEPT_CHARSET' => 'iso-8859-5, unicode-1-1;q=0.8')
+    assert(r.charset?('iso-8859-5'))
+    assert(r.charset?('unicode-1-1'))
+    assert(r.charset?('iso-8859-1'))
+    assert(!r.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 >))
+    r = R.new('HTTP_ACCEPT_CHARSET' => 'iso-8859-1;q=0')
+    assert(!r.charset?('iso-8859-1'))
   end
 
   def test_encoding
-    request = R.new('HTTP_ACCEPT_ENCODING' => '')
-    assert(request.encoding?('identity'))
-    assert(!request.encoding?('gzip'))
+    r = R.new('HTTP_ACCEPT_ENCODING' => '')
+    assert(r.encoding?('identity'))
+    assert(!r.encoding?('gzip'))
 
-    request = R.new('HTTP_ACCEPT_ENCODING' => 'gzip')
-    assert(request.encoding?('identity'))
-    assert(request.encoding?('gzip'))
-    assert(!request.encoding?('compress'))
+    r = R.new('HTTP_ACCEPT_ENCODING' => 'gzip')
+    assert(r.encoding?('identity'))
+    assert(r.encoding?('gzip'))
+    assert(!r.encoding?('compress'))
 
-    request = R.new('HTTP_ACCEPT_ENCODING' => 'gzip;q=0, *')
-    assert(request.encoding?('compress'))
-    assert(request.encoding?('identity'))
-    assert(!request.encoding?('gzip'))
+    r = R.new('HTTP_ACCEPT_ENCODING' => 'gzip;q=0, *')
+    assert(r.encoding?('compress'))
+    assert(r.encoding?('identity'))
+    assert(!r.encoding?('gzip'))
 
-    request = R.new('HTTP_ACCEPT_ENCODING' => 'identity;q=0')
-    assert(!request.encoding?('identity'))
+    r = R.new('HTTP_ACCEPT_ENCODING' => 'identity;q=0')
+    assert(!r.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 >))
+    r = R.new('HTTP_ACCEPT_ENCODING' => '*;q=0')
+    assert(!r.encoding?('identity'))
   end
 
   def test_language
@@ -82,12 +59,4 @@ class RequestTest < Test::Unit::TestCase
     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

@@ -4,8 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 3
-  version: "0.3"
+  - 4
+  - 1
+  version: 0.4.1
 platform: ruby
 authors: 
 - Michael J. I. Jackson
@@ -13,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-02 00:00:00 -06:00
+date: 2010-04-05 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency