xenon 0.0.2 → 0.0.3

data/lib/xenon/headers/if_unmodified_since.rb

@@ -0,0 +1,22 @@
+require 'xenon/headers'
+
+module Xenon
+  class Headers
+    # http://tools.ietf.org/html/rfc7232#section-3.4
+    class IfUnmodifiedSince < Header 'If-Unmodified-Since'
+      attr_reader :date
+
+      def initialize(date)
+        @date = date
+      end
+
+      def self.parse(s)
+        new(Time.httpdate(s))
+      end
+
+      def to_s
+        @date.httpdate
+      end
+    end
+  end
+end

data/lib/xenon/headers/user_agent.rb

@@ -0,0 +1,65 @@
+require 'xenon/headers'
+require 'xenon/parsers/header_rules'
+
+module Xenon
+  class Product
+    attr_reader :name, :version, :comment
+
+    def initialize(name, version = nil, comment = nil)
+      @name = name
+      @version = version
+      @comment = comment
+    end
+
+    def to_s
+      s = ''
+      s << @name if @name
+      s << '/' << @version if @version
+      if @comment
+        s << ' ' unless s.empty?
+        s << '(' << @comment << ')'
+      end
+      s
+    end
+  end
+
+  class Headers
+    # http://tools.ietf.org/html/rfc7231#section-5.5.3
+    class UserAgent < Header 'User-Agent'
+      attr_reader :products
+
+      def initialize(*products)
+        @products = products
+      end
+
+      def self.parse(s)
+        tree = Parsers::UserAgentHeader.new.parse(s)
+        Parsers::UserAgentHeaderTransform.new.apply(tree)
+      end
+
+      def to_s
+        @products.map(&:to_s).join(' ')
+      end
+    end
+  end
+
+  module Parsers
+    class UserAgentHeader < Parslet::Parser
+      include HeaderRules
+      rule(:product) { (token.as(:name) >> (str('/') >> token.as(:version)).maybe >> (rws >> comment.as(:comment)).maybe).as(:product) }
+      rule(:product_comment) { comment.as(:product_comment) }
+      rule(:user_agent) { (product >> (rws >> (product | product_comment)).repeat).as(:user_agent) }
+      root(:user_agent)
+    end
+
+    class UserAgentHeaderTransform < HeaderTransform
+      rule(product: { name: simple(:p), version: simple(:v), comment: simple(:c) }) { Product.new(p, v, c) }
+      rule(product: { name: simple(:p), version: simple(:v) }) { Product.new(p, v) }
+      rule(product: { name: simple(:p), comment: simple(:c) }) { Product.new(p, nil, c) }
+      rule(product: { name: simple(:p) }) { Product.new(p) }
+      rule(product_comment: simple(:c)) { Product.new(nil, nil, c) }
+      rule(user_agent: sequence(:p)) { Headers::UserAgent.new(*p) }
+      rule(user_agent: simple(:p)) { Headers::UserAgent.new(p) }
+    end
+  end
+end

data/lib/xenon/headers/www_authenticate.rb

@@ -0,0 +1,70 @@
+require 'active_support/core_ext/hash/indifferent_access'
+require 'xenon/headers'
+require 'xenon/parsers/header_rules'
+require 'xenon/quoted_string'
+
+module Xenon
+  class Headers
+    class Challenge
+      extend Forwardable
+      using QuotedString
+
+      attr_reader :auth_scheme
+      def_delegators :@params, :key?, :include?, :[]
+
+      def initialize(auth_scheme, params = {})
+        @auth_scheme = auth_scheme
+        @params = params.with_indifferent_access
+      end
+
+      def method_missing(name, *args, &block)
+        name = name.to_sym
+        @params.key?(name) ? @params[name] : super
+      end
+
+      def respond_to_missing?(name, include_all)
+        @params.key?(name.to_sym) || super
+      end
+
+      def to_s
+        param_string = @params.map { |k, v| "#{k}=#{v.quote}"}.join(', ')
+        "#{@auth_scheme} #{param_string}"
+      end
+    end
+
+    # https://tools.ietf.org/html/rfc7235#section-4.1
+    class WWWAuthenticate < ListHeader 'WWW-Authenticate'
+      def initialize(*challenges)
+        super(challenges)
+      end
+
+      alias_method :challenges, :values
+
+      def self.parse(s)
+        tree = Parsers::WWWAuthenticateHeader.new.parse(s)
+        Parsers::WWWAuthenticateHeaderTransform.new.apply(tree)
+      end
+
+      def to_s
+        challenges.map(&:to_s).join(', ')
+      end
+    end
+  end
+
+  module Parsers
+    class WWWAuthenticateHeader < Parslet::Parser
+      include AuthHeaderRules
+      rule(:challenge) { (auth_scheme >> sp >> (auth_params | token68)).as(:challenge) }
+      rule(:www_authenticate) { (challenge >> (comma >> challenge).repeat).as(:www_authenticate) }
+      root(:www_authenticate)
+    end
+
+    class WWWAuthenticateHeaderTransform < HeaderTransform
+      rule(auth_param: { name: simple(:n), value: simple(:v) }) { Tuple.new(n, v) }
+      rule(challenge: { auth_scheme: simple(:s), auth_params: simple(:p) }) { Headers::Challenge.new(s, Hash[*p.to_a]) }
+      rule(challenge: { auth_scheme: simple(:s), auth_params: sequence(:p) }) { Headers::Challenge.new(s, Hash[p.map(&:to_a)]) }
+      rule(www_authenticate: simple(:c)) { Headers::WWWAuthenticate.new(c) }
+      rule(www_authenticate: sequence(:c)) { Headers::WWWAuthenticate.new(*c) }
+    end
+  end
+end

data/lib/xenon/media_type.rb

@@ -3,20 +3,33 @@ require 'xenon/parsers/media_type'
 
 module Xenon
 
+  # A media type.
+  #
+  # @see ContentType
+  # @see MediaRange
   class MediaType
     attr_reader :type, :subtype, :params
 
+    # Initializes a new instance of MediaType.
+    #
+    # @param type [String] The main type, e.g. 'application'.
+    # @param subtype [String] The subtype, e.g. 'json'.
+    # @param params [Hash] Any params for the media type; don't use 'q' or 'charset'.
     def initialize(type, subtype, params = {})
       @type = type
       @subtype = subtype
       @params = params
     end
 
+    # Parses a media type.
+    #
+    # @param s [String] The media type string.
+    # @return [MediaType] The media type.
     def self.parse(s)
       tree = Parsers::MediaType.new.parse(s)
       Parsers::MediaTypeTransform.new.apply(tree)
     rescue Parslet::ParseFailed
-      raise Xenon::ParseError.new("Invalid media type (#{s})")
+      raise Xenon::ParseError.new("Invalid media type (#{s}).")
     end
 
     %w(application audio image message multipart text video).each do |type|
@@ -43,10 +56,18 @@ module Xenon
       end
     end
 
+    # Creates a {MediaRange} using this media type with a quality factor.
+    #
+    # @param q [Numeric] A value between 1.0 (most desirable) and 0.0 (not acceptable).
+    # @return [MediaRange] The media range.
     def with_q(q)
       MediaRange.new(self, q)
     end
 
+    # Creates a {ContentType} using this media type with a charset.
+    #
+    # @param charset [String] The desired charset, e.g. 'utf-8'.
+    # @return [ContentType] The content type.
     def with_charset(charset)
       ContentType.new(self, charset)
     end
@@ -59,6 +80,7 @@ module Xenon
     XML = MediaType.new('application', 'xml')
   end
 
+  # A content type.
   class ContentType
     attr_reader :media_type, :charset
 
@@ -109,7 +131,7 @@ module Xenon
       dp = params.size <=> other.params.size
       return dp if dp != 0
       @q <=> other.q
-    end 
+    end
 
     def =~(media_type)
       (type == '*' || type == media_type.type) &&

data/lib/xenon/parsers/basic_rules.rb

@@ -3,6 +3,19 @@ require 'parslet'
 module Xenon
   module Parsers
 
+    # Parslet doesn't match sequence of sequences (i.e. [['foo', 'bar']]) as a sequence(:v) in transform
+    # rules so this is a little wrapper class that allows smuggling an array through the matcher rules,
+    # for example above would be [Tuple.new('foo', 'bar')], when no 'proper' class is required.
+    class Tuple
+      def initialize(*values)
+        @values = values
+      end
+
+      def to_a
+        @values
+      end
+    end
+
     module BasicRules
       include Parslet
 
@@ -35,21 +48,39 @@ module Xenon
       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) }
+      # http://tools.ietf.org/html/rfc7231#section-7.1.1.1
+      rule(:day_name) { str('Mon') | str('Tue') | str('Wed') | str('Thu') | str('Fri') | str('Sat') | str('Sun') }
+      rule(:day) { digit.repeat(2) }
+      rule(:month) { (str('Jan') | str('Feb') | str('Mar') | str('Apr') | str('May') | str('Jun') | str('Jul') | str('Aug') | str('Sep') | str('Oct') | str('Nov') | str('Dec')) }
+      rule(:year) { digit.repeat(4) }
+      rule(:date1) { day >> sp >> month >> sp >> year }
+      rule(:gmt) { str('GMT') }
+      rule(:hour) { digit.repeat(2) }
+      rule(:minute) { digit.repeat(2) }
+      rule(:second) { digit.repeat(2) }
+      rule(:time_of_day) { hour >> str(':') >> minute >> str(':') >> second }
+      rule(:imf_fixdate) { day_name >> str(',') >> sp >> date1 >> sp >> time_of_day >> sp >> gmt }
+      rule(:day_name_l) { str('Monday') | str('Tuesday') | str('Wednesday') | str('Thursday') | str('Friday') | str('Saturday') | str('Sunday') }
+      rule(:year2) { digit.repeat(2) }
+      rule(:date2) { day >> str('-') >> month >> str('-') >> year2 }
+      rule(:rfc850_date) { day_name_l >> str(',') >> sp >> date2 >> sp >> time_of_day >> sp >> gmt }
+      rule(:day1) { sp >> digit }
+      rule(:date3) { month >> sp >> (day | day1) }
+      rule(:asctime_date) { day_name >> sp >> date3 >> sp >> time_of_day >> sp >> year }
+      rule(:obs_date) { rfc850_date | asctime_date }
+      rule(:http_date) { (imf_fixdate | obs_date).as(:http_date) }
 
-      # extras -- TODO: move these into header rules?      
+      # 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') }
+      rule(http_date: simple(:str)) { Time.httpdate(str) }
     end
-    
+
   end
 end

data/lib/xenon/parsers/header_rules.rb

@@ -1,13 +1,59 @@
+require 'xenon/quoted_string'
 require 'xenon/parsers/basic_rules'
 
 module Xenon
   module Parsers
 
-    # http://tools.ietf.org/html/rfc7231#section-5.3.1
-    module WeightRules
+    module HeaderRules
       include Parslet, BasicRules
+
+      # http://tools.ietf.org/html/rfc7230#section-3.2.6
+      rule(:list_sep) { str(',') >> sp? }
+      rule(:param_sep) { str(';') >> sp? }
+      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) }
+      rule(:ctext) { htab | sp | match(/[\u0021-\u0027\u002a-\u005b\u005d-\u007e]/) | obs_text }
+      rule(:comment) { (str('(') >> (ctext | quoted_pair | comment).repeat >> str(')')).as(:comment) }
+
+      # http://tools.ietf.org/html/rfc7231#section-5.3.1
       rule(:weight_value) { (digit >> (str('.') >> digit.repeat(0, 3)).maybe).as(:q) }
-      rule(:weight) { semicolon >> str('q') >> sp? >> str('=') >> sp? >> weight_value >> sp? }
+      rule(:weight) { param_sep >> str('q') >> sp? >> str('=') >> sp? >> weight_value >> sp? }
+    end
+
+    module AuthHeaderRules
+      include Parslet, HeaderRules
+
+      rule(:token68) { ((alpha | digit | match(/[\-\._~\+\/]/)) >> str('=').repeat).repeat(1).as(:token) }
+      rule(:auth_scheme) { token.as(:auth_scheme) }
+      rule(:name) { token.as(:name) }
+      rule(:value) { token.as(:value) }
+      rule(:auth_param) { (name >> bws >> str('=') >> bws >> (token | quoted_string).as(:value)).as(:auth_param) }
+      rule(:auth_params) { (auth_param.maybe >> (ows >> comma >> ows >> auth_param).repeat).as(:auth_params) }
+    end
+
+    module ETagHeaderRules
+      include Parslet, HeaderRules
+
+      # http://tools.ietf.org/html/rfc7232#section-2.3
+      rule(:wildcard) { str('*').as(:wildcard) }
+      rule(:weak) { str('W/').as(:weak) }
+      rule(:etagc) { str('!') | match(/[\u0023-\u007e#-~]/) | obs_text }
+      rule(:opaque_tag) { dquote >> etagc.repeat.as(:opaque_tag) >> dquote }
+      rule(:etag) { (weak.maybe >> opaque_tag).as(:etag) }
+    end
+
+    class HeaderTransform < BasicTransform
+      using QuotedString
+
+      rule(quoted_string: simple(:qs)) { qs.unquote }
+      rule(comment: simple(:c)) { c.uncomment }
+    end
+
+    class ETagHeaderTransform < HeaderTransform
+      rule(etag: { opaque_tag: simple(:t), weak: simple(:w) }) { Xenon::ETag.new(t, weak: true) }
+      rule(etag: { opaque_tag: simple(:t) }) { Xenon::ETag.new(t) }
     end
 
   end

data/lib/xenon/parsers/media_type.rb

@@ -16,10 +16,11 @@ module Xenon
       rule(:slash) { str('/') }
       rule(:subtype) { restricted_name.as(:subtype) >> sp? }
 
+      rule(:param_sep) { str(';') >> 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(:param) { param_sep >> param_name >> (equals >> param_value).maybe >> sp? }
       rule(:params) { param.repeat.as(:params) }
 
       rule(:media_type) { (type >> slash >> subtype >> params).as(:media_type) >> sp? }
@@ -44,8 +45,8 @@ module Xenon
       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])}
+      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

data/lib/xenon/quoted_string.rb

@@ -2,9 +2,19 @@ module Xenon
   module QuotedString
     refine String do
       def quote
-        qs = self.gsub(/([\\"])/, '\\\\\1')
+        qs = gsub(/([\\"])/, '\\\\\1')
         self == qs ? self : %{"#{qs}"}
       end
+
+      def unquote
+      	qs = start_with?('"') && end_with?('"') ? self[1..-2] : self
+      	qs.gsub(/\\(.)/, '\1')
+      end
+
+      def uncomment
+      	qs = start_with?('(') && end_with?(')') ? self[1..-2] : self
+      	qs.gsub(/\\(.)/, '\1')
+      end
     end
   end
 end

data/lib/xenon/routing/directives.rb

@@ -0,0 +1,14 @@
+Dir[File.join(__dir__, '*_directives.rb')].each { |f| require f }
+
+module Xenon
+  module Routing
+    module Directives
+      include RouteDirectives
+      include HeaderDirectives
+      include MethodDirectives
+      include ParamDirectives
+      include PathDirectives
+      include SecurityDirectives
+    end
+  end
+end

data/lib/xenon/routing/header_directives.rb

@@ -0,0 +1,32 @@
+require 'xenon/routing/route_directives'
+
+module Xenon
+  module Routing
+    module HeaderDirectives
+      include RouteDirectives
+
+      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(: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
+  end
+end