accept_headers 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4fe78baeb6173880a3a828984a2ece4ba13c586d56ec7aa2c9dcec8e1706cf08
-  data.tar.gz: ab2d2265cef9efb0615a756940c58723c754f44f446b16a39cdbbb5b954acc20
+  metadata.gz: f3e0dda15c77d1bf57df59c16d27f829e3fadf8868f63717e59bd65247b0ec3f
+  data.tar.gz: 0baaeba925e9b4582f43fd3f699ae03debd44a8bb7d31b4b4501f178984ccb2e
 SHA512:
-  metadata.gz: 25ec2d46da27efaa2b46ba60a48dbdda47fa506930ae6ebbc609282c4494ef46ec575c447ca0d88432d9310f638919cfc1afc72ead05e12691342ecdb8a342d8
-  data.tar.gz: 1726ae60e312b8cae49d41713bd23391912cec46a327a2e2dd3bed8107db62f8bf3feab28f66a9bf2bb5d443ce44d201f7e0177d8b69f3e2ede989db8c176b16
+  metadata.gz: b76e1a583842a4952c99b953fa406edc682bd4f5e30eb07f383f07f42cb89b71f4d7b6e31f4010ad1f375406b82ac65b2462b2672529a689e18fd31ed562c9df
+  data.tar.gz: c4920549cbed068d58abec12c24058ea3d8cc8b6c4d6768374f698d7e4f544f4c03c4d831e67b83228b237e0136d384dc9877b9b4c772fa3ce1a48c9419299e1

data/.github/dependabot.yml

@@ -0,0 +1,8 @@
+version: 2
+updates:
+- package-ecosystem: bundler
+  directory: "/"
+  schedule:
+    interval: daily
+    time: "10:00"
+  open-pull-requests-limit: 10

data/.github/workflows/ci.yml

@@ -0,0 +1,23 @@
+name: CI
+
+on: [push, pull_request]
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: ['3.3', '3.4', '4.0']
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - run: bundle exec rake test

data/CHANGELOG.md

@@ -1,4 +1,16 @@
-## HEAD
+## 0.2.0 / Unreleased
+
+  * Replace Travis CI with GitHub Actions covering maintained Ruby 3.3, 3.4, and 4.0, and repair fresh test dependency setup.
+  * Follow RFC 9110 negotiation rules and RFC 4647 Basic Filtering for languages.
+  * Honor specific quality values and exclusions before wildcard preferences.
+  * Match declared media parameters and preserve supported representation parameters instead of copying requested parameters.
+  * Preserve quoted delimiters and escapes, validate media tokens, and serialize media parameters before quality values.
+  * Handle raw HTTP field bytes without encoding exceptions and preserve quoted non-ASCII values.
+  * Parse current quality syntax, including `0.`, `1.`, and case-insensitive `q`, while retaining the documented invalid-quality recovery value.
+  * Distinguish missing and empty fields and apply encoding identity fallback and exclusion rules.
+  * Support multi-subtag languages and case-insensitive matching. Replace `en-*` header ranges with `en`; bare supported tags remain bare.
+  * Compare values by all their fields instead of equating unrelated values with the same sort priority.
+  * Update usage, upgrade notes, and Rack 3 examples. These corrections change results for callers relying on the previous behavior; see [Upgrading from 0.1.0 to 0.2.0](README.md#upgrading-from-010-to-020) before upgrading.
 
 ## 0.1.0 / April 19, 2019
 

data/Gemfile

@@ -4,6 +4,7 @@ source "https://rubygems.org"
 gemspec
 
 group :test do
+  gem "csv"
   gem "minitest-focus"
   gem "simplecov", require: false
 end
@@ -11,5 +12,5 @@ end
 group :development, :test do
   gem "pry"
   gem "awesome_print"
-  gem "rack-test"
+  gem "rack"
 end

data/README.md

@@ -1,220 +1,180 @@
-[![Build Status](https://travis-ci.org/kamui/accept_headers.png)](https://travis-ci.org/kamui/accept_headers)
+[![CI](https://github.com/kamui/accept_headers/actions/workflows/ci.yml/badge.svg)](https://github.com/kamui/accept_headers/actions/workflows/ci.yml)
 
 # AcceptHeaders
 
-**AcceptHeaders** is a ruby library that does content negotiation and parses and sorts http accept headers.
+AcceptHeaders parses HTTP `Accept`, `Accept-Encoding`, and `Accept-Language` headers and negotiates a match against the representations your application supports. It has no runtime dependencies.
 
-Some features of the library are:
+This README describes version 0.2.0. See [Upgrading from 0.1.0 to 0.2.0](#upgrading-from-010-to-020) before updating an existing installation.
 
-  * Strict adherence to [RFC 2616][rfc], specifically [section 14][rfc-sec14]
-  * Full support for the [Accept][rfc-sec14-1], [Accept-Encoding][rfc-sec14-3],
-    and [Accept-Language][rfc-sec14-4] HTTP request headers
-  * `Accept-Charset` is not supported because it's [obsolete](https://developer.mozilla.org/en-US/docs/Web/HTTP/Content_negotiation#The_Accept-Charset.3A_header)
-  * Parser tested against all IANA registered [media types][iana-media-types] and [encodings][iana-encodings]
-  * A comprehensive [spec suite][spec] that covers many edge cases
-
-This library is optimistic when parsing headers. If a specific media type, encoding, or language can't be parsed, is in an invalid format, or contains invalid characters, it will skip that specific entry when constructing the sorted list. If a `q` value can't be read or is in the wrong format (more than 3 decimal places), it will default it to `0.001` so it still has a chance to match. Lack of an explicit `q` value of course defaults to 1.
-
-[rfc]: http://www.w3.org/Protocols/rfc2616/rfc2616.html
-[rfc-sec14]: http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html
-[rfc-sec14-1]: http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.1
-[rfc-sec14-3]: http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.3
-[rfc-sec14-4]: http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.4
-[iana-media-types]: https://www.iana.org/assignments/media-types/media-types.xhtml
-[iana-encodings]: https://www.iana.org/assignments/http-parameters/http-parameters.xml#content-coding
-[spec]: http://github.com/kamui/accept_headers/tree/master/spec/
+Negotiation follows [RFC 9110, sections 12.4 and 12.5](https://www.rfc-editor.org/rfc/rfc9110.html#section-12.4). Language matching uses [RFC 4647 Basic Filtering](https://www.rfc-editor.org/rfc/rfc4647.html#section-3.3.1). `Accept-Charset` is not supported because it is deprecated.
 
 ## Installation
 
-Add this line to your application's Gemfile:
+CI covers the maintained Ruby series: 3.3, 3.4, and 4.0. Older Ruby versions remain allowed by the gem specification but are not tested.
+
+Add the gem to your Gemfile and run `bundle install`:
 
 ```ruby
-gem 'accept_headers'
+gem 'accept_headers', '~> 0.2.0'
 ```
 
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
+## Usage
 
-    $ gem install accept_headers
+```ruby
+require 'accept_headers'
+```
 
-## Usage
+Each negotiator accepts a header value, with or without its conventional header name prefix. `#list` returns parsed entries sorted by preference. `#negotiate` accepts one supported string or an array and returns a `MediaType`, `Encoding`, or `Language`, or `nil` when none is acceptable. `#accept?` checks whether negotiation succeeds.
 
-### Accept
+Entries in `#list` describe client preferences. Their order alone does not determine the best supported representation. Negotiation accounts for the most specific matching range before comparing quality values.
 
-`AcceptHeaders::MediaType::Negotiator` is a class that is initialized with an `Accept` header string and will internally store an array of `MediaType`s in descending order according to the spec, which takes into account `q` value, `type`/`subtype` and `extensions` specificity.
+### Media types
 
 ```ruby
-accept_header = 'Accept: text/*;q=0.3, text/html;q=0.7, text/html;level=1, text/html;level=2;q=0.4, */*;q=0.5'
-media_types = AcceptHeaders::MediaType::Negotiator.new(accept_header)
+media_types = AcceptHeaders::MediaType::Negotiator.new(
+	'text/html;q=0.1, text/*;q=0.9, application/json;q=0.5'
+)
 
-media_types.list
+media_types.negotiate(['text/html', 'application/json']).media_range
+# => "application/json"
 
-# Returns:
+media_types.accept?('text/html')
+# => true
 
-[
-  AcceptHeaders::MediaType.new('text', 'html', extensions: { 'level' => '1' }),
-  AcceptHeaders::MediaType.new('text', 'html', q: 0.7),
-  AcceptHeaders::MediaType.new('*', '*', q: 0.5),
-  AcceptHeaders::MediaType.new('text', 'html', q: 0.4, extensions: { 'level' => '2' }),
-  AcceptHeaders::MediaType.new('text', '*', q: 0.3)
-]
+AcceptHeaders::MediaType::Negotiator.new('text/html;q=0, */*;q=1').accept?('text/html')
+# => false
 ```
 
-`#negotiate` takes an array of media range strings supported (by your API or route/controller) and returns the best supported `MediaType` and the `extensions` params from the matching internal media type.
+The exact `text/html` range sets HTML's quality to `0.1`, even though `text/*` has a higher quality. A more specific positive range can also override a wildcard exclusion.
 
-This will first check the available list for any matching media types with a `q` of 0 and skip any matches. It does this because the RFC specifies that if the `q` value is 0, then content with this parameter is `not acceptable`. Then it'll look to the highest `q` values and look for matches in descending `q` value order and return the first match (accounting for wildcards). Finally, if there are no matches, it returns `nil`.
+Media parameters constrain the match. Declare each representation that your application actually supports:
 
 ```ruby
-# The same media_types variable as above
-media_types.negotiate(['text/html', 'text/plain'])
-
-# Returns this equivalent:
-
-AcceptHeader::MediaType.new('text', 'html', extensions: { 'level' => '1' })
+versions = AcceptHeaders::MediaType::Negotiator.new(
+	'application/json;version=2, application/json;version=1;q=0.8'
+)
+
+match = versions.negotiate(['application/json;version=1', 'application/json;version=2'])
+match.media_range
+# => "application/json"
+match.extensions
+# => { "version" => "2" }
+
+versions.negotiate('application/json')
+# => nil
 ```
 
-It returns the matching `MediaType`, so you can see which one matched and also access the `extensions` params. For example, if you wanted to put your API version in the extensions, you could then retrieve the value.
+`#extensions` retains its historical name and contains media parameters. Under RFC 9110, parameters after `q` are also media parameters. Negotiation preserves the selected supported representation's parameters. It does not copy unsupported parameters from the request.
 
-```ruby
-versions_header = 'Accept: application/json;version=2,application/json;version=1;q=0.8'
-media_types = AcceptHeaders::MediaType::Negotiator.new(versions_header)
+Media type names and parameter names match without regard to case. Parameter values are case-sensitive except for `charset` values. Double-quoted values support commas, semicolons, and backslash escapes. `#to_s` quotes parameter values when needed and writes `q` last.
 
-m = media_types.negotiate('application/json')
-puts m.extensions['version'] # returns '2'
-```
-
-`#accept?`:
+### Encodings
 
 ```ruby
-media_types.accept?('text/html') # true
+encodings = AcceptHeaders::Encoding::Negotiator.new('br, gzip;q=0.8')
+encodings.negotiate(['gzip', 'identity']).encoding
+# => "gzip"
+encodings.accept?('identity')
+# => true
+
+AcceptHeaders::Encoding::Negotiator.new('').accept?('gzip')
+# => false
+AcceptHeaders::Encoding::Negotiator.new('').accept?('identity')
+# => true
+AcceptHeaders::Encoding::Negotiator.new(nil).accept?('gzip')
+# => true
 ```
 
-### Accept-Encoding
+A missing encoding header allows any coding. A present empty header allows only an unencoded response, represented by `identity`. For a nonempty header, identity is a fallback unless `identity;q=0` or `*;q=0` excludes it. Explicit coding preferences take precedence over `*`. Coding names match without regard to case.
 
-`AcceptHeader::Encoding::Encoding`:
+Selecting `gzip` does not compress the response body. Your application or compression middleware must produce the selected encoding. Omit `Content-Encoding` for identity responses.
 
-```ruby
-accept_encoding = 'Accept-Encoding: deflate; q=0.5, gzip, compress; q=0.8, identity'
-encodings = AcceptHeaders::Encoding::Negotiator.new(accept_encoding)
+### Languages
 
-encodings.list
-
-# Returns:
-
-[
-  AcceptHeaders::Encoding.new('gzip'),
-  AcceptHeaders::Encoding.new('compress', q: 0.8),
-  AcceptHeaders::Encoding.new('deflate', q: 0.5)
-]
+```ruby
+languages = AcceptHeaders::Language::Negotiator.new('zh-Hant-TW, en;q=0.8')
+languages.negotiate(['en-US', 'zh-Hant-TW']).language_tag
+# => "zh-hant-tw"
+languages.accept?('en-GB')
+# => true
+languages.accept?('eng')
+# => false
+
+AcceptHeaders::Language::Negotiator.new('en').negotiate('en').language_tag
+# => "en"
 ```
 
-`#negotiate`:
+Basic Filtering matches a complete range or a prefix followed by a hyphen, without regard to case. Ranges can contain multiple subtags. `*` matches otherwise unspecified languages. More specific ranges determine quality and exclusions.
 
-```ruby
-encodings.negotiate(['gzip', 'compress'])
+Use `en` to match English variants. Extended wildcard ranges such as `en-*` are outside the HTTP basic language-range syntax and are skipped. This is filtering, so `en-GB` does not fall back to `en` or match `en-US`.
 
-# Returns this equivalent:
+`#primary_tag` returns the first subtag. `#subtag` returns the remaining subtags as one lowercase string. For a bare tag, `#subtag` retains the historical `*` sentinel. Language tags returned by negotiation are lowercase supported tags. Bare tags remain bare, so `en` is not emitted as `en-*`.
 
-AcceptHeader::Encoding.new('gzip')
-```
+### Missing, empty, and malformed headers
 
-`#accept?`:
+A `nil` header represents an absent field and allows any supported value. A present empty `Accept` or `Accept-Language` contains no acceptable entries. Empty `Accept-Encoding` allows only identity.
 
-```ruby
-encodings.accept?('gzip') # true
+The parsers skip malformed entries. An unterminated quoted string rejects the whole list because its comma boundaries are ambiguous. Apostrophes are token characters, not string delimiters. Headers with an invalid Ruby string encoding are read as raw HTTP bytes. Quoted non-ASCII values are preserved.
 
-# Identity is accepted as long as it's not explicitly rejected 'identity;q=0'
+Invalid quality values recover to `0.001`, preserving this library's lenient parsing policy. Missing quality defaults to `1`. Valid quality syntax follows RFC 9110: values range from `0` to `1` with at most three decimal digits, including `0.`, `1.`, and `1.000`. The parameter name `q` is case-insensitive.
 
-encodings.accept?('identity') # true
-```
+`#to_s` produces a normalized preference header, including quality values. Use `#media_range`, `#encoding`, or `#language_tag` when you need the selected value alone. With `==`, objects compare equal only when their class, type-specific fields, and quality values agree. Sorting order does not imply equality.
 
-### Accept-Language
+## Rack middleware
 
-`Accept::Language::Negotiator`:
+The middleware adds negotiators to the request environment. The application selects representations and creates the response:
 
 ```ruby
-accept_language = 'Accept-Language: en-*, en-us, *;q=0.8'
-languages = AcceptHeaders::Language::Negotiator.new(accept_language)
-
-languages.list
-
-# Returns:
+require 'accept_headers/middleware'
 
-[
-  AcceptHeaders::Language.new('en', 'us'),
-  AcceptHeaders::Language.new('en', '*'),
-  AcceptHeaders::Language.new('*', '*', q: 0.8)
-]
+use AcceptHeaders::Middleware
+run lambda { |env|
+	media = env['accept_headers.media_types'].negotiate('application/json')
+	encoding = env['accept_headers.encodings'].negotiate('identity')
+	language = env['accept_headers.languages'].negotiate(['en-US', 'en-GB'])
+	vary = 'Accept, Accept-Encoding, Accept-Language'
+
+	if media && encoding && language
+		headers = {
+			'content-type' => media.media_range,
+			'content-language' => language.language_tag,
+			'vary' => vary
+		}
+		[200, headers, ['{"message":"Hello"}']]
+	else
+		[406, { 'content-type' => 'text/plain', 'vary' => vary }, ['Not acceptable']]
+	end
+}
 ```
 
-`#negotiate`:
-
-```ruby
-languages.negotiate(['en-us', 'zh-Hant'])
+This example supports an unencoded JSON body in two English locales. It chooses to honor negotiation failures with `406`. Applications can choose a different fallback policy. When request headers influence response selection, set `Vary` so caches distinguish the variants. Rack 3 response header names must be lowercase.
 
-# Returns this equivalent:
+## Upgrading from 0.1.0 to 0.2.0
 
-AcceptHeaders::Language.new('en', 'us')
-```
+Version 0.2.0 corrects behavior from version 0.1.0:
 
-`#accept?`:
+- Explicit exclusions and specific media preferences now take precedence over broader wildcard matches.
+- Parameterized media requests require matching supported parameters. Replace `negotiate('application/json')` with the versioned representations your application actually supports.
+- Media parameters follow RFC 9110, including parameters after `q`. Serialization places `q` last and quotes values when needed.
+- Missing and empty headers have distinct meanings. Identity fallback follows the encoding rules above.
+- Replace `en-*` header ranges with `en`. Multi-subtag language ranges now work, and bare supported tags remain bare.
+- Equality compares actual values, including parameters. Two different values with equal sort priority are no longer equal.
 
-```ruby
-languages.accept?('en-gb') # true
-```
+The public negotiator classes, constructors, and `#extensions` accessor remain available. These corrections can change selection results for callers that depended on the previous behavior.
 
-## Rack Middleware
+## Development
 
-Add the middleware:
+Install dependencies with `bundle install`, then run the complete suite:
 
-```ruby
-require 'accept_headers/middleware'
-use AcceptHeaders::Middleware
-run YourApp
+```sh
+bundle exec rake test
 ```
 
-Simple way to set the content response headers based on the request accept headers and the supported media types, encodings, and languages provided by the app or route.
-
-```ruby
-class YourApp
-  def initialize(app)
-    @app = app
-  end
-
-  def call(env)
-    # List your arrays of supported media types, encodings, languages. This can be global or per route/controller
-    supported_media_types = %w[application/json application/xml text/html text/plain]
-    supported_encodings = %w[gzip identify]
-    supported_languages = %w[en-US en-GB]
-
-    # Call the Negotiators and pass in the supported arrays and it'll return the best match
-    matched_media_type = env["accept_headers.media_types"].negotiate(supported_media_types)
-    matched_encoding = env["accept_headers.encodings"].negotiate(supported_encodings)
-    matched_language = env["accept_headers.languages"].negotiate(supported_languages)
-
-    # Set a default, in this case an empty string, in case of a bad header that cannot be parsed
-    # The return value is a MediaType, Encoding, or Language depending on the case:
-    # On MediaType, you can call #type ('text'), #subtype ('html'), #media_range ('text/html') to get the stringified parts
-    # On Encoding, you can call #encoding to get the string encoding ('gzip')
-    # On Language, you can call #primary_tag ('en'), #subtag ('us'), or #language_tag ('en-us')
-    headers = {
-      'Content-Type' => matched_media_type ? matched_media_type.media_range : '',
-      'Content-Encoding' => matched_encoding ? matched_encoding.encoding : '',
-      'Content-Language' => matched_language ? matched_language.language_tag : '',
-    }
-
-    [200, headers, ["Hello World!"]]
-  end
-end
-```
+The suite includes negotiation regressions and parser checks against the bundled IANA media-type and coding snapshots. Those snapshots are historical fixtures, not a live registry mirror. The CI workflow runs the suite on Ruby 3.3, 3.4, and 4.0.
 
 ## Contributing
 
-1. Fork it ( https://github.com/[my-github-username]/accept_headers/fork )
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create a new Pull Request
+1. Fork [kamui/accept_headers](https://github.com/kamui/accept_headers).
+2. Create a branch for your change.
+3. Add regression tests and run the suite.
+4. Open a pull request.

data/accept_headers.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Jack Chu"]
   spec.email         = ["kamuigt@gmail.com"]
   spec.summary       = %q{A ruby library that does content negotiation and parses and sorts http accept headers.}
-  spec.description   = %q{A ruby library that does content negotiation and parses and sorts http accept headers. Adheres to RFC 2616.}
+  spec.description   = %q{A ruby library that parses HTTP accept headers and negotiates media types, content codings, and languages using RFC 9110 and RFC 4647 Basic Filtering.}
   spec.homepage      = ""
   spec.license       = "MIT"
 
@@ -20,7 +20,7 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 2.4.0'
 
-  spec.add_development_dependency "rake", "~> 12.0"
+  spec.add_development_dependency "rake", "~> 13.0"
 
   spec.add_development_dependency "minitest", "~> 5.11"
   spec.add_development_dependency "guard"

data/lib/accept_headers/acceptable.rb

@@ -5,6 +5,10 @@ module AcceptHeaders
 
     attr_reader :q
 
+    def ==(other)
+      other.instance_of?(self.class) && to_h == other.to_h
+    end
+
     def reject?(other)
       if q != 0.0
         false
@@ -39,5 +43,9 @@ module AcceptHeaders
     def match(other)
       raise NotImplementedError.new("#match is not implemented")
     end
+
+    def specificity
+      raise NotImplementedError.new("#specificity is not implemented")
+    end
   end
 end

data/lib/accept_headers/encoding/negotiator.rb

@@ -6,20 +6,30 @@ module AcceptHeaders
     class Negotiator
       include Negotiatable
 
-      ENCODING_PATTERN = /^\s*(?<encoding>[\w!#$%^&*\-\+{}\\|'.`~]+)\s*$/
+      ENCODING_PATTERN = /\A[ \t]*(?<encoding>[A-Za-z0-9!#$%&'*+.^_`|~\-]+)[ \t]*\z/
       HEADER_PREFIX = 'Accept-Encoding:'
 
       def negotiate(supported)
-        support, match = super(supported)
-        return nil if support.nil? && match.nil?
-        begin
-          return parse(support).first
-        rescue Encoding::Error
-          return nil
-        end
+        supported = [*supported]
+        identity = Encoding.new('identity')
+        explicit_identity = list.any? { |part| part.encoding == 'identity' }
+        candidates = explicit_identity ? supported : supported.reject { |support| identity.match(support) }
+        support, = super(candidates)
+        return Encoding.new(support) if support
+        return nil if explicit_identity || !supported.any? { |value| identity.match(value) }
+        return nil if list.any? { |part| part.encoding == '*' && part.q.zero? }
+        identity
       end
 
       private
+      def parse(header)
+        if header && header.sub(/\A#{HEADER_PREFIX}\s*/i, '').strip.empty?
+          [Encoding.new('identity')]
+        else
+          super
+        end
+      end
+
       def no_header
         [Encoding.new]
       end

data/lib/accept_headers/encoding.rb

@@ -27,6 +27,10 @@ module AcceptHeaders
       }
     end
 
+    def specificity
+      [encoding == '*' ? 0 : 1]
+    end
+
     def to_s
       qvalue = (q == 0 || q == 1) ? q.to_i : q
       "#{encoding};q=#{qvalue}"
@@ -36,9 +40,7 @@ module AcceptHeaders
       match_data = Negotiator::ENCODING_PATTERN.match(encoding_string)
       if !match_data
         false
-      elsif encoding == match_data[:encoding]
-        true
-      elsif match_data[:encoding] == 'identity'
+      elsif encoding == match_data[:encoding].downcase
         true
       elsif encoding == '*'
         true

data/lib/accept_headers/language/negotiator.rb

@@ -6,7 +6,8 @@ module AcceptHeaders
     class Negotiator
       include Negotiatable
 
-      LANGUAGE_TAG_PATTERN = /^\s*(?<primary_tag>[\w]{1,8}|\*)(?:\s*\-\s*(?<subtag>[\w]{1,8}|\*))?\s*$/
+      LANGUAGE_TAG_PATTERN = /\A[ \t]*(?<primary_tag>[A-Za-z]{1,8}|\*)(?:-(?<subtag>[A-Za-z0-9]{1,8}(?:-[A-Za-z0-9]{1,8})*))?[ \t]*\z/
+      SUPPORTED_LANGUAGE_TAG_PATTERN = /\A[A-Za-z]{1,8}(?:-[A-Za-z0-9]{1,8})*\z/
       HEADER_PREFIX = 'Accept-Language:'
 
       def negotiate(supported)
@@ -30,7 +31,7 @@ module AcceptHeaders
         language_string, q_string = header.split(';', 2)
         raise Error if language_string.nil?
         language_range = LANGUAGE_TAG_PATTERN.match(language_string)
-        raise Error if language_range.nil?
+        raise Error if language_range.nil? || (language_range[:primary_tag] == '*' && language_range[:subtag])
         Language.new(
           language_range[:primary_tag],
           language_range[:subtag],

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