accept_headers 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3e4d8ab6edced3cc033d6a693d51c7cbd9fee32d
-  data.tar.gz: 2fe2cf946fe203666424c666fb9d00e1fb3d9eb0
+  metadata.gz: e40f6f21dfdede27f8ec870248f903caa24a8207
+  data.tar.gz: 2a4ce23b83c7a92cbb80fffe73fa81b2eb425fe1
 SHA512:
-  metadata.gz: e9dc99f82ca6f752b2f6d562ad63c93aa8e32527a41910e0935d58137349d47b82a1ed2f69bb7b4c52f030281e551dba84a2dd3f49c5e93e1c890b2d77161002
-  data.tar.gz: 92c33af011978e0dbbaa9d88d0c060368edb969dfea3e73e072754e4ae4d1c634643f6ef6a834b22c45ad46194be7cd313e073a57188b6ac74eff41d5d0a8487
+  metadata.gz: 5c1c66df7d5771a7a8aaf90a411d74c4e3e8ef7c0bb09e595d7898fbc62dcc42847d17bc8e0e79e3a76b97ddea9c9c2c23d18983c2a14c7f0e8db64c30f823cd
+  data.tar.gz: 7b6d214b3c465b5eccb5bb441cdecec1e5e0290596ecd81684d779b896cba6fcccc786ff8dc9394f35a020226e59227598fc315ea28ef52c9d6ab6da7f2660b7

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.2 / November 15, 2014
+
+  * Add `Negotiator`s which can parse and find the best match.
+
 ## 0.1 / November 14, 2014
 
-  * Initial release
+  * Initial release.

data/Gemfile

@@ -6,8 +6,8 @@ gemspec
 group :test do
   gem "ruby_gntp"
   gem "minitest-focus"
-  gem "codeclimate-test-reporter"
-  gem "simplecov"
+  gem "codeclimate-test-reporter", require: false
+  gem "simplecov", require: false
 end
 
 group :development, :test do

data/README.md

@@ -4,7 +4,7 @@
 
 # AcceptHeaders
 
-**AcceptHeaders** is a ruby library that parses and sorts http accept headers.
+**AcceptHeaders** is a ruby library that does content negotiation and parses and sorts http accept headers.
 
 Some features of the library are:
 
@@ -14,6 +14,8 @@ Some features of the library are:
     request headers
   * A comprehensive [spec suite][spec] that covers many edge cases
 
+This library is optimistic when parsing headers. If a specific media type, encoding, charset, 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
@@ -40,74 +42,127 @@ Or install it yourself as:
 
 ## Usage
 
-`AcceptHeaders` can parse the Accept Header and return an array of `MediaType`s in descending order according to the spec, which takes into account `q` value, `type`/`subtype` and `params` specificity.
+### Accept
+
+`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 `params` specificity.
 
 ```ruby
-AcceptHeaders::MediaType.parse("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("text/*;q=0.3, text/html;q=0.7, text/html;level=1, text/html;level=2;q=0.4, */*;q=0.5")
 
-Will generate this equivalent array:
+media_types.list
+
+# Returns:
 
-```ruby
 [
-  MediaType.new('text', 'html', params: { 'level' => '1' }),
-  MediaType.new('text', 'html', q: 0.7),
-  MediaType.new('*', '*', q: 0.5),
-  MediaType.new('text', 'html', q: 0.4, params: { 'level' => '2' }),
-  MediaType.new('text', '*', q: 0.3)
+  AcceptHeaders::MediaType.new('text', 'html', params: { 'level' => '1' }),
+  AcceptHeaders::MediaType.new('text', 'html', q: 0.7),
+  AcceptHeaders::MediaType.new('*', '*', q: 0.5),
+  AcceptHeaders::MediaType.new('text', 'html', q: 0.4, params: { 'level' => '2' }),
+  AcceptHeaders::MediaType.new('text', '*', q: 0.3)
 ]
 ```
 
-Parsing `Charset`:
+`#negotiate` takes a string of media types supported (by your API or route/controller) and returns the best match as a `MediaType`. This will first check the available list for any matching media types with a `q` of 0 and return `nil` if there is a match. Then it'll look to the highest `q` values and look for matches in descending `q` value order and return the first match account for wildcards.
 
 ```ruby
-AcceptHeaders::Charset.parse("us-ascii; q=0.5, iso-8859-1, utf-8; q=0.8, macintosh")
+media_type.negotiate('text/html')
+
+# Returns:
+
+AcceptHeaders::MediaType.new('text', 'html', params: { 'level' => '1' })
 ```
 
-generates:
+### Accept-Charset
+
+`AcceptHeader::Charset::Negotiator`:
 
 ```ruby
+charsets = AcceptHeaders::Charset::Negotiator.new("us-ascii; q=0.5, iso-8859-1, utf-8; q=0.8, macintosh")
+
+charsets.list
+
+# Returns:
+
 [
-  Charset.new('iso-8859-1'),
-  Charset.new('macintosh'),
-  Charset.new('utf-8', q: 0.8),
-  Charset.new('us-ascii', q: 0.5)
+  AcceptHeaders::Charset.new('iso-8859-1'),
+  AcceptHeaders::Charset.new('macintosh'),
+  AcceptHeaders::Charset.new('utf-8', q: 0.8),
+  AcceptHeaders::Charset.new('us-ascii', q: 0.5)
 ]
 ```
 
-Parsing `Encoding`:
+`#negotiate`:
 
 ```ruby
-AcceptHeaders::Encoding.parse("deflate; q=0.5, gzip, compress; q=0.8, identity")
+charsets.negotiate('iso-8859-1')
+
+# Returns:
+
+AcceptHeaders::Charset.new('iso-8859-1')
 ```
 
-generates:
+### Accept-Encoding
+
+`AcceptHeader::Charset::Encoding`:
 
 ```ruby
+encodings = AcceptHeaders::Encoding::Negotiator.new("deflate; q=0.5, gzip, compress; q=0.8, identity")
+
+encodings.list
+
+# Returns:
+
 [
-  Encoding.new('gzip'),
-  Encoding.new('identity'),
-  Encoding.new('compress', q: 0.8),
-  Encoding.new('deflate', q: 0.5)
+  AcceptHeaders::Encoding.new('gzip'),
+  AcceptHeaders::Encoding.new('identity'),
+  AcceptHeaders::Encoding.new('compress', q: 0.8),
+  AcceptHeaders::Encoding.new('deflate', q: 0.5)
 ]
 ```
 
-Parsing `Language`:
+`#negotiate`:
 
 ```ruby
-AcceptHeaders::Language.parse("en-*, en-us, *;q=0.8")
+encodings.negotiate('identity')
+
+# Returns:
+
+AcceptHeaders::Encoding.new('identity')
 ```
 
-generates:
+### Accept-Language
+
+`Accept::Language::Negotiator`:
 
 ```ruby
+languages = AcceptHeaders::Language::Negotiator.new("en-*, en-us, *;q=0.8")
+
+languages.list
+
+# Returns:
+
 [
-  Language.new('en', 'us'),
-  Language.new('en', '*'),
-  Language.new('*', '*', q: 0.8)
+  AcceptHeaders::Language.new('en', 'us'),
+  AcceptHeaders::Language.new('en', '*'),
+  AcceptHeaders::Language.new('*', '*', q: 0.8)
 ]
 ```
 
+`#negotiate`:
+
+```ruby
+languages.negotiate('en-us')
+
+# Returns:
+
+AcceptHeaders::Language.new('en', 'us')
+```
+
+## Todo
+
+* Write rack middleware
+* More edge case tests
+
 ## Contributing
 
 1. Fork it ( https://github.com/[my-github-username]/accept_headers/fork )

data/accept_headers.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.version       = AcceptHeaders::VERSION
   spec.authors       = ["Jack Chu"]
   spec.email         = ["kamuigt@gmail.com"]
-  spec.summary       = %q{A ruby library that parses and sorts http accept headers.}
-  spec.description   = %q{A ruby library that parses and sorts http accept headers. Adheres to RFC 2616.}
+  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.homepage      = ""
   spec.license       = "MIT"
 

data/lib/accept_headers.rb

@@ -1,8 +1,12 @@
 require "accept_headers/version"
 require "accept_headers/charset"
+require "accept_headers/charset/negotiator"
 require "accept_headers/encoding"
+require "accept_headers/encoding/negotiator"
 require "accept_headers/media_type"
+require "accept_headers/media_type/negotiator"
 require "accept_headers/language"
+require "accept_headers/language/negotiator"
 
 module AcceptHeaders
 end

data/lib/accept_headers/acceptable.rb

@@ -1,17 +1,12 @@
 module AcceptHeaders
   module Acceptable
     class Error < StandardError; end
-    class OutOfRangeError < Error; end
-    class InvalidPrecisionError < Error; end
     class InvalidQError < Error; end
-    class ParseError < Error; end
 
     attr_reader :q
 
-    TOKEN_PATTERN = /^\s*(?<token>[\w!#$%^&*\-\+{}\\|'.`~]+)\s*$/
-
-    def self.included(base)
-      base.extend ClassMethods
+    def match(other)
+      raise NotImplementedError.new("#match is not implemented")
     end
 
     def q=(value)
@@ -21,31 +16,12 @@ module AcceptHeaders
         raise InvalidQError.new(e.message)
       end
       if !q_float.between?(0.0, 1.0)
-        raise OutOfRangeError.new("q must be between 0 and 1")
+        raise InvalidQError.new("q must be between 0 and 1")
       end
       if q_float.to_s.match(/^\d\.(\d+)$/) && $1 && $1.size > 3
-        raise InvalidPrecisionError.new("q must be at most 3 decimal places")
+        raise InvalidQError.new("q must be at most 3 decimal places")
       end
       @q = q_float
     end
-
-    module ClassMethods
-      Q_PATTERN = /(?:\A|;)\s*(?<exists>qs*\=)\s*(?:(?<q>0\.\d{1,3}|[01])|(?:[^;]*))\s*(?:\z|;)/
-
-      private
-      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
-          end
-        end
-        q
-      end
-    end
   end
 end

data/lib/accept_headers/charset.rb

@@ -5,8 +5,6 @@ module AcceptHeaders
     include Comparable
     include Acceptable
 
-    class InvalidCharsetError < Error; end
-
     attr_reader :charset
 
     def initialize(charset = '*', q: 1.0)
@@ -34,20 +32,14 @@ module AcceptHeaders
       "#{charset};q=#{qvalue}"
     end
 
-    def self.parse(original_header)
-      header = original_header.dup
-      header.sub!(/\AAccept-Charset:\s*/, '')
-      header.strip!
-      return [Charset.new('iso-8859-5', q: 1)] if header.empty?
-      charsets = []
-      header.split(',').each do |entry|
-        charset_arr = entry.split(';', 2)
-        next if charset_arr[0].nil?
-        charset = TOKEN_PATTERN.match(charset_arr[0])
-        next if charset.nil?
-        charsets << Charset.new(charset[:token], q: parse_q(charset_arr[1]))
+    def match(other)
+      if charset == other.charset
+        true
+      elsif other.charset == '*'
+        true
+      else
+        false
       end
-      charsets.sort! { |x,y| y <=> x }
     end
   end
 end

data/lib/accept_headers/charset/negotiator.rb

@@ -0,0 +1,27 @@
+require "accept_headers/charset"
+require "accept_headers/negotiatable"
+
+module AcceptHeaders
+  class Charset
+    class Negotiator
+      include Negotiatable
+
+      private
+      def parse(original_header)
+        header = original_header.dup
+        header.sub!(/\AAccept-Charset:\s*/, '')
+        header.strip!
+        return [Charset.new('iso-8859-5', q: 1)] if header.empty?
+        charsets = []
+        header.split(',').each do |entry|
+          charset_arr = entry.split(';', 2)
+          next if charset_arr[0].nil?
+          charset = TOKEN_PATTERN.match(charset_arr[0])
+          next if charset.nil?
+          charsets << Charset.new(charset[:token], q: parse_q(charset_arr[1]))
+        end
+        charsets.sort! { |x,y| y <=> x }
+      end
+    end
+  end
+end

data/lib/accept_headers/encoding.rb

@@ -5,8 +5,6 @@ module AcceptHeaders
     include Comparable
     include Acceptable
 
-    class InvalidEncodingError < Error; end
-
     attr_reader :encoding
 
     def initialize(encoding = '*', q: 1.0)
@@ -34,20 +32,14 @@ module AcceptHeaders
       "#{encoding};q=#{qvalue}"
     end
 
-    def self.parse(original_header)
-      header = original_header.dup
-      header.sub!(/\AAccept-Encoding:\s*/, '')
-      header.strip!
-      return [Charset.new] if header.empty?
-      encodings = []
-      header.split(',').each do |entry|
-        encoding_arr = entry.split(';', 2)
-        next if encoding_arr[0].nil?
-        encoding = TOKEN_PATTERN.match(encoding_arr[0])
-        next if encoding.nil?
-        encodings << Encoding.new(encoding[:token], q: parse_q(encoding_arr[1]))
+    def match(other)
+      if encoding == other.encoding
+        true
+      elsif other.encoding == '*'
+        true
+      else
+        false
       end
-      encodings.sort! { |x,y| y <=> x }
     end
   end
 end

data/lib/accept_headers/encoding/negotiator.rb

@@ -0,0 +1,27 @@
+require "accept_headers/encoding"
+require "accept_headers/negotiatable"
+
+module AcceptHeaders
+  class Encoding
+    class Negotiator
+      include Negotiatable
+
+      private
+      def parse(original_header)
+        header = original_header.dup
+        header.sub!(/\AAccept-Encoding:\s*/, '')
+        header.strip!
+        return [Charset.new] if header.empty?
+        encodings = []
+        header.split(',').each do |entry|
+          encoding_arr = entry.split(';', 2)
+          next if encoding_arr[0].nil?
+          encoding = TOKEN_PATTERN.match(encoding_arr[0])
+          next if encoding.nil?
+          encodings << Encoding.new(encoding[:token], q: parse_q(encoding_arr[1]))
+        end
+        encodings.sort! { |x,y| y <=> x }
+      end
+    end
+  end
+end

data/lib/accept_headers/language.rb

@@ -5,8 +5,6 @@ module AcceptHeaders
     include Comparable
     include Acceptable
 
-    class InvalidLanguageTagError < Error; end
-
     attr_reader :primary_tag, :subtag, :params
 
     def initialize(primary_tag = '*', subtag = nil, q: 1.0)
@@ -54,30 +52,16 @@ module AcceptHeaders
       "#{primary_tag}-#{subtag};q=#{qvalue}"
     end
 
-    LANGUAGE_PATTERN = /^\s*(?<primary_tag>[\w]{1,8}|\*)(?:\s*\-\s*(?<subtag>[\w]{1,8}|\*))?\s*$/
-
-    def self.parse(original_header)
-      header = original_header.dup
-      header.sub!(/\AAccept-Language:\s*/, '')
-      header.strip!
-      return [Language.new] if header.empty?
-      languages = []
-      header.split(',').each do |entry|
-        language_arr = entry.split(';', 2)
-        next if language_arr[0].nil?
-        language_range = LANGUAGE_PATTERN.match(language_arr[0])
-        next if language_range.nil?
-        begin
-          languages << Language.new(
-            language_range[:primary_tag],
-            language_range[:subtag],
-            q: parse_q(language_arr[1])
-          )
-        rescue Error
-          next
-        end
+    def match(other)
+      if primary_tag == other.primary_tag && subtag == other.subtag
+        true
+      elsif primary_tag == other.primary_tag && subtag == '*'
+        true
+      elsif other.primary_tag == '*'
+        true
+      else
+        false
       end
-      languages.sort! { |x,y| y <=> x }
     end
   end
 end