accept_headers 0.1.0 → 0.2.0

data/lib/accept_headers/media_type/negotiator.rb

@@ -6,20 +6,14 @@ module AcceptHeaders
     class Negotiator
       include Negotiatable
 
-      MEDIA_TYPE_PATTERN = /^\s*(?<type>[\w!#$%^&*\-\+{}\\|'.`~]+)(?:\s*\/\s*(?<subtype>[\w!#$%^&*\-\+{}\\|'.`~]+))?\s*$/
-      PARAMS_PATTERN = /(?<attribute>[\w!#$%^&*\-\+{}\\|'.`~]+)\s*\=\s*(?:\"(?<value>[^"]*)\"|\'(?<value>[^']*)\'|(?<value>[\w!#$%^&*\-\+{}\\|\'.`~]*))/
+      MEDIA_TYPE_PATTERN = /\A[ \t]*(?<type>[!#$%&'*+\-.^_`|~0-9A-Za-z]+)(?:\/(?<subtype>[!#$%&'*+\-.^_`|~0-9A-Za-z]+))?[ \t]*\z/
+      PARAMS_PATTERN = /\A\s*(?<attribute>[!#$%&'*+\-.^_`|~0-9A-Za-z]+)\s*=\s*(?<value>[!#$%&'*+\-.^_`|~0-9A-Za-z]+|"(?:[\t !#-\[\]-~\x80-\xFF]|\\[\t -~\x80-\xFF])*")\s*\z/n
       HEADER_PREFIX = 'Accept:'
 
       def negotiate(supported)
-        support, match = super(supported)
-        return nil if support.nil? && match.nil?
-        begin
-          media_type = parse(support).first
-          media_type.extensions = match.extensions
-          return media_type
-        rescue MediaType::Error
-          return nil
-        end
+        support, = super(supported)
+        return nil if support.nil?
+        parse(support).first
       end
 
       private
@@ -34,6 +28,8 @@ module AcceptHeaders
         raise Error if accept_media_range.nil?
         media_range = MEDIA_TYPE_PATTERN.match(accept_media_range)
         raise Error if media_range.nil?
+        raise Error if media_range[:subtype].nil? && media_range[:type] != '*'
+        raise Error if media_range[:type] == '*' && ![nil, '*'].include?(media_range[:subtype])
         MediaType.new(
           media_range[:type],
           media_range[:subtype],
@@ -44,16 +40,19 @@ module AcceptHeaders
 
       def parse_extensions(extensions_string)
         return {} if !extensions_string || extensions_string.empty?
-        if extensions_string.match(/['"]/)
-          extensions = extensions_string.scan(PARAMS_PATTERN).map(&:compact).to_h
-        else
-          extensions = {}
-          extensions_string.split(';').each do |part|
-            param = PARAMS_PATTERN.match(part)
-            extensions[param[:attribute]] = param[:value] if param
+        extensions = {}
+        split_quoted(extensions_string, ';').each do |part|
+          next if part.strip.empty?
+          name = part.split('=', 2).first.strip.downcase
+          next if name == 'q'
+          param = PARAMS_PATTERN.match(part.b)
+          raise ParseError unless param
+          value = param[:value].force_encoding(part.encoding)
+          if value.start_with?('"')
+            value = value[1...-1].gsub(/\\(.)/m, '\\1')
           end
+          extensions[param[:attribute].downcase] = value
         end
-        extensions.delete('q')
         extensions
       end
     end

data/lib/accept_headers/media_type.rb

@@ -47,7 +47,7 @@ module AcceptHeaders
     def extensions=(hash)
       @extensions = {}
       hash.each do |k,v|
-        @extensions[k.strip] = v
+        @extensions[k.strip.downcase] = v
       end
       @extensions
     end
@@ -63,29 +63,42 @@ module AcceptHeaders
 
     def to_s
       qvalue = (q == 0 || q == 1) ? q.to_i : q
-      string = "#{media_range};q=#{qvalue}"
+      string = media_range
       if extensions.size > 0
-        extensions.each { |k, v| string.concat(";#{k}=#{v}") }
+        extensions.each do |key, value|
+          value = value.to_s
+          unless /\A[!#$%&'*+\-.^_`|~0-9A-Za-z]+\z/.match(value)
+            value = '"' + value.gsub(/["\\]/) { |character| "\\#{character}" } + '"'
+          end
+          string.concat(";#{key}=#{value}")
+        end
       end
-      string
+      string.concat(";q=#{qvalue}")
     end
 
     def media_range
       "#{type}/#{subtype}"
     end
 
+    def specificity
+      [type == '*' ? 0 : 1, subtype == '*' ? 0 : 1, extensions.size]
+    end
+
     def match(media_range_string)
-      match_data = Negotiator::MEDIA_TYPE_PATTERN.match(media_range_string)
-      if !match_data
-        false
-      elsif type == match_data[:type] && subtype == match_data[:subtype]
-        true
-      elsif type == match_data[:type] && subtype == '*'
-        true
-      elsif type == '*' && subtype == '*'
-        true
-      else
-        false
+      return false if media_range_string.nil? || media_range_string.strip.empty?
+      candidates = Negotiator.new(media_range_string).list
+      return false unless candidates.size == 1
+      candidate = candidates.first
+      return false unless (type == '*' || type == candidate.type) &&
+        (subtype == '*' || subtype == candidate.subtype)
+
+      extensions.all? do |name, value|
+        supported_value = candidate.extensions[name]
+        if name == 'charset'
+          supported_value && value.casecmp?(supported_value)
+        else
+          value == supported_value
+        end
       end
     end
   end

data/lib/accept_headers/negotiatable.rb

@@ -5,29 +5,27 @@ module AcceptHeaders
 
     attr_reader :list
 
-    Q_PATTERN = /(?:\A|;)\s*(?<exists>qs*\=)\s*(?:(?<q>0\.\d{1,3}|[01])|(?:[^;]*))\s*(?:\z|;)/
+    Q_PATTERN = /\A[ \t]*q[ \t]*=[ \t]*(?<q>.*?)[ \t]*\z/im
+    QVALUE_PATTERN = /\A(?:0(?:\.[0-9]{0,3})?|1(?:\.0{0,3})?)\z/
 
     def initialize(header)
+      header = header.b if header && !header.valid_encoding?
       @list = parse(header)
     end
 
     def negotiate(supported)
-      return nil if list.empty?
-      supported = [*supported]
-      # TODO: Maybe q=0 should be first by default when sorting
-      rejects, acceptable = list.partition { |m| m.q == 0.0 }
-      (rejects + acceptable).each do |part|
-        supported.each do |support|
-          if part.match(support)
-            if part.q == 0.0
-              next
-            else
-              return [support, part]
-            end
-          end
+      candidates = [*supported].each_with_index.map do |support, support_index|
+        matches = list.each_with_index.select { |part, _| part.match(support) }
+        part, header_index = matches.max_by do |match, _|
+          [match.specificity, match.q.zero? ? 1 : 0, match.q]
         end
+        next if part.nil? || part.q.zero?
+        [support, part, header_index, support_index]
+      end.compact
+      best = candidates.max_by do |_, part, header_index, support_index|
+        [part.q, part.specificity, -header_index, -support_index]
       end
-      nil
+      best && best.first(2)
     end
 
     def accept?(other)
@@ -50,11 +48,11 @@ module AcceptHeaders
     def parse(header, &block)
       return no_header unless header
       header = header.dup
-      header.sub!(/\A#{self.class::HEADER_PREFIX}\s*/, '')
+      header.sub!(/\A#{self.class::HEADER_PREFIX}\s*/i, '')
       header.strip!
-      return no_header if header.empty?
+      return [] if header.empty?
       list = []
-      header.split(',').each do |entry|
+      split_quoted(header, ',').each do |entry|
         begin
           item = parse_item(entry)
           next if item.nil?
@@ -64,20 +62,42 @@ module AcceptHeaders
         end
       end
       list.sort! { |x,y| y <=> x }
+    rescue ParseError
+      []
     end
 
-    def parse_q(header)
-      q = 1
-      return q unless header
-      q_match = Q_PATTERN.match(header)
-      if q_match && q_match[:exists]
-        if q_match[:q]
-          q = q_match[:q]
-        else
-          q = 0.001
+    def split_quoted(value, delimiter)
+      parts = []
+      part = +""
+      quoted = false
+      escaped = false
+      value.each_char do |character|
+        if escaped
+          escaped = false
+        elsif quoted && character == "\\"
+          escaped = true
+        elsif character == '"'
+          quoted = !quoted
+        elsif !quoted && character == delimiter
+          parts << part
+          part = +""
+          next
         end
+        part << character
+      end
+      raise ParseError if quoted || escaped
+      parts << part
+    end
+
+    def parse_q(header)
+      return 1 unless header
+      split_quoted(header, ';').each do |parameter|
+        q_match = Q_PATTERN.match(parameter)
+        next unless q_match
+        value = q_match[:q]
+        return QVALUE_PATTERN.match(value) ? value.to_f : 0.001
       end
-      q
+      1
     end
   end
 end

data/lib/accept_headers/version.rb

@@ -1,3 +1,3 @@
 module AcceptHeaders
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/spec/encoding/negotiator_spec.rb

@@ -25,7 +25,7 @@ describe AcceptHeaders::Encoding::Negotiator do
       ]
     end
 
-    it "supports all registered IANA encodings" do
+    it "parses content codings in the bundled IANA snapshot" do
       require 'csv'
       # https://www.iana.org/assignments/http-parameters/http-parameters.xml#content-coding
       CSV.foreach("spec/support/encodings/content-coding.csv", headers: true) do |row|
@@ -38,10 +38,14 @@ describe AcceptHeaders::Encoding::Negotiator do
       end
     end
 
-    it "sets encoding to * when the accept-encoding header is empty" do
-      subject.new('').list.must_equal [
-        encoding.new('*')
-      ]
+    it "allows only identity when the accept-encoding header is empty" do
+      ['', " \t", 'Accept-Encoding:', 'accept-encoding: '].each do |header|
+        subject.new(header).list.map(&:encoding).must_equal ['identity']
+      end
+    end
+
+    it "allows any content coding when the accept-encoding header is absent" do
+      subject.new(nil).list.map(&:encoding).must_equal ['*']
     end
 
     it "defaults q to 1 if it's not explicitly specified" do
@@ -75,6 +79,10 @@ describe AcceptHeaders::Encoding::Negotiator do
         encoding.new('gzip', q: 1.0)
       ]
     end
+
+    it "parses HTTP token characters and skips delimiter-containing coding names" do
+      subject.new('example.coding, bad{coding}, bad\\coding').list.map(&:encoding).must_equal ['example.coding']
+    end
   end
 
   describe "#to_s" do
@@ -86,7 +94,53 @@ describe AcceptHeaders::Encoding::Negotiator do
   describe "negotiate supported encodings" do
     it "returns a best matching encoding" do
       n = subject.new('deflate; q=0.5, gzip, compress; q=0.8, identity')
-      n.negotiate(['identity', 'deflate']).must_equal encoding.new('identity')
+      n.negotiate(['identity', 'deflate']).encoding.must_equal 'identity'
+    end
+
+    it "distinguishes an absent header from an empty field value" do
+      subject.new(nil).negotiate('gzip').encoding.must_equal 'gzip'
+      ['', " \t", 'Accept-Encoding:'].each do |header|
+        negotiator = subject.new(header)
+        negotiator.negotiate('gzip').must_be_nil
+        negotiator.negotiate(['gzip', 'identity']).encoding.must_equal 'identity'
+      end
+    end
+
+    it "prefers an acceptable coding over implicit identity" do
+      subject.new('gzip;q=0.5').negotiate(['identity', 'gzip']).encoding.must_equal 'gzip'
+      subject.new('*;q=0.5').negotiate(['identity', 'br']).encoding.must_equal 'br'
+    end
+
+    it "falls back to identity without accepting unlisted content codings" do
+      negotiator = subject.new('gzip')
+      negotiator.negotiate(['br', 'identity']).encoding.must_equal 'identity'
+      negotiator.accept?('identity').must_equal true
+      negotiator.negotiate('br').must_be_nil
+    end
+
+    it "does not turn another coding's rejection into an identity rejection" do
+      negotiator = subject.new('gzip;q=0')
+      negotiator.negotiate(['gzip', 'identity']).encoding.must_equal 'identity'
+      negotiator.accept?('gzip').must_equal false
+    end
+
+    it "honors explicit identity preferences and exclusions" do
+      subject.new('gzip;q=0.5, identity;q=0.8').negotiate(['gzip', 'identity']).encoding.must_equal 'identity'
+      subject.new('identity;q=0').negotiate('identity').must_be_nil
+      subject.new('*;q=0').negotiate('identity').must_be_nil
+      subject.new('*;q=0, identity;q=0.5').negotiate('identity').encoding.must_equal 'identity'
+    end
+
+    it "matches supported coding names without case sensitivity" do
+      subject.new('GZIP').negotiate('GZip').encoding.must_equal 'gzip'
+      subject.new('br').negotiate('IDENTITY').encoding.must_equal 'identity'
+    end
+
+    it "requires supported names to be complete HTTP tokens" do
+      negotiator = subject.new('*')
+      ['gzip\\bad', 'gzip{bad}', "gzip\nidentity", 'gzip,br'].each do |coding|
+        negotiator.negotiate(coding).must_be_nil
+      end
     end
   end
 end

data/spec/encoding_spec.rb

@@ -74,6 +74,14 @@ describe AcceptHeaders::Encoding do
       a.accept?('gzip').must_equal true
       b = subject.new('gzip', q: 0.001)
       b.accept?('gzip').must_equal true
+      a.accept?('GZIP').must_equal true
+    end
+
+    it "matches identity only as its own coding or a wildcard" do
+      subject.new('gzip').accept?('identity').must_equal false
+      subject.new('gzip', q: 0).reject?('identity').must_equal false
+      subject.new('identity').accept?('IDENTITY').must_equal true
+      subject.new('*').accept?('identity').must_equal true
     end
 
     it "accepted if the encoding is *" do

data/spec/equality_spec.rb

@@ -0,0 +1,70 @@
+require_relative "spec_helper"
+
+describe "acceptable value equality" do
+  let(:values) do
+    [
+      AcceptHeaders::MediaType.new('text', 'html'),
+      AcceptHeaders::Encoding.new('gzip'),
+      AcceptHeaders::Language.new('en', 'us')
+    ]
+  end
+
+  it "compares all normalized fields for values of the same class" do
+    assert_equal AcceptHeaders::MediaType.new('text', 'html', extensions: { 'level' => '1' }),
+      AcceptHeaders::MediaType.new('TEXT', 'HTML', extensions: { 'level' => '1' })
+    assert_equal AcceptHeaders::Encoding.new('gzip'), AcceptHeaders::Encoding.new('GZIP')
+    assert_equal AcceptHeaders::Language.new('en', 'us'), AcceptHeaders::Language.new('EN', 'US')
+    values.each { |value| assert_equal value, value }
+  end
+
+  it "distinguishes different media types and parameters at the same preference rank" do
+    refute_equal AcceptHeaders::MediaType.new('text', 'html'), AcceptHeaders::MediaType.new('text', 'plain')
+    refute_equal AcceptHeaders::MediaType.new('text', 'plain'), AcceptHeaders::MediaType.new('application', 'plain')
+    refute_equal AcceptHeaders::MediaType.new('text', 'html', extensions: { 'level' => '1' }),
+      AcceptHeaders::MediaType.new('text', 'html', extensions: { 'level' => '2' })
+    refute_equal AcceptHeaders::MediaType.new('text', 'html', extensions: { 'level' => '1' }),
+      AcceptHeaders::MediaType.new('text', 'html', extensions: { 'version' => '1' })
+  end
+
+  it "distinguishes encodings and languages at the same preference rank" do
+    refute_equal AcceptHeaders::Encoding.new('gzip'), AcceptHeaders::Encoding.new('compress')
+    refute_equal AcceptHeaders::Language.new('en', 'us'), AcceptHeaders::Language.new('en', 'gb')
+    refute_equal AcceptHeaders::Language.new('en', 'us'), AcceptHeaders::Language.new('fr', 'us')
+  end
+
+  it "includes quality in equality" do
+    values.each do |value|
+      different_quality = value.dup
+      different_quality.q = 0.5
+      refute_equal value, different_quality
+      refute_equal different_quality, value
+    end
+  end
+
+  it "returns false symmetrically for different classes and unrelated objects" do
+    values.each do |value|
+      (values.reject { |other| other.class == value.class } + [nil, Object.new, value.to_h]).each do |other|
+        refute_equal value, other
+        refute_equal other, value
+      end
+      subclass_value = Class.new(value.class).new
+      value.to_h.each { |field, field_value| subclass_value.public_send("#{field}=", field_value) }
+      refute_equal value, subclass_value
+      refute_equal subclass_value, value
+    end
+  end
+
+  it "keeps equal preference ranks sortable without making their values equal" do
+    [
+      [AcceptHeaders::MediaType.new('text', 'html'), AcceptHeaders::MediaType.new('text', 'plain')],
+      [AcceptHeaders::Encoding.new('gzip'), AcceptHeaders::Encoding.new('compress')],
+      [AcceptHeaders::Language.new('en', 'us'), AcceptHeaders::Language.new('en', 'gb')]
+    ].each do |left, right|
+      assert_equal 0, left <=> right
+      assert_equal 0, right <=> left
+      refute_equal left, right
+      refute_equal right, left
+      assert_equal [left.to_h, right.to_h], [left, right].sort.map(&:to_h)
+    end
+  end
+end

data/spec/language/negotiator_spec.rb

@@ -2,84 +2,106 @@ require_relative "../spec_helper"
 
 describe AcceptHeaders::Language::Negotiator do
   subject { AcceptHeaders::Language::Negotiator }
-  let(:language) { AcceptHeaders::Language }
 
-  describe "parsing an accept header" do
-    it "returns a sorted array of media primary tags" do
-      subject.new("en-*;q=0.2, en-us").list.must_equal [
-        language.new('en', 'us'),
-        language.new('en', '*', q: 0.2)
+  describe "parsing an Accept-Language header" do
+    it "sorts ranges by quality and specificity" do
+      subject.new('en;q=0.2, en-us').list.map(&:to_h).must_equal [
+        {primary_tag: 'en', subtag: 'us', q: 1.0},
+        {primary_tag: 'en', subtag: '*', q: 0.2}
       ]
 
-      subject.new("en-*, en-us, *;q=0.8").list.must_equal [
-        language.new('en', 'us'),
-        language.new('en', '*'),
-        language.new('*', '*', q: 0.8)
-      ]
+      subject.new('en, en-us, *;q=0.8').list.map(&:language_tag).must_equal ['en-us', 'en', '*']
     end
 
-    it "ignores the 'Accept-Language:' prefix" do
-      subject.new('Accept-Language: en-us').list.must_equal [
-        language.new('en', 'us')
-      ]
+    it "ignores the Accept-Language prefix" do
+      subject.new('Accept-Language: en-us').list.map(&:language_tag).must_equal ['en-us']
     end
 
-    it "sets media primary tag to */* when the accept header is empty" do
-      subject.new('').list.must_equal [
-        language.new('*', '*')
-      ]
+    it "accepts any language when the header is missing" do
+      subject.new(nil).list.map(&:language_tag).must_equal ['*']
+      subject.new(nil).negotiate('en-US').language_tag.must_equal 'en-us'
     end
 
-    it "sets media primary tag to */* when the primary tag is only *" do
-      subject.new('*').list.must_equal [
-        language.new('*', '*')
-      ]
+    it "accepts no languages when the header is present and empty" do
+      ['', " \t", 'Accept-Language:'].each do |header|
+        assert_empty subject.new(header).list
+        assert_nil subject.new(header).negotiate('en-US')
+      end
     end
 
-    it "defaults q to 1 if it's not explicitly specified" do
-      subject.new("en-us").list.must_equal [
-        language.new('en', 'plain', q: 1.0)
+    it "parses a wildcard range" do
+      subject.new('*').list.map(&:to_h).must_equal [
+        {primary_tag: '*', subtag: '*', q: 1.0}
       ]
     end
 
-    it "strips whitespace from between media primary tags" do
-      subject.new("\ten-us\r,\nen-gb\s").list.must_equal [
-        language.new('en', 'us'),
-        language.new('en', 'gb')
-      ]
+    it "defaults quality to one" do
+      subject.new('en-us').list.first.to_h.must_equal({primary_tag: 'en', subtag: 'us', q: 1.0})
     end
 
-    it "strips whitespace around q" do
-      subject.new("en-us;\tq\r=\n1, en-gb").list.must_equal [
-        language.new('en', 'us'),
-        language.new('en', 'gb')
-      ]
+    it "uses the documented fallback quality for an invalid weight" do
+      subject.new('en-us;q=x').list.first.to_h.must_equal({primary_tag: 'en', subtag: 'us', q: 0.001})
     end
 
-    it "has a q value of 0.001 when parsed q is invalid" do
-      subject.new("en-us;q=x").list.must_equal [
-        language.new('en', 'plain', q: 0.001)
-      ]
+    it "allows optional whitespace around ranges" do
+      subject.new("\ten-us , en-gb\t").list.map(&:language_tag).must_equal ['en-us', 'en-gb']
     end
 
-    it "skips invalid media primary tags" do
-      subject.new("en-us, en-us-omg;q=0.9").list.must_equal [
-        language.new('en', 'us', q: 1)
+    it "retains every subtag and normalizes case" do
+      subject.new('ZH-Hant-TW, en-US-omg;q=0.9').list.map(&:to_h).must_equal [
+        {primary_tag: 'zh', subtag: 'hant-tw', q: 1.0},
+        {primary_tag: 'en', subtag: 'us-omg', q: 0.9}
       ]
     end
+
+    it "skips ranges outside the basic language-range grammar" do
+      invalid = ['en-*', '*-US', 'en_US', '123', 'englishxx', 'en-123456789', 'en--US', 'en - US']
+      subject.new((invalid + ['fr']).join(',')).list.map(&:language_tag).must_equal ['fr']
+    end
   end
 
   describe "#to_s" do
-    it "returns a string of each language #to_s joined by a comma" do
-      subject.new("en-us, en-gb;q=0.9").to_s.must_equal "en-us;q=1,en-gb;q=0.9"
+    it "serializes basic language ranges without adding wildcards" do
+      subject.new('en, zh-Hant-TW;q=0.9').to_s.must_equal 'en;q=1,zh-hant-tw;q=0.9'
     end
   end
 
-  describe "negotiate supported languages" do
-    it "returns a best matching language" do
-      match = language.new('en', 'us')
-      n = subject.new('en-*, en-us, *;q=0.8')
-      n.negotiate('en-us').must_equal language.new('en', 'us')
+  describe "negotiating supported languages" do
+    it "returns the supported language rather than the matching range" do
+      match = subject.new('en, *;q=0.8').negotiate('en-US')
+      match.to_h.must_equal({primary_tag: 'en', subtag: 'us', q: 1.0})
+    end
+
+    it "returns a plain supported language without a synthetic wildcard" do
+      subject.new('*').negotiate('en').language_tag.must_equal 'en'
+    end
+
+    it "matches script and region subtags case insensitively" do
+      subject.new('zh-Hant').negotiate(['zh-Hans-TW', 'ZH-hant-TW']).language_tag.must_equal 'zh-hant-tw'
+    end
+
+    it "applies a more specific exclusion before its parent language range" do
+      match = subject.new('zh, zh-Hant;q=0').negotiate(['zh-Hant-TW', 'zh-Hans-CN'])
+      match.language_tag.must_equal 'zh-hans-cn'
+    end
+
+    it "uses the most specific matching range quality" do
+      match = subject.new('en;q=1, en-US;q=0.1, fr;q=0.5').negotiate(['en-US', 'fr'])
+      match.language_tag.must_equal 'fr'
+    end
+
+    it "rejects candidates outside a subtag boundary" do
+      subject.new('en-US').accept?('en-USA').must_equal false
+    end
+
+    it "requires concrete supported language tags" do
+      ['*', 'en-*', 'en_US', 'en;q=1', nil].each do |support|
+        subject.new('*').accept?(support).must_equal false
+      end
+    end
+
+    it "returns nil when no supported language matches" do
+      _(subject.new('fr').negotiate('en')).must_be_nil
     end
   end
 end

data/spec/language_spec.rb

@@ -91,6 +91,11 @@ describe AcceptHeaders::Language do
       subject.new('en', 'us', q: 0.9).language_tag.must_equal "en-us"
     end
 
+    it "outputs the primary tag alone when no subtag is given" do
+      subject.new('en').language_tag.must_equal 'en'
+      subject.new('en', '*').language_tag.must_equal 'en'
+    end
+
     it "if primary tag is * and subtag is * or nil, outputs *" do
       subject.new('*', nil).language_tag.must_equal '*'
       subject.new('*', '*').language_tag.must_equal '*'
@@ -119,6 +124,13 @@ describe AcceptHeaders::Language do
       b.accept?('en-us').must_equal true
     end
 
+    it "matches complete subtag prefixes case insensitively" do
+      a = subject.new('zh', 'hant')
+      a.accept?('ZH-Hant-TW').must_equal true
+      a.accept?('zh-Hans-TW').must_equal false
+      a.accept?('zh-Hantish').must_equal false
+    end
+
     it "not accepted if the primary_tag and subtag don't match" do
       a = subject.new('en', 'us')
       a.accept?('en-gb').must_equal false
@@ -156,8 +168,7 @@ describe AcceptHeaders::Language do
       a.accept?(nil).must_equal false
     end
 
-    # TODO: test *
-    it "not accepted if..." do
+    it "does not accept a wildcard as a concrete supported tag" do
       a = subject.new('en', 'us')
       a.accept?('*').must_equal false
     end
@@ -195,8 +206,7 @@ describe AcceptHeaders::Language do
         a.reject?('en-gb').must_equal false
       end
 
-      # TODO: test *
-      it "not rejected if..." do
+      it "does not reject a wildcard as a concrete supported tag" do
         a = subject.new('en', 'us', q: 0)
         a.reject?('*').must_equal false
       end