accept_headers 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3e4d8ab6edced3cc033d6a693d51c7cbd9fee32d
+  data.tar.gz: 2fe2cf946fe203666424c666fb9d00e1fb3d9eb0
+SHA512:
+  metadata.gz: e9dc99f82ca6f752b2f6d562ad63c93aa8e32527a41910e0935d58137349d47b82a1ed2f69bb7b4c52f030281e551dba84a2dd3f49c5e93e1c890b2d77161002
+  data.tar.gz: 92c33af011978e0dbbaa9d88d0c060368edb969dfea3e73e072754e4ae4d1c634643f6ef6a834b22c45ad46194be7cd313e073a57188b6ac74eff41d5d0a8487

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.travis.yml

@@ -0,0 +1,17 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 2.1.5
+  - rbx
+  - ruby-head
+  - jruby-head
+
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-head
+    - rvm: rbx
+
+addons:
+  code_climate:
+    repo_token: 50c636c924d1aa253e29c57822931c1a172cd65675ad66396bba39d255373a58

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.1 / November 14, 2014
+
+  * Initial release

data/Gemfile

@@ -0,0 +1,16 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in retriable.gemspec
+gemspec
+
+group :test do
+  gem "ruby_gntp"
+  gem "minitest-focus"
+  gem "codeclimate-test-reporter"
+  gem "simplecov"
+end
+
+group :development, :test do
+  gem "pry"
+  gem "awesome_print"
+end

data/Guardfile

@@ -0,0 +1,9 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :minitest do
+  watch(%r{^spec/(.*)_spec\.rb$})
+  watch(%r{^lib/accept_headers/(.+)\.rb$})       { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^spec/spec_helper\.rb$})              { 'spec' }
+  watch(%r{^lib/accept_headers/acceptable\.rb$}) { 'spec' }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Jack Chu
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,117 @@
+[![Build Status](https://travis-ci.org/kamui/accept_headers.png)](https://travis-ci.org/kamui/accept_headers)
+[![Code Climate](https://codeclimate.com/github/kamui/accept_headers/badges/gpa.svg)](https://codeclimate.com/github/kamui/accept_headers)
+[![Test Coverage](https://codeclimate.com/github/kamui/accept_headers/badges/coverage.svg)](https://codeclimate.com/github/kamui/accept_headers)
+
+# AcceptHeaders
+
+**AcceptHeaders** is a ruby library that parses and sorts http accept headers.
+
+Some features of the library are:
+
+  * Strict adherence to [RFC 2616][rfc], specifically [section 14][rfc-sec14]
+  * Full support for the [Accept][rfc-sec14-1], [Accept-Charset][rfc-sec14-2],
+    [Accept-Encoding][rfc-sec14-3], and [Accept-Language][rfc-sec14-4] HTTP
+    request headers
+  * A comprehensive [spec suite][spec] that covers many edge cases
+
+[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-2]: http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.2
+[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
+[spec]: http://github.com/kamui/accept_headers/tree/master/spec/
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'accept_headers'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install accept_headers
+
+## 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.
+
+```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")
+```
+
+Will generate this equivalent array:
+
+```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)
+]
+```
+
+Parsing `Charset`:
+
+```ruby
+AcceptHeaders::Charset.parse("us-ascii; q=0.5, iso-8859-1, utf-8; q=0.8, macintosh")
+```
+
+generates:
+
+```ruby
+[
+  Charset.new('iso-8859-1'),
+  Charset.new('macintosh'),
+  Charset.new('utf-8', q: 0.8),
+  Charset.new('us-ascii', q: 0.5)
+]
+```
+
+Parsing `Encoding`:
+
+```ruby
+AcceptHeaders::Encoding.parse("deflate; q=0.5, gzip, compress; q=0.8, identity")
+```
+
+generates:
+
+```ruby
+[
+  Encoding.new('gzip'),
+  Encoding.new('identity'),
+  Encoding.new('compress', q: 0.8),
+  Encoding.new('deflate', q: 0.5)
+]
+```
+
+Parsing `Language`:
+
+```ruby
+AcceptHeaders::Language.parse("en-*, en-us, *;q=0.8")
+```
+
+generates:
+
+```ruby
+[
+  Language.new('en', 'us'),
+  Language.new('en', '*'),
+  Language.new('*', '*', q: 0.8)
+]
+```
+
+## 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

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+task default: :test
+
+Rake::TestTask.new do |t|
+  t.libs << "spec"
+  t.test_files = FileList['spec/*_spec.rb']
+  t.verbose = true
+end

data/accept_headers.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'accept_headers/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "accept_headers"
+  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.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+
+  spec.add_development_dependency "minitest", "~> 5.4"
+  spec.add_development_dependency "guard"
+  spec.add_development_dependency "guard-minitest"
+end

data/lib/accept_headers.rb

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

data/lib/accept_headers/acceptable.rb

@@ -0,0 +1,51 @@
+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
+    end
+
+    def q=(value)
+      begin
+        q_float = Float(value)
+      rescue ArgumentError => e
+        raise InvalidQError.new(e.message)
+      end
+      if !q_float.between?(0.0, 1.0)
+        raise OutOfRangeError.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")
+      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

@@ -0,0 +1,53 @@
+require "accept_headers/acceptable"
+
+module AcceptHeaders
+  class Charset
+    include Comparable
+    include Acceptable
+
+    class InvalidCharsetError < Error; end
+
+    attr_reader :charset
+
+    def initialize(charset = '*', q: 1.0)
+      self.charset = charset
+      self.q = q
+    end
+
+    def <=>(other)
+      q <=> other.q
+    end
+
+    def charset=(value)
+      @charset = value.strip.downcase
+    end
+
+    def to_h
+      {
+        charset: charset,
+        q: q
+      }
+    end
+
+    def to_s
+      qvalue = (q == 0 || q == 1) ? q.to_i : q
+      "#{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]))
+      end
+      charsets.sort! { |x,y| y <=> x }
+    end
+  end
+end

data/lib/accept_headers/encoding.rb

@@ -0,0 +1,53 @@
+require "accept_headers/acceptable"
+
+module AcceptHeaders
+  class Encoding
+    include Comparable
+    include Acceptable
+
+    class InvalidEncodingError < Error; end
+
+    attr_reader :encoding
+
+    def initialize(encoding = '*', q: 1.0)
+      self.encoding = encoding
+      self.q = q
+    end
+
+    def <=>(other)
+      q <=> other.q
+    end
+
+    def encoding=(value)
+      @encoding = value.strip.downcase
+    end
+
+    def to_h
+      {
+        encoding: encoding,
+        q: q
+      }
+    end
+
+    def to_s
+      qvalue = (q == 0 || q == 1) ? q.to_i : q
+      "#{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]))
+      end
+      encodings.sort! { |x,y| y <=> x }
+    end
+  end
+end

data/lib/accept_headers/language.rb

@@ -0,0 +1,83 @@
+require "accept_headers/acceptable"
+
+module AcceptHeaders
+  class Language
+    include Comparable
+    include Acceptable
+
+    class InvalidLanguageTagError < Error; end
+
+    attr_reader :primary_tag, :subtag, :params
+
+    def initialize(primary_tag = '*', subtag = nil, q: 1.0)
+      self.primary_tag = primary_tag
+      self.subtag = subtag
+      self.q = q
+    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
+    end
+
+    def primary_tag=(value)
+      @primary_tag = value.strip.downcase
+    end
+
+    def subtag=(value)
+      @subtag = if value.nil?
+        '*'
+      else
+        value.strip.downcase
+      end
+    end
+
+    def to_h
+      {
+        primary_tag: primary_tag,
+        subtag: subtag,
+        q: q
+      }
+    end
+
+    def to_s
+      qvalue = (q == 0 || q == 1) ? q.to_i : q
+      "#{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
+      end
+      languages.sort! { |x,y| y <=> x }
+    end
+  end
+end