xenon 0.0.1 → 0.0.2

data/lib/xenon/parsers/basic_rules.rb

@@ -0,0 +1,55 @@
+require 'parslet'
+
+module Xenon
+  module Parsers
+
+    module BasicRules
+      include Parslet
+
+      # http://tools.ietf.org/html/rfc5234#appendix-B.1
+      rule(:alpha) { match(/[a-z]/i) }
+      rule(:bit) { match(/[01]/) }
+      rule(:char) { match(/[\u0001-\u007f]/) }
+      rule(:digit) { match(/[0-9]/) }
+      rule(:hexdig) { match(/[a-f0-9]/i)}
+      rule(:vchar) { match(/[\u0021-\u007e]/) }
+      rule(:alphanum) { alpha | digit }
+
+      rule(:sp) { str(' ') }
+      rule(:sp?) { sp.repeat }
+      rule(:htab) { str("\t") }
+      rule(:wsp) { sp | htab }
+      rule(:lwsp) { (crlf.maybe >> wsp).repeat }
+
+      rule(:cr) { str("\r") }
+      rule(:lf) { str("\n") }
+      rule(:crlf) { cr >> lf }
+      rule(:dquote) { str('"') }
+
+      # http://tools.ietf.org/html/rfc7230#section-3.2.3
+      rule(:ows) { wsp.repeat }
+      rule(:rws) { wsp.repeat(1) }
+      rule(:bws) { wsp.repeat }
+
+      # http://tools.ietf.org/html/rfc7230#section-3.2.6
+      rule(:tchar) { alpha | digit | match(/[!#\$%&'\*\+\-\.\^_`\|~]/) }
+      rule(:token) { tchar.repeat(1) }
+
+      rule(:obs_text) { match(/[\u0080-\u00ff]/)}
+      rule(:qdtext) { htab | sp | match(/[\u0021\u0023-\u005b\u005d-\u007e]/) | obs_text }
+      rule(:quoted_pair) { str('\\') >> (htab | sp | vchar | obs_text) }
+      rule(:quoted_string) { (dquote >> (qdtext | quoted_pair).repeat >> dquote).as(:quoted_string) }
+
+      # extras -- TODO: move these into header rules?      
+      rule(:comma) { str(',') >> sp? }
+      rule(:semicolon) { str(';') >> sp? }
+    end
+
+    class BasicTransform < Parslet::Transform
+      rule(simple(:v)) { v.respond_to?(:str) ? v.str : v }
+      
+      rule(quoted_string: simple(:qs)) { qs[1..-2].gsub(/\\(.)/, '\1') }
+    end
+    
+  end
+end

data/lib/xenon/parsers/header_rules.rb

@@ -0,0 +1,14 @@
+require 'xenon/parsers/basic_rules'
+
+module Xenon
+  module Parsers
+
+    # http://tools.ietf.org/html/rfc7231#section-5.3.1
+    module WeightRules
+      include Parslet, BasicRules
+      rule(:weight_value) { (digit >> (str('.') >> digit.repeat(0, 3)).maybe).as(:q) }
+      rule(:weight) { semicolon >> str('q') >> sp? >> str('=') >> sp? >> weight_value >> sp? }
+    end
+
+  end
+end

data/lib/xenon/parsers/media_type.rb

@@ -0,0 +1,52 @@
+require 'xenon/parsers/basic_rules'
+
+module Xenon
+  module Parsers
+
+    # note this uses the rules from https://tools.ietf.org/html/rfc6838 not http://tools.ietf.org/html/rfc7231
+    # because the latter is slightly ambiguous, e.g. a token can include * so */json would parse correctly
+    module MediaTypeRules
+      include Parslet, BasicRules
+
+      rule(:restricted_name_first) { match(/[a-zA-Z0-9]/) }
+      rule(:restricted_name_chars) { match(/[a-zA-Z0-9!#\$&\-\^_\.\+]/).repeat(0, 126) }
+      rule(:restricted_name) { restricted_name_first >> restricted_name_chars }
+
+      rule(:type) { restricted_name.as(:type) }
+      rule(:slash) { str('/') }
+      rule(:subtype) { restricted_name.as(:subtype) >> sp? }
+
+      rule(:param_name) { restricted_name.as(:param_name) >> sp? }
+      rule(:equals) { str('=') >> sp? }
+      rule(:param_value) { token.as(:param_value) >> sp? } # not quite correct but probably correct enough
+      rule(:param) { semicolon >> param_name >> (equals >> param_value).maybe >> sp? }
+      rule(:params) { param.repeat.as(:params) }
+
+      rule(:media_type) { (type >> slash >> subtype >> params).as(:media_type) >> sp? }
+
+      rule(:wildcard) { str('*') }
+      rule(:wild_media_range) { wildcard.as(:type) >> slash >> wildcard.as(:subtype) >> params }
+      rule(:root_media_range) { type >> slash >> (wildcard.as(:subtype) | subtype) >> params }
+      rule(:media_range) { (wild_media_range | root_media_range).as(:media_range) >> sp? }
+    end
+
+    class MediaType < Parslet::Parser
+      include MediaTypeRules
+      root(:media_type)
+    end
+
+    class MediaRange < Parslet::Parser
+      include MediaTypeRules
+      root(:media_range)
+    end
+
+    class MediaTypeTransform < Parslet::Transform
+      rule(param_name: simple(:n), param_value: simple(:v)) { [n.str, v.str] }
+      rule(param_name: simple(:n)) { [n.str, nil] }
+      rule(type: simple(:t), subtype: simple(:s), params: subtree(:p)) { { type: t.str, subtype: s.str, params: Hash[p] } }
+      rule(media_type: subtree(:mt)) { ::Xenon::MediaType.new(mt[:type], mt[:subtype], mt[:params])}
+      rule(media_range: subtree(:mr)) { ::Xenon::MediaRange.new(mr[:type], mr[:subtype], mr[:params])}
+    end
+
+  end
+end

data/lib/xenon/quoted_string.rb

@@ -0,0 +1,10 @@
+module Xenon
+  module QuotedString
+    refine String do
+      def quote
+        qs = self.gsub(/([\\"])/, '\\\\\1')
+        self == qs ? self : %{"#{qs}"}
+      end
+    end
+  end
+end

data/lib/xenon/routing.rb

@@ -0,0 +1,133 @@
+module Xenon
+  module Routing
+
+    module RouteDirectives
+      def map_request(map)
+        context.branch do
+          context.request = map.respond_to?(:call) ? map.call(context.request) : context.request.copy(map)
+          yield
+        end
+      end
+
+      def map_response(map)
+        context.branch do
+          context.response = map.respond_to?(:call) ? map.call(context.response) : context.response.copy(map)
+          yield
+        end
+      end
+
+      def complete(status, body)
+        map_response complete: true, status: status, body: body do
+          throw :complete
+        end
+      end
+
+      def reject(rejection)
+        context.rejections << rejection unless rejection.nil?
+      end
+
+      def extract(lambda)
+        yield lambda.call(context)
+      end
+
+      def extract_request(lambda = nil)
+        yield lambda ? lambda.call(context.request) : context.request
+      end
+    end
+
+    module HeaderDirectives
+      def optional_header(name)
+        extract_request do |request|
+          yield request.header(name)
+        end
+      end
+
+      def header(name)
+        optional_header(name) do |value|
+          if value
+            yield value
+          else
+            reject Rejection.new(Rejection::HEADER, { required: name })
+          end
+        end
+      end
+
+      def respond_with_header(header)
+        map_response -> r { r.copy(headers: r.headers.add(header)) } do
+          yield
+        end
+      end
+    end
+
+    module MethodDirectives
+      include RouteDirectives
+
+      def request_method(method)
+        extract_request do |request|
+          if request.request_method == method
+            yield
+          else
+            reject Rejection.new(Rejection::METHOD, { supported: method })
+          end
+        end
+      end
+
+      %i(delete get head options patch post put).each do |method|
+        define_method(method) do |&inner|
+          request_method(method, &inner)
+        end
+      end
+    end
+
+    module ParamDirectives
+      def form_hash
+        extract_request do |request|
+          yield request.form_hash
+        end
+      end
+
+      def query_hash
+        extract_request do |request|
+          yield request.query_hash
+        end
+      end
+    end
+
+    module PathDirectives
+      include RouteDirectives
+
+      def path_prefix(pattern)
+        extract_request do |request|
+          match = request.unmatched_path.match(pattern)
+          if match && match.pre_match == ''
+            map_request unmatched_path: match.post_match do
+              yield *match.captures
+            end
+          else
+            reject nil # path rejections are nil to allow more specific rejections to be seen
+          end
+        end
+      end
+
+      def path_end(&inner)
+        path_prefix(/\Z/, &inner)
+      end
+
+      def path(pattern, &inner)
+        path_prefix(pattern) do |*captures|
+          path_end do
+            inner.call(*captures)
+          end
+        end
+      end
+    end
+
+    module Directives
+      include HeaderDirectives
+      include MethodDirectives
+      include ParamDirectives
+      include PathDirectives
+    end
+
+  end
+end

data/lib/xenon/version.rb

@@ -1,3 +1,3 @@
 module Xenon
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/spec_helper.rb

@@ -0,0 +1,91 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

data/spec/xenon/headers/accept_charset_spec.rb

@@ -0,0 +1,31 @@
+require 'xenon/headers/accept_charset'
+
+describe Xenon::Headers::AcceptCharset do
+
+  context '::parse' do
+    it 'can parse a basic charset range' do
+      header = Xenon::Headers::AcceptCharset.parse('unicode-1-1;q=0.8')
+      expect(header.charset_ranges.size).to eq(1)
+      expect(header.charset_ranges[0].to_s).to eq('unicode-1-1; q=0.8')
+    end
+
+    it 'can parse the example from RFC 7231 § 5.3.3 with the right precedence' do
+      header = Xenon::Headers::AcceptCharset.parse('iso-8859-5, unicode-1-1;q=0.8')
+      expect(header.charset_ranges.size).to eq(2)
+      expect(header.charset_ranges[0].to_s).to eq('iso-8859-5')
+      expect(header.charset_ranges[1].to_s).to eq('unicode-1-1; q=0.8')
+    end
+  end
+
+  context '#merge' do
+    it 'can merge two headers with the right precedence' do
+      h1 = Xenon::Headers::AcceptCharset.parse('unicode-1-1;q=0.8')
+      h2 = Xenon::Headers::AcceptCharset.parse('iso-8859-5')
+      header = h1.merge(h2)
+      expect(header.charset_ranges.size).to eq(2)
+      expect(header.charset_ranges[0].to_s).to eq('iso-8859-5')
+      expect(header.charset_ranges[1].to_s).to eq('unicode-1-1; q=0.8')
+    end
+  end
+
+end

data/spec/xenon/headers/accept_encoding_spec.rb

@@ -0,0 +1,40 @@
+require 'xenon/headers/accept_encoding'
+
+describe Xenon::Headers::AcceptEncoding do
+
+  context '::parse' do
+    %w(identity compress x-compress deflate gzip x-gzip *).each do |cc|
+      it "can parse the #{cc} content coding" do
+        header = Xenon::Headers::AcceptEncoding.parse(cc)
+        expect(header.coding_ranges.size).to eq(1)
+        expect(header.coding_ranges[0].to_s).to eq(cc)
+      end
+    end
+
+    it 'can parse the fifth example from RFC 7231 § 5.3.4 with the right precedence' do
+      header = Xenon::Headers::AcceptEncoding.parse('gzip;q=1.0, identity; q=0.5, *;q=0')
+      expect(header.coding_ranges.size).to eq(3)
+      expect(header.coding_ranges[0].to_s).to eq('gzip')
+      expect(header.coding_ranges[1].to_s).to eq('identity; q=0.5')
+      expect(header.coding_ranges[2].to_s).to eq('*; q=0.0')
+    end
+
+    it 'parses an empty header as containing no codings' do
+      header = Xenon::Headers::AcceptEncoding.parse('')
+      expect(header.coding_ranges.size).to eq(0) 
+    end
+  end
+
+  context '#merge' do
+    it 'can merge two headers with the right precedence' do
+      h1 = Xenon::Headers::AcceptEncoding.parse('identity; q=0.5')
+      h2 = Xenon::Headers::AcceptEncoding.parse('gzip;q=1.0, *;q=0')
+      header = h1.merge(h2)
+      expect(header.coding_ranges.size).to eq(3)
+      expect(header.coding_ranges[0].to_s).to eq('gzip')
+      expect(header.coding_ranges[1].to_s).to eq('identity; q=0.5')
+      expect(header.coding_ranges[2].to_s).to eq('*; q=0.0')
+    end
+  end
+
+end

data/spec/xenon/headers/accept_language_spec.rb

@@ -0,0 +1,33 @@
+require 'xenon/headers/accept_language'
+
+describe Xenon::Headers::AcceptLanguage do
+
+  context '::parse' do
+    it 'can parse a basic language range' do
+      header = Xenon::Headers::AcceptLanguage.parse('en-gb;q=0.8')
+      expect(header.language_ranges.size).to eq(1)
+      expect(header.language_ranges[0].to_s).to eq('en-gb; q=0.8')
+    end
+
+    it 'can parse the example from RFC 7231 § 5.3.5 with the right precedence' do
+      header = Xenon::Headers::AcceptLanguage.parse('da, en-gb;q=0.8, en;q=0.7')
+      expect(header.language_ranges.size).to eq(3)
+      expect(header.language_ranges[0].to_s).to eq('da')
+      expect(header.language_ranges[1].to_s).to eq('en-gb; q=0.8')
+      expect(header.language_ranges[2].to_s).to eq('en; q=0.7')
+    end
+  end
+
+  context '#merge' do
+    it 'can merge two headers with the right precedence' do
+      h1 = Xenon::Headers::AcceptLanguage.parse('da, en;q=0.7')
+      h2 = Xenon::Headers::AcceptLanguage.parse('en-gb;q=0.8')
+      header = h1.merge(h2)
+      expect(header.language_ranges.size).to eq(3)
+      expect(header.language_ranges[0].to_s).to eq('da')
+      expect(header.language_ranges[1].to_s).to eq('en-gb; q=0.8')
+      expect(header.language_ranges[2].to_s).to eq('en; q=0.7')
+    end
+  end
+
+end