scorched-accept 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 46ea82e8392e2bba39152ce99220a4f0b36e13a1
+  data.tar.gz: 4a38940f1c317f5a4f23f5ca2f10e86f6d66e51e
+SHA512:
+  metadata.gz: 6a33772055e16ad5b267eea0107e6cd3be945543787e65365fedcce77ab7d5b14672813ebc66501011c0a1344526ce6a95ff409d2d2019d420a54be72f564196
+  data.tar.gz: d6ee7e415e5182831764acccd8cc2f1e68c0d345acbc60ce5843933d94b5c2af4c02a9ab861b8d622cf266047b96bd597572cfa576c9a8db1a115ed499bc120a

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/Gemfile.lock

@@ -0,0 +1,26 @@
+PATH
+  remote: .
+  specs:
+    scorched-accept (0.1)
+      parslet (~> 1.7)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    blankslate (3.1.3)
+    maxitest (1.4.1)
+      minitest (>= 5.0.0, < 5.6.0)
+    minitest (5.5.1)
+    parslet (1.7.0)
+      blankslate (>= 2.0, <= 4.0)
+    rack (1.6.0)
+    rack-test (0.6.3)
+      rack (>= 1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  maxitest (~> 1.4)
+  rack-test (~> 0.6)
+  scorched-accept!

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2015 Tom Wardrop
+
+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,18 @@
+An accept header parser and API. Contains nothing Scorched specific, it's only named such because every other obvious
+name has been used by the other libraries already in existence, none of which actually parse the accept header
+correctly, or implement proper prioritisation of media ranges.
+
+Example
+-------
+```ruby
+accept_header = AcceptHeader.new('text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8')
+accept_header.best_of('application/json', 'video/mp4')
+```
+
+Refer to specs and API documentation for more information.
+
+Tests
+-----
+```bash
+mtest spec
+```

data/TODO.md

@@ -0,0 +1,4 @@
+Things To Do
+============
+
+* Precompile treetop parsers as part of the release process.

data/lib/scorched/accept.rb

@@ -0,0 +1,7 @@
+require_relative './accept/accept_header'
+require_relative './accept/rack'
+
+module Scorched
+  module Accept
+  end
+end

data/lib/scorched/accept/accept_header.rb

@@ -0,0 +1,130 @@
+# encoding: US-ASCII
+require 'parslet'
+
+module Scorched
+  module Accept
+    DEFAULT_QVALUE = 1
+
+    class AcceptHeader
+      include Enumerable
+
+      def initialize(raw_str = nil)
+        @raw_str = (raw_str && not(raw_str =~ /^\s*$/)) ? raw_str : '*/*'
+      end
+
+      # Returns true if the given media type is acceptable.
+      def acceptable?(media_type)
+        !matches(media_type).empty?
+      end
+
+      # Ranks the supplied media type based on its appropriatness. Scores range from 0 (the most appropriate), to
+      # `n-1`, where `n` is the number of media types defined in the accept header of the request. If _invert_ is true,
+      # `n-1` is returned for the most appropriate match, and 0 for the least appropriate. `nil` is returned if
+      # the media type is unacceptable.
+      def rank(media_type, invert = false)
+        match = matches(media_type).first
+        if(invert)
+          match && length - 1 - match.last
+        else
+          match && match.last
+        end
+      end
+
+      # Of the media types given, returns the most appropriate. If none are appropriate, returns nil. If all media types
+      # are of equal appropriatness, or multiple media types are equal best, the media type that was listed highest in
+      # argument list is returned.
+      def best_of(*media_types)
+        media_types.min_by { |m| rank(m) }
+      end
+
+      # Returns a hash with each media range as the key, and the rest of the attributes as the value.
+      # Possible attributes are: :parameters, :q, and :extensions.
+      def to_h
+        @to_h ||= ordered_values.map { |v|
+          v = v.dup
+          media_type = v.delete(:media_type)
+          [media_type, v]
+        }.to_h
+      end
+
+      def values
+        @values ||= AcceptHeaderTransform.new.apply(AcceptHeaderParser.new.parse(@raw_str))
+      end
+
+      # Orders media ranges based on q-value, specificity, and the order they are defined
+      def ordered_values
+        @ordered_values ||= values.sort_by { |m| [m[:q] || DEFAULT_QVALUE, specificity(m)] }.reverse
+      end
+
+      # Enumerabilitisationing
+      def each(*args, &block)
+        ordered_values.each(*args, &block)
+      end
+
+      # Returns the number of media range definitions in the accept header of the request.
+      def length
+        values.length
+      end
+
+    protected
+
+      def matches(media_type)
+        matched = {}
+        ordered_values.each_with_index do |v,i|
+          matched[v] = i if Regexp.new(v[:media_type].split('/').map { |v| v == '*' ? '.+' : v }.join('/')) =~ media_type
+        end
+        matched
+      end
+
+      # Returns a number representing how specific the media range definition is. Higher numbers represent a more
+      # specific media range definition.
+      def specificity(m)
+        if m[:media_type] == '*/*' then 0
+        elsif m[:media_type] =~ %r{/\*$} then 1
+        else 2 + (m[:parameters] ? m[:parameters].count : 0)
+        end
+      end
+    end
+
+    class AcceptHeaderParser < Parslet::Parser
+      root(:accept)
+      rule(:accept) { (accept_element >> (ows >> str(",") >> accept_element).repeat).as(:accept) >> ows }
+      rule(:accept_element) { ows >> (media_range >> (ows >> accept_params).maybe).as(:accept_element) }
+      rule(:media_range) { (str("*/*") | (token >> str('/') >> str('*').as(:subtype)) | (token >> str("/") >> token.as(:subtype))).as(:media_type) >> (ows >> str(";") >> ows >> parameter).repeat.as(:parameters) }
+      rule(:accept_params) { str(";") >> ows >> str("q=") >> qvalue.as(:q) >> extension.repeat.as(:extensions) }
+      rule(:extension) { ows >> str(";") >> ows >> token.as(:key) >> (str("=") >> (token | quoted_string).as(:value)).maybe }
+      rule(:parameter) { str("q").absent? >> token.as(:key) >> str("=") >> (token | quoted_string).as(:value) }
+      rule(:token) { tchar.repeat(1).as(:token) }
+      rule(:qvalue) { (str("0") >> (str(".") >> digit.repeat(0,3)).maybe | str("1") >> (str(".") >> str("0").repeat(0,3)).maybe).as(:qvalue) }
+      rule(:quoted_string) { str('"') >> (qdtext | quoted_pair).repeat.as(:quoted_string) >> str('"') }
+      rule(:qdtext) { (match["\t !#-\\[\\]-~"] | obs_text).as(:qdtext) }
+      rule(:obs_text) { match["\x80-\xFF"] }
+      rule(:quoted_pair) { (str("\\") >> (match["\t "] | vchar | obs_text)).as(:quoted_pair) }
+      rule(:tchar) { match["!#$%&'*+\\-.^_`|~"] | digit | alpha }
+      rule(:vchar) { match["\x20-\x7E"] }
+      rule(:ows) { match["\t "].repeat }
+      rule(:alpha) { match["a-zA-Z"] }
+      rule(:digit) { match["0-9"] }
+    end
+
+    class AcceptHeaderTransform < Parslet::Transform
+      rule(accept: subtree(:x)) do
+        Array === x ? x : [x]
+      end
+      rule(accept_element: subtree(:x)) do
+        x[:media_type] = (x[:media_type].respond_to? :values) ? x[:media_type].values.join("/") : x[:media_type].to_s
+        x[:parameters] = x[:parameters].reduce(&:merge) if x[:parameters].respond_to? :reduce
+        x[:extensions] = x[:extensions].reduce(&:merge) if x[:extensions].respond_to? :reduce
+        x.delete_if { |k,v| v.nil? }
+      end
+      rule(media_type: subtree(:x)) { x.values.join('/') }
+      rule(key: simple(:k), value: simple(:v)) { {k.to_sym => v} }
+      rule(token: simple(:t)) { t.to_s }
+      rule(quoted_string: sequence(:x)) { x.join }
+      rule(qvalue: simple(:x)) { x.to_f }
+      rule(qdtext: simple(:x)) { x.to_s }
+      rule(quoted_pair: simple(:x)) { x.to_s[1] }
+      rule(ows: simple(:x)) { " " }
+    end
+  end
+end

data/lib/scorched/accept/rack.rb

@@ -0,0 +1,15 @@
+module Scorched
+  module Accept
+    class Rack
+      def initialize(app, env_prefix = 'scorched')
+        @app = app
+        @env_prefix = env_prefix
+      end
+
+      def call(env)
+        env["#{@env_prefix}.accept"] = {accept: AcceptHeader.new(env["HTTP_ACCEPT"])}
+        @app.call(env)
+      end
+    end
+  end
+end

data/scorched-accept.gemspec

@@ -0,0 +1,19 @@
+$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
+
+Gem::Specification.new 'scorched-accept', '0.1' do |s|
+  s.summary           = 'HTTP accept header parser'
+  s.description       = 'A parser for parsing the accept headers of a HTTP request'
+  s.authors           = ['Tom Wardrop']
+  s.email             = 'tom@tomwardrop.com'
+  s.homepage          = 'http://github.com/wardrop/scorched-accept'
+  s.license           = 'MIT'
+  s.files             = Dir.glob(`git ls-files`.split("\n") - %w[.gitignore])
+  s.test_files        = Dir.glob('spec/**/*_spec.rb')
+  s.rdoc_options      = %w[--line-numbers --inline-source --title Scorched::Accept --encoding=UTF-8]
+
+  s.required_ruby_version = '>= 2.0.0'
+
+  s.add_dependency 'parslet', '~> 1.7'
+  s.add_development_dependency 'rack-test', '~> 0.6'
+  s.add_development_dependency 'maxitest', '~>1.4'
+end

data/spec/accept_header_parser_spec.rb

@@ -0,0 +1,24 @@
+#require_relative './spec_helper.rb'
+require_relative "../lib/scorched/accept/accept_header"
+require "maxitest/autorun"
+
+module Scorched
+  module Accept
+    describe AcceptHeaderParser do
+      it "parses correctly" do
+        tree = AcceptHeaderParser.new.parse(' text/plain; name=bob ; age=19; q=0.10; dog="r\o\o\\f\" bark"; cat=meow, */*, video/*')
+        AcceptHeaderTransform.new.apply(tree).must_equal([
+          {media_type: "text/plain", parameters: {name: "bob", age: "19"}, q: 0.1, extensions: {dog: %q{roof" bark}, cat: "meow"}},
+          {media_type: "*/*"},
+          {media_type: "video/*"}
+        ])
+
+        lambda { AcceptHeaderParser.new.parse('text/plain; name = bob') }.must_raise Parslet::ParseFailed
+      end
+
+      it "deals with a single media range correctly" do
+        AcceptHeaderTransform.new.apply(AcceptHeaderParser.new.parse('*/*')).must_equal [{:media_type=>"*/*"}]
+      end
+    end
+  end
+end

data/spec/accept_header_spec.rb

@@ -0,0 +1,82 @@
+require_relative './spec_helper.rb'
+
+module Scorched
+  module Accept
+    describe "AcceptHeader" do
+      let_all :long_header do
+        '*/*, text/html;level=3,video/webm;codecs=vp8;videoonly=1, text/*, video/*;q=0.4, application/json, text/plain'
+      end
+
+      let_all :short_header do
+        'text/*;encoding=utf-8;q=1;speed=high, video/mpeg'
+      end
+
+      # How the `long_header` should be once parsed and ordered.
+      let_all :long_header_ordered do
+        %w{
+          video/webm
+          text/html
+          application/json
+          text/plain
+          text/*
+          */*
+          video/*
+        }
+      end
+
+      let :accept_header do
+        AcceptHeader.new(long_header)
+      end
+
+      it "orders media ranges based on qvalue, specificity, and the order they are defined" do
+        accept_header.ordered_values.map { |v| v[:media_type] }.must_equal long_header_ordered
+      end
+
+      it "determines whether a media type is acceptable or not" do
+        accept_header.acceptable?('text/html').must_equal true
+        accept_header.acceptable?('large/dog').must_equal true
+        AcceptHeader.new(short_header).acceptable?('video/mp4').must_equal false
+      end
+
+      it "ranks a media type against list of acceptable media types" do
+        accept_header.rank('text/x-markdown').must_equal long_header_ordered.index('text/*')
+        accept_header.rank('video/mpeg').must_equal long_header_ordered.index('*/*')
+        AcceptHeader.new(short_header).rank('video/mp4').must_equal nil
+        # Test inverting
+        accept_header.rank('text/x-markdown', true).must_equal long_header_ordered.reverse.index('text/*')
+      end
+
+      it "selects the most appropriate media type out of an array" do
+        accept_header.best_of('text/plain', 'text/html').must_equal 'text/html'
+        accept_header.best_of('video/mpeg', 'text/x-markdown', 'cat/meow').must_equal 'text/x-markdown'
+        AcceptHeader.new(short_header).rank('video/mp4').must_equal nil
+
+        # Uses the order of arguments if the provided arguments are equally acceptable.
+        accept_header.best_of('dog/roof', 'cat/meow').must_equal 'dog/roof'
+      end
+
+      it "can return a hash" do
+        AcceptHeader.new(short_header).to_h.must_equal(
+          'video/mpeg' => {},
+          'text/*' => {parameters: {encoding: 'utf-8'}, q: 1, extensions: {speed: 'high'}}
+        )
+      end
+
+      it "is enumerable" do
+        AcceptHeader.include?(Enumerable).must_equal true
+        accept_header.map { |v| v[:media_type] }[-2].must_equal long_header_ordered[-2]
+      end
+
+      it "tells you how many media ranges were parsed" do
+        accept_header.length.must_equal long_header_ordered.length
+      end
+
+      it "gracefully handles not being given an accept header string" do
+        AcceptHeader.new.length.must_equal 1
+        AcceptHeader.new.acceptable?('text/html').must_equal true
+        AcceptHeader.new(nil).length.must_equal 1
+        AcceptHeader.new(' ').length.must_equal 1
+      end
+    end
+  end
+end

data/spec/rack_spec.rb

@@ -0,0 +1,20 @@
+require_relative './spec_helper.rb'
+require_relative "../lib/scorched/accept"
+
+module Scorched
+  module Accept
+    describe "Rack" do
+
+      it "adds an AcceptHeader instance to Rack env" do
+        internal_env = nil
+        rt = ::Rack::Test::Session.new(::Rack::Builder.new do
+          internal_env = nil
+          use Scorched::Accept::Rack
+          run proc { |env| internal_env = env; [200, {}, 'ok'] }
+        end)
+        rt.get('/')
+        internal_env['scorched.accept'][:accept].must_be_instance_of Scorched::Accept::AcceptHeader
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+ENV['RACK_ENV'] = 'production'
+
+require 'maxitest'
+require 'rack/test'

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: scorched-accept
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Tom Wardrop
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: maxitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+description: A parser for parsing the accept headers of a HTTP request
+email: tom@tomwardrop.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- TODO.md
+- lib/.DS_Store
+- lib/scorched/accept.rb
+- lib/scorched/accept/accept_header.rb
+- lib/scorched/accept/rack.rb
+- scorched-accept.gemspec
+- spec/accept_header_parser_spec.rb
+- spec/accept_header_spec.rb
+- spec/rack_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/wardrop/scorched-accept
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--line-numbers"
+- "--inline-source"
+- "--title"
+- Scorched::Accept
+- "--encoding=UTF-8"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: HTTP accept header parser
+test_files:
+- spec/accept_header_parser_spec.rb
+- spec/accept_header_spec.rb
+- spec/rack_spec.rb