accept_headers 0.1.0 → 0.3.0

data/lib/accept_headers/language.rb

@@ -14,17 +14,7 @@ module AcceptHeaders
     end
 
     def <=>(other)
-      if q < other.q
-        -1
-      elsif q > other.q
-        1
-      elsif (primary_tag == '*' && other.primary_tag != '*') || (subtag == '*' && other.subtag != '*')
-        -1
-      elsif (primary_tag != '*' && other.primary_tag == '*') || (subtag != '*' && other.subtag == '*')
-        1
-      else
-        0
-      end
+      [q, specificity] <=> [other.q, other.specificity]
     end
 
     def primary_tag=(value)
@@ -53,26 +43,19 @@ module AcceptHeaders
     end
 
     def language_tag
-      if primary_tag == '*' && (subtag.nil? || subtag == '*')
-        '*'
-      else
-        "#{primary_tag}-#{subtag}"
-      end
+      subtag == '*' ? primary_tag : "#{primary_tag}-#{subtag}"
+    end
+
+    def specificity
+      [primary_tag == '*' ? 0 : language_tag.split('-').length]
     end
 
     def match(language_tag_string)
-      match_data = Negotiator::LANGUAGE_TAG_PATTERN.match(language_tag_string)
-      if !match_data
-        false
-      elsif primary_tag == match_data[:primary_tag] && subtag == match_data[:subtag]
-        true
-      elsif primary_tag == match_data[:primary_tag] && subtag == '*'
-        true
-      elsif primary_tag == '*'
-        true
-      else
-        false
-      end
+      return false unless language_tag_string.is_a?(String)
+      return false unless Negotiator::SUPPORTED_LANGUAGE_TAG_PATTERN.match?(language_tag_string)
+      candidate = language_tag_string.downcase
+      range = language_tag
+      range == '*' || candidate == range || candidate.start_with?("#{range}-")
     end
   end
 end

data/lib/accept_headers/media_type/negotiator.rb

@@ -6,23 +6,31 @@ 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
+      def valid_supported_value?(value)
+        media_range_string, *parameters = split_quoted(value.b, ';')
+        media_range = MEDIA_TYPE_PATTERN.match(media_range_string)
+        return false unless media_range && media_range[:subtype]
+        return false if media_range[:type] == '*' || media_range[:subtype] == '*'
+        parameters.all? do |parameter|
+          next true if parameter.strip.empty?
+          match = PARAMS_PATTERN.match(parameter)
+          match && match[:attribute].downcase != 'q'
+        end
+      rescue ParseError
+        false
+      end
+
       def no_header
         [MediaType.new]
       end
@@ -34,6 +42,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 +54,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.b[1...-1].gsub(/\\(.)/m, '\\1').force_encoding(part.encoding)
           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,9 +63,19 @@ module AcceptHeaders
 
     def to_s
       qvalue = (q == 0 || q == 1) ? q.to_i : q
-      string = "#{media_range};q=#{qvalue}"
+      content_type.concat(";q=#{qvalue}")
+    end
+
+    def content_type
+      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.b)
+            value = '"' + value.b.gsub(/["\\]/) { |character| "\\#{character}" }.force_encoding(value.encoding) + '"'
+          end
+          string.concat(";#{key}=#{value}")
+        end
       end
       string
     end
@@ -74,18 +84,29 @@ module AcceptHeaders
       "#{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 value.is_a?(String) && supported_value.is_a?(String)
+          value = value.b
+          supported_value = supported_value.b
+        end
+        if name == 'charset'
+          supported_value && value.casecmp?(supported_value)
+        else
+          value == supported_value
+        end
       end
     end
   end

data/lib/accept_headers/negotiatable.rb

@@ -1,3 +1,5 @@
+require "accept_headers/invalid_supported_value"
+
 module AcceptHeaders
   module Negotiatable
     class Error < StandardError; end
@@ -5,29 +7,29 @@ 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/
+    SUPPORTED_CONTROL_PATTERN = /[\x00-\x08\x0A-\x1F\x7F]/n
 
     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
+      supported = validate_supported_values(supported)
+      candidates = supported.each_with_index.map do |support, support_index|
+        matches = list.each_with_index.select { |part, _| part.match(support.strip) }
+        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)
@@ -39,6 +41,23 @@ module AcceptHeaders
     end
 
     private
+    def validate_supported_values(supported)
+      values = if supported.nil?
+        []
+      elsif supported.is_a?(Array)
+        supported
+      else
+        [supported]
+      end
+      values.each do |value|
+        unless value.is_a?(String) && value.valid_encoding? && value.encoding.ascii_compatible? &&
+            !SUPPORTED_CONTROL_PATTERN.match(value.b) && valid_supported_value?(value)
+          raise InvalidSupportedValue, "Invalid supported value: #{value.inspect}"
+        end
+      end
+      values
+    end
+
     def no_header
       raise NotImplementedError.new("#no_header is not implemented")
     end
@@ -50,11 +69,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 +83,43 @@ 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 = +"".b
+      quoted = false
+      escaped = false
+      value.b.each_char do |character|
+        if escaped
+          escaped = false
+        elsif quoted && character == "\\"
+          escaped = true
+        elsif character == '"'
+          quoted = !quoted
+        elsif !quoted && character == delimiter
+          parts << part
+          part = +"".b
+          next
         end
+        part << character
+      end
+      raise ParseError if quoted || escaped
+      parts << part
+      parts.map { |segment| segment.force_encoding(value.encoding) }
+    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.3.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|
+        assert_raises(AcceptHeaders::InvalidSupportedValue) { negotiator.negotiate(coding) }
+      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