accept_headers 0.0.1

data/lib/accept_headers/media_type.rb

@@ -0,0 +1,114 @@
+require "accept_headers/acceptable"
+
+module AcceptHeaders
+  class MediaType
+    include Comparable
+    include Acceptable
+
+    attr_reader :type, :subtype, :params
+
+    def initialize(type = '*', subtype = '*', q: 1.0, params: {})
+      self.type = type
+      self.subtype = subtype
+      self.q = q
+      self.params = params
+    end
+
+    def <=>(other)
+      if q < other.q
+        -1
+      elsif q > other.q
+        1
+      elsif (type == '*' && other.type != '*') || (subtype == '*' && other.subtype != '*')
+        -1
+      elsif (type != '*' && other.type == '*') || (subtype != '*' && other.subtype == '*')
+        1
+      elsif params.size < other.params.size
+        -1
+      elsif params.size > other.params.size
+        1
+      else
+        0
+      end
+    end
+
+    def type=(value)
+      @type = value.strip.downcase
+    end
+
+    def subtype=(value)
+      @subtype = if value.nil? && type == '*'
+        '*'
+      else
+        value.strip.downcase
+      end
+    end
+
+    def params=(hash)
+      @params = {}
+      hash.each do |k,v|
+        @params[k.strip] = v.strip
+      end
+      @params
+    end
+
+    def to_h
+      {
+        type: type,
+        subtype: subtype,
+        q: q,
+        params: params
+      }
+    end
+
+    def to_s
+      qvalue = (q == 0 || q == 1) ? q.to_i : q
+      string = "#{type}/#{subtype};q=#{qvalue}"
+      if params.size > 0
+        params.each { |k, v| string.concat(";#{k}=#{v}") }
+      end
+      string
+    end
+
+    MEDIA_TYPE_PATTERN = /^\s*(?<type>[\w!#$%^&*\-\+{}\\|'.`~]+)(?:\s*\/\s*(?<subtype>[\w!#$%^&*\-\+{}\\|'.`~]+))?\s*$/
+    PARAM_PATTERN = /(?<attribute>[\w!#$%^&*\-\+{}\\|'.`~]+)\s*\=\s*(?:\"(?<value>[^"]*)\"|\'(?<value>[^']*)\'|(?<value>[\w!#$%^&*\-\+{}\\|\'.`~]*))/
+
+    def self.parse(original_header)
+      header = original_header.dup
+      header.sub!(/\AAccept:\s*/, '')
+      header.strip!
+      return [MediaType.new] if header.empty?
+      media_types = []
+      header.split(',').each do |entry|
+        accept_media_range, accept_params = entry.split(';', 2)
+        next if accept_media_range.nil?
+        media_range = MEDIA_TYPE_PATTERN.match(accept_media_range)
+        next if media_range.nil?
+        begin
+          media_types << MediaType.new(
+            media_range[:type],
+            media_range[:subtype],
+            q: parse_q(accept_params),
+            params: parse_params(accept_params)
+          )
+        rescue Error
+          next
+        end
+      end
+      media_types.sort! { |x,y| y <=> x }
+    end
+
+    private
+
+    def self.parse_params(params_string)
+      params = {}
+      return params if !params_string || params_string.empty?
+      params_string.split(';').each do |part|
+        param = PARAM_PATTERN.match(part)
+        params[param[:attribute]] = param[:value] if param
+      end
+      params.delete('q')
+      params
+    end
+  end
+end

data/lib/accept_headers/version.rb

@@ -0,0 +1,3 @@
+module AcceptHeaders
+  VERSION = "0.0.1"
+end

data/spec/charset_spec.rb

@@ -0,0 +1,126 @@
+require_relative "spec_helper"
+
+module AcceptHeaders
+  describe Charset do
+    subject do
+      AcceptHeaders::Charset
+    end
+
+    it "defaults charset to *" do
+      subject.new.charset.must_equal '*'
+    end
+
+    it "strips and downcases the charset" do
+      subject.new("\t\nISO-8859-1\s\r").charset.must_equal "iso-8859-1"
+    end
+
+    it "optionally supports a q argument" do
+      subject.new('iso-8859-1', q: 0.8).q.must_equal 0.8
+    end
+
+    it "compares on q value all other values remaining equal" do
+      subject.new(q: 0.514).must_be :>, subject.new(q: 0.1)
+      subject.new(q: 0).must_be :<, subject.new(q: 1)
+      subject.new(q: 0.9).must_equal subject.new(q: 0.9)
+    end
+
+    it "raises an InvalidQError if q can't be converted to a float" do
+      e = -> do
+        subject.new('iso-8859-1', q: 'a')
+      end.must_raise Charset::InvalidQError
+
+      e.message.must_equal 'invalid value for Float(): "a"'
+
+      subject.new('iso-8859-1', q: '1')
+    end
+
+    it "raises an OutOfRangeError unless q value is between 0 and 1" do
+      [-1.0, -0.1, 1.1].each do |q|
+        e = -> do
+          subject.new('iso-8859-1', q: q)
+        end.must_raise Charset::OutOfRangeError
+
+        e.message.must_equal "q must be between 0 and 1"
+      end
+
+      subject.new('iso-8859-1', q: 1)
+      subject.new('unicode-1-1', q: 0)
+    end
+
+    it "raises an InvalidPrecisionError if q has more than a precision of 3" do
+      e = -> do
+        subject.new('iso-8859-1', q: 0.1234)
+      end.must_raise Charset::InvalidPrecisionError
+
+      e.message.must_equal "q must be at most 3 decimal places"
+
+      subject.new('iso-8859-1', q: 0.123)
+    end
+
+    it "converts to hash" do
+      subject.new('iso-8859-1').to_h.must_equal({
+        charset: 'iso-8859-1',
+        q: 1.0
+      })
+    end
+
+    it "convers to string" do
+      s = subject.new('iso-8859-1', q: 0.9).to_s
+      s.must_equal "iso-8859-1;q=0.9"
+    end
+
+    describe "parsing an accept header" do
+      it "returns a sorted array of charsets" do
+        subject.parse("*; q=0.2, unicode-1-1").must_equal [
+          Charset.new('unicode-1-1'),
+          Charset.new('*', q: 0.2)
+        ]
+
+        subject.parse("us-ascii; q=0.5, iso-8859-1, utf-8; q=0.8, macintosh").must_equal [
+          Charset.new('iso-8859-1'),
+          Charset.new('macintosh'),
+          Charset.new('utf-8', q: 0.8),
+          Charset.new('us-ascii', q: 0.5)
+        ]
+      end
+
+      it "sets charset to * when the accept-charset header is empty" do
+        subject.parse('').must_equal [
+          Charset.new('*')
+        ]
+      end
+
+      it "defaults q to 1 if it's not explicitly specified" do
+        subject.parse("iso-8859-1").must_equal [
+          Charset.new('iso-8859-1', q: 1.0)
+        ]
+      end
+
+      it "strips whitespace from between charsets" do
+        subject.parse("\tunicode-1-1\r,\niso-8859-1\s").must_equal [
+          Charset.new('unicode-1-1'),
+          Charset.new('iso-8859-1')
+        ]
+      end
+
+      it "strips whitespace around q" do
+        subject.parse("iso-8859-1;\tq\r=\n1, unicode-1-1;q=0.8\n").must_equal [
+          Charset.new('iso-8859-1'),
+          Charset.new('unicode-1-1', q: 0.8)
+        ]
+      end
+
+      it "has a q value of 0.001 when parsed q is invalid" do
+        subject.parse("iso-8859-1;q=x").must_equal [
+          Charset.new('iso-8859-1', q: 0.001)
+        ]
+      end
+
+      it "skips invalid character sets" do
+        subject.parse("iso-8859-1, @unicode-1-1").must_equal [
+          Charset.new('iso-8859-1', q: 1)
+        ]
+      end
+    end
+  end
+end

data/spec/encoding_spec.rb

@@ -0,0 +1,126 @@
+require_relative "spec_helper"
+
+module AcceptHeaders
+  describe Encoding do
+    subject do
+      AcceptHeaders::Encoding
+    end
+
+    it "defaults encoding to *" do
+      subject.new.encoding.must_equal '*'
+    end
+
+    it "strips and downcases the encoding" do
+      subject.new("\t\nGZIP\s\r").encoding.must_equal "gzip"
+    end
+
+    it "optionally supports a q argument" do
+      subject.new('gzip', q: 0.8).q.must_equal 0.8
+    end
+
+    it "compares on q value all other values remaining equal" do
+      subject.new(q: 0.514).must_be :>, subject.new(q: 0.1)
+      subject.new(q: 0).must_be :<, subject.new(q: 1)
+      subject.new(q: 0.9).must_equal subject.new(q: 0.9)
+    end
+
+    it "raises an InvalidQError if q can't be converted to a float" do
+      e = -> do
+        subject.new('gzip', q: 'a')
+      end.must_raise Encoding::InvalidQError
+
+      e.message.must_equal 'invalid value for Float(): "a"'
+
+      subject.new('gzip', q: '1')
+    end
+
+    it "raises an OutOfRangeError unless q value is between 0 and 1" do
+      [-1.0, -0.1, 1.1].each do |q|
+        e = -> do
+          subject.new('gzip', q: q)
+        end.must_raise Encoding::OutOfRangeError
+
+        e.message.must_equal "q must be between 0 and 1"
+      end
+
+      subject.new('gzip', q: 1)
+      subject.new('compress', q: 0)
+    end
+
+    it "raises an InvalidPrecisionError if q has more than a precision of 3" do
+      e = -> do
+        subject.new('gzip', q: 0.1234)
+      end.must_raise Encoding::InvalidPrecisionError
+
+      e.message.must_equal "q must be at most 3 decimal places"
+
+      subject.new('gzip', q: 0.123)
+    end
+
+    it "converts to hash" do
+      subject.new('gzip').to_h.must_equal({
+        encoding: 'gzip',
+        q: 1.0
+      })
+    end
+
+    it "convers to string" do
+      s = subject.new('gzip', q: 0.9).to_s
+      s.must_equal "gzip;q=0.9"
+    end
+
+    describe "parsing an accept header" do
+      it "returns a sorted array of encodings" do
+        subject.parse("*; q=0.2, compress").must_equal [
+          Encoding.new('compress'),
+          Encoding.new('*', q: 0.2)
+        ]
+
+        subject.parse("deflate; q=0.5, gzip, compress; q=0.8, identity").must_equal [
+          Encoding.new('gzip'),
+          Encoding.new('identity'),
+          Encoding.new('compress', q: 0.8),
+          Encoding.new('deflate', q: 0.5)
+        ]
+      end
+
+      it "sets encoding to * when the accept-encoding header is empty" do
+        subject.parse('').must_equal [
+          Encoding.new('*')
+        ]
+      end
+
+      it "defaults q to 1 if it's not explicitly specified" do
+        subject.parse("gzip").must_equal [
+          Encoding.new('gzip', q: 1.0)
+        ]
+      end
+
+      it "strips whitespace from between encodings" do
+        subject.parse("\tcompress\r,\ngzip\s").must_equal [
+          Encoding.new('compress'),
+          Encoding.new('gzip')
+        ]
+      end
+
+      it "strips whitespace around q" do
+        subject.parse("gzip;\tq\r=\n1, compress;q=0.8\n").must_equal [
+          Encoding.new('gzip'),
+          Encoding.new('compress', q: 0.8)
+        ]
+      end
+
+      it "has a q value of 0.001 when parsed q is invalid" do
+        subject.parse("gzip;q=x").must_equal [
+          Encoding.new('gzip', q: 0.001)
+        ]
+      end
+
+      it "skips invalid encodings" do
+        subject.parse("gzip, @blah").must_equal [
+          Encoding.new('gzip', q: 1.0)
+        ]
+      end
+    end
+  end
+end

data/spec/language_spec.rb

@@ -0,0 +1,149 @@
+require_relative "spec_helper"
+
+module AcceptHeaders
+  describe Language do
+    subject do
+      AcceptHeaders::Language
+    end
+
+    it "defaults primary tag to *" do
+      subject.new.primary_tag.must_equal '*'
+    end
+
+    it "defaults subtag to *" do
+      subject.new('en').subtag.must_equal '*'
+    end
+
+    it "strips and downcases the primary tag" do
+      subject.new("\t\nEN\s\r", '*').primary_tag.must_equal "en"
+    end
+
+    it "strips and downcases the subtag" do
+      subject.new("en", "\s\nUS\r\t").subtag.must_equal "us"
+    end
+
+    it "sets subtag to * if value passed in is nil and primary tag is *" do
+      subject.new('*', nil).subtag.must_equal '*'
+    end
+
+    it "optionally supports a q argument" do
+      subject.new('en', 'us', q: 0.8).q.must_equal 0.8
+    end
+
+    it "compares on q value all other values remaining equal" do
+      subject.new(q: 0.514).must_be :>, subject.new(q: 0.1)
+      subject.new(q: 0).must_be :<, subject.new(q: 1)
+      subject.new(q: 0.9).must_equal subject.new(q: 0.9)
+    end
+
+    it "compares on subtag then primary tag all other values remaining equal" do
+      subject.new('en', 'us').must_be :>, subject.new('en', '*')
+      subject.new('*', '*').must_be :<, subject.new('en', '*')
+    end
+
+    it "raises an InvalidQError if q can't be converted to a float" do
+      e = -> do
+        subject.new('en', 'us', q: 'a')
+      end.must_raise Language::InvalidQError
+
+      e.message.must_equal 'invalid value for Float(): "a"'
+
+      subject.new('en', 'us', q: '1')
+    end
+
+    it "raises an OutOfRangeError unless q value is between 0 and 1" do
+      [-1.0, -0.1, 1.1].each do |q|
+        e = -> do
+          subject.new('en', 'us', q: q)
+        end.must_raise Language::OutOfRangeError
+
+        e.message.must_equal "q must be between 0 and 1"
+      end
+
+      subject.new('en', 'us', q: 1)
+      subject.new('en', 'gb', q: 0)
+    end
+
+    it "raises an InvalidPrecisionError if q has more than a precision of 3" do
+      e = -> do
+        subject.new('en', 'us', q: 0.1234)
+      end.must_raise Language::InvalidPrecisionError
+
+      e.message.must_equal "q must be at most 3 decimal places"
+
+      subject.new('en', 'us', q: 0.123)
+    end
+
+    it "converts to hash" do
+      subject.new('en', 'us').to_h.must_equal({
+        primary_tag: 'en',
+        subtag: 'us',
+        q: 1.0
+      })
+    end
+
+    it "convers to string" do
+      s = subject.new('en', 'us', q: 0.9).to_s
+      s.must_equal "en-us;q=0.9"
+    end
+
+    describe "parsing an accept header" do
+      it "returns a sorted array of media primary tags" do
+        subject.parse("en-*;q=0.2, en-us").must_equal [
+          Language.new('en', 'us'),
+          Language.new('en', '*', q: 0.2)
+        ]
+
+        subject.parse("en-*, en-us, *;q=0.8").must_equal [
+          Language.new('en', 'us'),
+          Language.new('en', '*'),
+          Language.new('*', '*', q: 0.8)
+        ]
+      end
+
+      it "sets media primary tag to */* when the accept header is empty" do
+        subject.parse('').must_equal [
+          Language.new('*', '*')
+        ]
+      end
+
+      it "sets media primary tag to */* when the primary tag is only *" do
+        subject.parse('*').must_equal [
+          Language.new('*', '*')
+        ]
+      end
+
+      it "defaults q to 1 if it's not explicitly specified" do
+        subject.parse("en-us").must_equal [
+          Language.new('en', 'plain', q: 1.0)
+        ]
+      end
+
+      it "strips whitespace from between media primary tags" do
+        subject.parse("\ten-us\r,\nen-gb\s").must_equal [
+          Language.new('en', 'us'),
+          Language.new('en', 'gb')
+        ]
+      end
+
+      it "strips whitespace around q" do
+        subject.parse("en-us;\tq\r=\n1, en-gb").must_equal [
+          Language.new('en', 'us'),
+          Language.new('en', 'gb')
+        ]
+      end
+
+      it "has a q value of 0.001 when parsed q is invalid" do
+        subject.parse("en-us;q=x").must_equal [
+          Language.new('en', 'plain', q: 0.001)
+        ]
+      end
+
+      it "skips invalid media primary tags" do
+        subject.parse("en-us, en-us-omg;q=0.9").must_equal [
+          Language.new('en', 'us', q: 1)
+        ]
+      end
+    end
+  end
+end