wants 1.0.0

data/README.md

@@ -0,0 +1,135 @@
+## Wants
+
+This library provides support for choosing the proper MIME type for a
+response.
+
+### Installation
+
+With Rubygems:
+
+```ruby
+gem install wants
+```
+
+With Bundler:
+
+```ruby
+gem 'wants'
+```
+
+### Loading
+
+Simply require the gem name:
+
+```ruby
+require 'wants'
+```
+
+### Usage
+
+#### `Wants.new`
+
+```ruby
+wants = Wants.new( accept, [ :html, :json, :atom ] )
+```
+
+The `Wants` constructor takes two arguments:
+
+ * The value of an HTTP Accept header. cf
+   [RFC 2616, §14.1](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.1)
+ * an `Array` of all the supported MIME types, each of which can be a full
+   type (e.g. `"application/json"`) or, if `Rack` is loaded, a key in
+   [`Rack::Mime::MIME_TYPES`](https://github.com/rack/rack/blob/master/lib/rack/mime.rb).
+   (If you want to use a different lookup table, you can set `Wants.mime_lookup_table`.)
+
+`Wants.new` will return to you a `Wants::MatchResult` object that represents the
+single best MIME type from the available options. It supports a variety of
+introspection methods:
+
+#### `MatchResult#not_acceptable?`
+
+This predicate tell you whether there was no acceptable match. For example,
+
+```ruby
+wants = Wants.new( { 'application/json' }, [ :html ] )
+wants.not_acceptable? # true
+```
+
+This method is aliased as `#blank?` and its inverse is available as `#present?`.
+
+#### `MatchResult#{mime}?`
+
+You can use a MIME abbreviation as a query method on the matcher. For example,
+
+```ruby
+acceptable = 'text/html,application/xhtml+xml;q=0.9'
+offered = [ :html, :json ]
+wants = Wants.new( acceptable, offered )
+wants.html?  # true
+wants.xhtml? # false
+wants.json?  # false
+```
+
+#### `MatchResult#[{mime}]`
+
+To query a full MIME type, use `#[]`. For example,
+
+```ruby
+acceptable = 'text/html,application/xhtml+xml;q=0.9'
+offered = [ :html, :json ]
+wants = Wants.new( acceptable, offered )
+wants[:html]                    # true
+wants['text/html']              # true
+wants['application/xhtml_xml']  # false
+wants['application/json']       # false
+```
+
+#### `MatchResult#{mime}`
+
+Lastly, you can use the matcher as DSL. For example,
+
+```ruby
+acceptable = 'application/json,application/javascript;q=0.8'
+offered = [ :html, :json ]
+wants = Wants.new( acceptable, offered )
+
+wants.atom           { build_an_atom_response }
+wants.json           { build_a_json_response }
+wants.html           { build_an_html_response }
+wants.not_acceptable { build_a_406_unacceptable_response }
+wants.any            { build_a_generic_response }
+```
+
+In this example, only `build_a_json_response` will be evaluated. `wants.json`
+and all subsequent `wants.{mime}` calls, including `wants.not_acceptable` and
+`wants.any`, will return whatever `build_a_json_response` returned.
+More formally, each `wants.{mime}` call behaves as follows:
+
+ 1. if `@response_value` is not `nil`, return it
+ 1. if [method name] is the abbreviation for the desired MIME type,
+    evaluate the block and set the result to `@response_value`
+
+`wants.not_acceptable` will match if `wants.not_acceptable?` returns `true`.
+`wants.any` will match if `wants.not_acceptable?` returns `false`. Thus,
+`wants.any` should be placed after all other matchers.
+
+#### `Wants::ValidateAcceptsMiddleware`
+
+Usage in `config.ru`:
+
+```ruby
+require 'wants/validate_accepts_middleware'
+
+use Wants::ValidateAcceptsMiddleware, :mime_types => [ :html, :json ]
+run MyApp
+```
+
+This will pass HTML and JSON requests down to `MyApp` and return a
+406 Not Acceptable response for all others. You can configure the
+failure case with the `:on_not_acceptable` option:
+
+```ruby
+use Wants::ValidateAcceptsMiddleware,
+  :mime_types => [ ... ],
+  :on_not_acceptable => lambda { |env| ... }
+```

data/lib/wants/match_result.rb

@@ -0,0 +1,70 @@
+require 'wants/mimeparse'
+
+module Wants
+  class MatchResult
+
+    def initialize(accept_header, acceptable)
+      @accept     = accept_header || ''
+      @acceptable = acceptable.map { |mime| parse_mime(mime) }
+      @best_match = MIMEParse.best_match(@acceptable, @accept)
+    end
+
+    def not_acceptable?
+      @best_match.nil?
+    end
+
+    def blank?
+      not_acceptable?
+    end
+
+    def present?
+      !blank?
+    end
+
+    def [](mime)
+      @best_match == parse_mime(mime)
+    end
+
+    def any(&block)
+      @response_value ||= block.call if present?
+    end
+
+    def not_acceptable(&block)
+      @response_value ||= block.call if blank?
+    end
+
+    def method_missing(method, *args, &block)
+      if mime = mime_abbreviation_from_method(method)
+        if args.length > 0
+          raise ArgumentError, "wrong number of arguments (#{args.length} for 0)"
+        end
+        if method =~ /\?$/
+          self[mime]
+        elsif self[mime]
+          @response_value ||= block.call
+        else
+          @response_value
+        end
+      else
+        super
+      end
+    end
+
+    def respond_to?(method)
+      return true if mime_abbreviation_from_method(method)
+      super
+    end
+
+    private
+
+    def parse_mime(mime)
+      Wants.mime_lookup_table[".#{mime}"] || mime.to_s
+    end
+
+    def mime_abbreviation_from_method(method)
+      md = /([^\?]+)\??$/.match(method)
+      md && Wants.mime_lookup_table[".#{md[1]}"]
+    end
+
+  end
+end

data/lib/wants/mimeparse.rb

@@ -0,0 +1,217 @@
+module Wants
+  # From http://code.google.com/p/mimeparse
+  #
+  # This module provides basic functions for handling mime-types. It can
+  # handle matching mime-types against a list of media-ranges. See section
+  # 14.1 of the HTTP specification [RFC 2616] for a complete explanation.
+  #
+  #   http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.1
+  #
+  # ---------
+  #
+  # This is a port of Joe Gregario's mimeparse.py, which can be found at
+  #   <http://code.google.com/p/mimeparse/>.
+  #
+  # ported from version 0.1.2
+  #
+  # Comments are mostly excerpted from the original.
+  module MIMEParse
+    module_function
+
+  # Carves up a mime-type and returns an Array of the
+  #  [type, subtype, params] where "params" is a Hash of all
+  #  the parameters for the media range.
+  #
+  # For example, the media range "application/xhtml;q=0.5" would
+  #  get parsed into:
+  #
+  # ["application", "xhtml", { "q" => "0.5" }]
+  def parse_mime_type(mime_type)
+    parts = mime_type.split(";")
+
+    params = {}
+
+    parts[1..-1].map do |param|
+      k,v = param.split("=").map { |s| s.strip }
+      params[k] = v
+    end
+
+    full_type = parts[0].strip
+    # Java URLConnection class sends an Accept header that includes a single "*"
+    # Turn it into a legal wildcard.
+    full_type = "*/*" if full_type == "*"
+    type, subtype = full_type.split("/")
+    raise "malformed mime type" unless subtype
+
+    [type.strip, subtype.strip, params]
+  end
+
+  # Carves up a media range and returns an Array of the
+  #  [type, subtype, params] where "params" is a Hash of all
+  #  the parameters for the media range.
+  #
+  # For example, the media range "application/*;q=0.5" would
+  #  get parsed into:
+  #
+  # ["application", "*", { "q", "0.5" }]
+  #
+  # In addition this function also guarantees that there
+  #  is a value for "q" in the params dictionary, filling it
+  #  in with a proper default if necessary.
+  def parse_media_range(range)
+    type, subtype, params = parse_mime_type(range)
+    unless params.has_key?("q") and params["q"] and params["q"].to_f and params["q"].to_f <= 1 and params["q"].to_f >= 0
+      params["q"] = "1"
+    end
+
+    [type, subtype, params]
+  end
+
+  # Find the best match for a given mime-type against a list of
+  #  media_ranges that have already been parsed by #parse_media_range
+  #
+  # Returns the fitness and the "q" quality parameter of the best match,
+  #  or [-1, 0] if no match was found. Just as for #quality_parsed,
+  #  "parsed_ranges" must be an Enumerable of parsed media ranges.
+  def fitness_and_quality_parsed(mime_type, parsed_ranges)
+    best_fitness = -1
+    best_fit_q = 0
+    target_type, target_subtype, target_params = parse_media_range(mime_type)
+
+    parsed_ranges.each do |type,subtype,params|
+      if (type == target_type or type == "*" or target_type == "*") and
+          (subtype == target_subtype or subtype == "*" or target_subtype == "*")
+        param_matches = target_params.find_all { |k,v| k != "q" and params.has_key?(k) and v == params[k] }.length
+
+        fitness = (type == target_type) ? 100 : 0
+        fitness += (subtype == target_subtype) ? 10 : 0
+        fitness += param_matches
+
+        if fitness > best_fitness
+          best_fitness = fitness
+          best_fit_q = params["q"]
+        end
+      end
+    end
+
+    [best_fitness, best_fit_q.to_f]
+  end
+
+  # Find the best match for a given mime-type against a list of
+  #  media_ranges that have already been parsed by #parse_media_range
+  #
+  # Returns the "q" quality parameter of the best match, 0 if no match
+  #  was found. This function behaves the same as #quality except that
+  #  "parsed_ranges" must be an Enumerable of parsed media ranges.
+  def quality_parsed(mime_type, parsed_ranges)
+    fitness_and_quality_parsed(mime_type, parsed_ranges)[1]
+  end
+
+  # Returns the quality "q" of a mime_type when compared against
+  #  the media-ranges in ranges. For example:
+  #
+  #     irb> quality("text/html", "text/*;q=0.3, text/html;q=0.7, text/html;level=1, text/html;level=2;q=0.4, */*;q=0.5")
+  #     => 0.7
+  def quality(mime_type, ranges)
+    parsed_ranges = ranges.split(",").map { |r| parse_media_range(r) }
+    quality_parsed(mime_type, parsed_ranges)
+  end
+
+  # Takes a list of supported mime-types and finds the best match
+  #  for all the media-ranges listed in header. The value of header
+  #  must be a string that conforms to the format of the HTTP Accept:
+  #  header. The value of supported is an Enumerable of mime-types
+  #
+  #     irb> best_match(["application/xbel+xml", "text/xml"], "text/*;q=0.5,*/*; q=0.1")
+  #     => "text/xml"
+  def best_match(supported, header)
+    parsed_header = header.split(",").map { |r| parse_media_range(r) }
+
+    weighted_matches = supported.map do |mime_type|
+      [fitness_and_quality_parsed(mime_type, parsed_header), mime_type]
+    end
+
+    weighted_matches.sort!
+
+    weighted_matches.last[0][1].zero? ? nil : weighted_matches.last[1]
+  end
+  end
+
+  if __FILE__ == $0
+    require "test/unit"
+
+    class TestMimeParsing < Test::Unit::TestCase
+      include MIMEParse
+
+      def test_parse_media_range
+        assert_equal [ "application", "xml", { "q" => "1" } ],
+                      parse_media_range("application/xml;q=1")
+
+        assert_equal [ "application", "xml", { "q" => "1" } ],
+                      parse_media_range("application/xml")
+
+        assert_equal [ "application", "xml", { "q" => "1" } ],
+                      parse_media_range("application/xml;q=")
+
+        assert_equal [ "application", "xml", { "q" => "1", "b" => "other" } ],
+                      parse_media_range("application/xml ; q=1;b=other")
+
+        assert_equal [ "application", "xml", { "q" => "1", "b" => "other" } ],
+                      parse_media_range("application/xml ; q=2;b=other")
+
+        # Java URLConnection class sends an Accept header that includes a single "*"
+        assert_equal [ "*", "*", { "q" => ".2" } ],
+                      parse_media_range(" *; q=.2")
+      end
+
+      def test_rfc_2616_example
+        accept = "text/*;q=0.3, text/html;q=0.7, text/html;level=1, text/html;level=2;q=0.4, */*;q=0.5"
+
+        assert_equal 1, quality("text/html;level=1", accept)
+        assert_equal 0.7, quality("text/html", accept)
+        assert_equal 0.3, quality("text/plain", accept)
+        assert_equal 0.5, quality("image/jpeg", accept)
+        assert_equal 0.4, quality("text/html;level=2", accept)
+        assert_equal 0.7, quality("text/html;level=3", accept)
+      end
+
+      def test_best_match
+        @supported_mime_types = [ "application/xbel+xml", "application/xml" ]
+
+        # direct match
+        assert_best_match "application/xbel+xml", "application/xbel+xml"
+        # direct match with a q parameter
+        assert_best_match "application/xbel+xml", "application/xbel+xml; q=1"
+        # direct match of our second choice with a q parameter
+        assert_best_match "application/xml", "application/xml; q=1"
+        # match using a subtype wildcard
+        assert_best_match "application/xml", "application/*; q=1"
+        # match using a type wildcard
+        assert_best_match "application/xml", "*/*"
+
+        @supported_mime_types = [ "application/xbel+xml", "text/xml" ]
+        # match using a type versus a lower weighted subtype
+        assert_best_match "text/xml", "text/*;q=0.5,*/*;q=0.1"
+        # fail to match anything
+        assert_best_match nil, "text/html,application/atom+xml; q=0.9"
+        # common AJAX scenario
+        @supported_mime_types = [ "application/json", "text/html" ]
+        assert_best_match "application/json", "application/json, text/javascript, */*"
+        # verify fitness sorting
+        assert_best_match "application/json", "application/json, text/html;q=0.9"
+      end
+
+      def test_support_wildcards
+        @supported_mime_types = ['image/*', 'application/xml']
+        # match using a type wildcard
+        assert_best_match 'image/*', 'image/png'
+        # match using a wildcard for both requested and supported
+        assert_best_match 'image/*', 'image/*'
+      end
+
+      def assert_best_match(expected, header)
+        assert_equal(expected, best_match(@supported_mime_types, header))
+      end
+    end
+  end
+end

data/lib/wants/validate_accepts_middleware.rb

@@ -0,0 +1,35 @@
+require 'wants/match_result'
+
+module Wants
+  class ValidateAcceptsMiddleware
+
+    DEFAULT_ON_NOT_ACCEPTABLE = lambda do |env|
+      [
+        406,
+        {
+          'Content-Type' => 'text/plain',
+          'Content-Length' => '14'
+        },
+        [ 'Not Acceptable' ]
+      ]
+    end
+
+    def initialize(app, options)
+      @app = app
+
+      @mime_types = options[:mime_types]
+      raise ArgumentError.new("#{self.class} requires option :mime_types") unless @mime_types
+
+      @on_not_acceptable = options[:on_not_acceptable] || DEFAULT_ON_NOT_ACCEPTABLE
+    end
+
+    def call(env)
+      if MatchResult.new(env['HTTP_ACCEPT'], @mime_types).present?
+        @app.call(env)
+      else
+        @on_not_acceptable.call(env)
+      end
+    end
+
+  end
+end

data/lib/wants.rb

@@ -0,0 +1,23 @@
+module Wants
+
+  class <<self
+
+    def new(env, mime_types)
+      MatchResult.new(env, mime_types)
+    end
+
+    def mime_lookup_table
+      @mime_lookup_table ||= begin
+        require 'rack/mime'
+        Rack::Mime::MIME_TYPES
+      rescue LoadError
+        {}
+      end
+    end
+
+    attr_writer :mime_lookup_table
+  end
+
+end
+
+require 'wants/match_result'

data/spec/match_result_spec.rb

@@ -0,0 +1,147 @@
+require 'spec_helper'
+require 'wants/match_result'
+
+describe Wants do
+
+  let(:accept)    { 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8' }
+  let(:available) { [ :html, :xhtml, :json ] }
+
+  subject { Wants::MatchResult.new(accept, available) }
+
+  describe 'when there are no acceptable MIME types' do
+    let(:accept) { 'application/atom+xml' }
+
+    it 'should be not_acceptable' do
+      subject.should be_not_acceptable
+    end
+
+    it 'should be blank' do
+      subject.should be_blank
+    end
+
+    it 'should not be present' do
+      subject.should_not be_present
+    end
+
+    describe 'any' do
+      it 'acts like a non-best-match MIME block method' do
+        evaluated = 0
+
+        subject.any { evaluated += 1; 'not acceptable' }.should == nil
+        evaluated.should == 0
+      end
+    end
+
+    describe 'not_acceptable' do
+      it 'acts like a best-match MIME block method' do
+        evaluated = 0
+
+        subject.not_acceptable { evaluated += 1; 'not_acceptable' }.should == 'not_acceptable'
+        evaluated.should == 1
+
+        subject.json { evaluated += 1; 'json' }.should == 'not_acceptable'
+        evaluated.should == 1
+      end
+    end
+  end
+
+  describe 'when there are acceptable MIME types' do
+    it 'should not be not_acceptable' do
+      subject.should_not be_not_acceptable
+    end
+
+    it 'should not be blank' do
+      subject.should_not be_blank
+    end
+
+    it 'should be present' do
+      subject.should be_present
+    end
+
+    describe '[]' do
+      it 'returns true for the best match' do
+        subject['text/html'].should be_true
+      end
+
+      it 'returns true for the best match as an abbreviation' do
+        subject[:html].should be_true
+      end
+
+      it 'returns false for non-best matches' do
+        subject['application/xhtml+xml'].should be_false
+      end
+
+      it 'returns false for non-matches' do
+        subject['application/atom+xml'].should be_false
+      end
+    end
+
+    describe '#respond_to?' do
+      it 'returns true for MIME-like query methods' do
+        subject.respond_to?(:html?).should be_true
+      end
+
+      it 'returns true for MIME block methods' do
+        subject.respond_to?(:json).should be_true
+      end
+    end
+
+    describe 'MIME query methods' do
+      it 'returns true for the best match as an abbreviation' do
+        subject.should be_html
+      end
+
+      it 'returns false for non-best matches' do
+        subject.should_not be_xhtml
+      end
+
+      it 'returns false for non-matches' do
+        subject.should_not be_atom
+      end
+
+      it 'throws an exception if passed arguments' do
+        expect {
+          subject.html? :anything
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    describe 'MIME block methods' do
+      it 'evaluates the block and returns its result only if the best match' do
+        evaluated = 0
+
+        subject.atom { evaluated += 1; 'atom' }.should be_nil
+        evaluated.should == 0
+
+        subject.html { evaluated += 1; 'html' }.should == 'html'
+        evaluated.should == 1
+
+        subject.json { evaluated += 1; 'json' }.should == 'html'
+        evaluated.should == 1
+      end
+    end
+
+    describe 'any' do
+      it 'acts like a best-match MIME block method' do
+        evaluated = 0
+
+        subject.any { evaluated += 1; 'any' }.should == 'any'
+        evaluated.should == 1
+
+        subject.json { evaluated += 1; 'json' }.should == 'any'
+        evaluated.should == 1
+      end
+    end
+
+    describe 'not_acceptable' do
+      it 'acts like a non-best-match MIME block method' do
+        evaluated = 0
+
+        subject.not_acceptable { evaluated += 1; 'not acceptable' }.should == nil
+        evaluated.should == 0
+      end
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH <<
+  File.expand_path('../../lib', __FILE__) <<
+  File.expand_path('..', __FILE__)
+
+require 'rspec'
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+end

data/spec/validate_accepts_middleware_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'wants/validate_accepts_middleware'
+
+describe Wants do
+
+  let(:upstream) { double('App') }
+  let(:accept)   { nil }
+  let(:env)      { { 'HTTP_ACCEPT' => accept } }
+
+  subject { Wants::ValidateAcceptsMiddleware.new(upstream, :mime_types => [ :html, :json ]) }
+
+  describe 'when there is an acceptable MIME type' do
+    let(:accept)   { 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.1' }
+
+    it 'passes the request upstream' do
+      upstream.should_receive(:call).with(env)
+      subject.call(env)
+    end
+
+    it 'returns the upstream response' do
+      result = double('Result')
+      upstream.stub(:call) { result }
+      subject.call(env).should == result
+    end
+  end
+
+  describe 'when there is no acceptable MIME type' do
+    let(:accept)   { 'application/atom+xml' }
+
+    it "doesn't pass the request upstream" do
+      upstream.should_not_receive(:call)
+      subject.call(env)
+    end
+
+    it 'returns a 406' do
+      status, headers, body = *subject.call(env)
+      status.should == 406
+      headers['Content-Type'].should == 'text/plain'
+      headers['Content-Length'].should == body.first.length.to_s
+      body.should == [ 'Not Acceptable' ]
+    end
+  end
+
+end

data/spec/wants_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'wants'
+
+describe Wants do
+
+  describe '.new' do
+    it 'delegates to Wants::MatchResult.new' do
+      env = Object.new
+      mime_types = [ :html, :json ]
+      result = Object.new
+      Wants::MatchResult.should_receive(:new).with(env, mime_types) { result }
+      Wants.new(env, mime_types).should == result
+    end
+  end
+
+  describe '.mime_lookup_table' do
+    subject { Wants.mime_lookup_table }
+
+    before do
+      require 'rack/mime'
+      Wants.instance_eval do
+        @mime_lookup_table = nil
+      end
+    end
+
+    describe 'when Rack::Mime::MIME_TYPES is available' do
+      it 'defaults to that' do
+        subject.should == Rack::Mime::MIME_TYPES
+      end
+    end
+
+    describe 'when Rack::Mime::MIME_TYPES is unavailable' do
+      before do
+        Wants.stub(:require) { raise LoadError.new('Rack unavailable') }
+      end
+
+      it 'defaults to an empty Hash' do
+        subject.should == {}
+      end
+    end
+
+    it 'can be set' do
+      table = Object.new
+      Wants.mime_lookup_table = table
+      subject.should == table
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: wants
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- James A. Rosen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Parse and query the HTTP Accept header
+email: james.a.rosen@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/wants/match_result.rb
+- lib/wants/mimeparse.rb
+- lib/wants/validate_accepts_middleware.rb
+- lib/wants.rb
+- README.md
+- spec/match_result_spec.rb
+- spec/spec_helper.rb
+- spec/validate_accepts_middleware_spec.rb
+- spec/wants_spec.rb
+homepage: http://github.com/jamesarosen/wants
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 2
+summary: HTTP Accept header support
+test_files:
+- spec/match_result_spec.rb
+- spec/spec_helper.rb
+- spec/validate_accepts_middleware_spec.rb
+- spec/wants_spec.rb