accept_headers 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4fe78baeb6173880a3a828984a2ece4ba13c586d56ec7aa2c9dcec8e1706cf08
-  data.tar.gz: ab2d2265cef9efb0615a756940c58723c754f44f446b16a39cdbbb5b954acc20
+  metadata.gz: a7e488e8a3433dba0966e71c79d189240b68ae10eca39fa21e62e3a4924fcdb9
+  data.tar.gz: cf0955ec1218a983b6b3f79b6ee64255b79094fc6347e07798d20768a9a8ddb9
 SHA512:
-  metadata.gz: 25ec2d46da27efaa2b46ba60a48dbdda47fa506930ae6ebbc609282c4494ef46ec575c447ca0d88432d9310f638919cfc1afc72ead05e12691342ecdb8a342d8
-  data.tar.gz: 1726ae60e312b8cae49d41713bd23391912cec46a327a2e2dd3bed8107db62f8bf3feab28f66a9bf2bb5d443ce44d201f7e0177d8b69f3e2ede989db8c176b16
+  metadata.gz: 56a57c4fc145a17435e6fcd0dfb90c074106161a6fdd7169285b6d9efec29ace5dcd9836434778a546cfe6d698148e3920603fc513b791ef78f8f4954e2dbf0d
+  data.tar.gz: 22f172cc9de919f571279e971b8f3fa740cd964323c4f09068e186a063c32ec898df1f6a5715e31039070eb94cf39e29b22686768208df2519832cdb32547431

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,26 @@
-## HEAD
+## 0.3.0 / October 21, 2026
+
+  * Validate every supported offer before negotiation and raise `AcceptHeaders::InvalidSupportedValue` for invalid application configuration. Supported offers must be concrete values without quality weights; request parsing remains lenient.
+  * Trim surrounding spaces and tabs from supported offers. Language offers such as `" en "` now match where 0.2.0 skipped them.
+  * Add `MediaType#content_type` to serialize response media types with their parameters and without quality weights.
+  * Preserve HTTP parameter bytes through parsing, matching, and response escaping, including ASCII-compatible multibyte headers and supported strings. A backslash byte introduces a quoted pair even within a Ruby multibyte character; this corrects 0.2.0's character-based parsing.
+  * Match identical media parameter bytes across Ruby encoding labels without transcoding. UTF-8, ASCII-8BIT, and ISO-8859-1 strings with the same bytes now match where 0.2.0 could return `nil`; different bytes remain distinct.
+  * Match `charset` parameter values with ASCII-only case folding, without the Unicode case folding used in 0.2.0.
+  * Document supported-value validation and use parameter-preserving response headers in the Rack example.
+
+## 0.2.0 / October 20, 2026
+
+  * 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,203 @@
-[![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.3.0. See [Upgrading from 0.2.0 to 0.3.0](#upgrading-from-020-to-030) before updating. For older installations, also see [Upgrading from 0.1.0 to 0.2.0](#upgrading-from-010-to-020).
 
-  * 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.3.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" }
+match.content_type
+# => "application/json;version=2"
+
+response_headers = { 'content-type' => match.content_type }
+response_headers['content-type']
+# => "application/json;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)
-
-m = media_types.negotiate('application/json')
-puts m.extensions['version'] # returns '2'
-```
+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. `#content_type` includes these parameters without a quality weight, for use in a response's `Content-Type`. `#to_s` quotes parameter values when needed and writes `q` last.
 
-`#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
+```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"
+```
 
-# Returns:
+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.
 
-[
-  AcceptHeaders::Encoding.new('gzip'),
-  AcceptHeaders::Encoding.new('compress', q: 0.8),
-  AcceptHeaders::Encoding.new('deflate', q: 0.5)
-]
-```
+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`.
 
-`#negotiate`:
+`#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-*`.
 
-```ruby
-encodings.negotiate(['gzip', 'compress'])
+### Missing, empty, and malformed headers
 
-# Returns this equivalent:
+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.
 
-AcceptHeader::Encoding.new('gzip')
-```
+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. For headers in ASCII-compatible Ruby encodings, media parameter parsing treats a backslash byte as a quoted-pair escape even when Ruby considers it part of a multibyte character. Headers and supported strings follow the same HTTP byte syntax, without transcoding.
 
-`#accept?`:
+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.
 
-```ruby
-encodings.accept?('gzip') # true
+`#to_s` produces a normalized preference header, including quality values. Use `#content_type`, `#encoding`, or `#language_tag` for response headers. `#media_range` contains only the media type and subtype, without parameters. With `==`, objects compare equal only when their class, type-specific fields, and quality values agree. Sorting order does not imply equality.
 
-# Identity is accepted as long as it's not explicitly rejected 'identity;q=0'
+### Supported values
 
-encodings.accept?('identity') # true
-```
+Supported strings must use an ASCII-compatible Ruby encoding. Media parameter parsing, matching, and response escaping interpret them as HTTP bytes, without transcoding. A backslash byte introduces a quoted pair even when Ruby considers it part of a multibyte character. Parameter values compare byte for byte regardless of Ruby encoding labels, except that `charset` ignores ASCII letter case. UTF-8 parameter values retain their encoding; frozen offers are not modified.
 
-### Accept-Language
+`#negotiate` and `#accept?` validate every supported value before matching, even when the request header is empty or an earlier offer matches. Declare concrete media types, coding tokens, or language tags. Wildcards, lists within one string, header name prefixes, quality weights such as `;q=1`, malformed syntax, and non-string values raise `AcceptHeaders::InvalidSupportedValue`, a subclass of `ArgumentError`. Invalid Ruby string encodings and prohibited control characters also raise this error. Quoted media parameter values can contain literal `q=` text.
 
-`Accept::Language::Negotiator`:
+This error indicates invalid application configuration. A valid offer that the client does not accept still returns `nil` from `#negotiate` and `false` from `#accept?`. Passing `nil` or an empty array declares no offers and returns those same results; an array containing `nil` is invalid. Request header parsing remains lenient as described above.
 
-```ruby
-accept_language = 'Accept-Language: en-*, en-us, *;q=0.8'
-languages = AcceptHeaders::Language::Negotiator.new(accept_language)
+## Rack middleware
 
-languages.list
+The middleware adds negotiators to the request environment. The application selects representations and creates the response:
 
-# Returns:
+```ruby
+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;version=2')
+	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.content_type,
+			'content-language' => language.language_tag,
+			'vary' => vary
+		}
+		[200, headers, ['{"message":"Hello"}']]
+	else
+		[406, { 'content-type' => 'text/plain', 'vary' => vary }, ['Not acceptable']]
+	end
+}
 ```
 
-`#negotiate`:
+This example supports version 2 of 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.
 
-```ruby
-languages.negotiate(['en-us', 'zh-Hant'])
+## Upgrading from 0.2.0 to 0.3.0
 
-# Returns this equivalent:
+Version 0.3.0 validates supported offers before negotiation and adds response serialization:
 
-AcceptHeaders::Language.new('en', 'us')
-```
+- Declare concrete supported values without wildcards, header prefixes, lists within one string, or quality weights. Every invalid offer raises `AcceptHeaders::InvalidSupportedValue`, even if an earlier offer matches. Request parsing remains lenient.
+- Surrounding spaces and tabs are trimmed from supported offers. Language offers such as `" en "` now match where 0.2.0 skipped them.
+- Media parameters follow HTTP byte syntax, including quoted-pair escapes inside Ruby multibyte characters. Identical parameter bytes match across Ruby encoding labels without transcoding. `charset` case folding applies only to ASCII letters.
+- Use `MediaType#content_type` for response headers to retain parameters without a quality weight. `#to_s` still includes quality values, and `#media_range` still omits parameters.
 
-`#accept?`:
+## Upgrading from 0.1.0 to 0.2.0
 
-```ruby
-languages.accept?('en-gb') # true
-```
+Version 0.2.0 corrects behavior from version 0.1.0:
 
-## Rack Middleware
+- 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.
 
-Add the middleware:
+The public negotiator classes, constructors, and `#extensions` accessor remain available. These corrections can change selection results for callers that depended on the previous behavior.
 
-```ruby
-require 'accept_headers/middleware'
-use AcceptHeaders::Middleware
-run YourApp
-```
+## Development
 
-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.
+Install dependencies with `bundle install`, then run the complete suite:
 
-```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
+```sh
+bundle exec rake test
 ```
 
+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,35 @@ 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 = validate_supported_values(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 valid_supported_value?(value)
+        match = ENCODING_PATTERN.match(value.b)
+        match && match[:encoding] != '*'
+      end
+
+      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/invalid_supported_value.rb

@@ -0,0 +1,3 @@
+module AcceptHeaders
+  class InvalidSupportedValue < ArgumentError; end
+end

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)
@@ -20,6 +21,10 @@ module AcceptHeaders
       end
 
       private
+      def valid_supported_value?(value)
+        SUPPORTED_LANGUAGE_TAG_PATTERN.match(value.b.strip)
+      end
+
       def no_header
         [Language.new]
       end
@@ -30,7 +35,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],