xenon 0.0.3 → 0.0.4

data/lib/xenon/media_type.rb

@@ -1,162 +0,0 @@
-require 'xenon/errors'
-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}).")
-    end
-
-    %w(application audio image message multipart text video).each do |type|
-      define_method "#{type}?" do
-        @type == type
-      end
-    end
-
-    def experimental?
-      @subtype.start_with?('x.') # not x- see http://tools.ietf.org/html/rfc6838#section-3.4
-    end
-
-    def personal?
-      @subtype.start_with?('prs.')
-    end
-
-    def vendor?
-      @subtype.start_with?('vnd.')
-    end
-
-    %w(ber der fastinfoset json wbxml xml zip).each do |format|
-      define_method "#{format}?" do
-        @subtype == format || @subtype.end_with?("+#{format}")
-      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
-
-    def to_s
-      "#{@type}/#{@subtype}" << @params.map { |n, v| v ? "; #{n}=#{v}" : "; #{n}" }.join
-    end
-
-    JSON = MediaType.new('application', 'json')
-    XML = MediaType.new('application', 'xml')
-  end
-
-  # A content type.
-  class ContentType
-    attr_reader :media_type, :charset
-
-    DEFAULT_CHARSET = 'utf-8' # historically iso-8859-1 but see http://tools.ietf.org/html/rfc7231#appendix-B
-
-    def initialize(media_type, charset = DEFAULT_CHARSET)
-      @media_type = media_type
-      @charset = charset
-    end
-
-    def self.parse(s)
-      media_type = MediaType.parse(s)
-      charset = media_type.params.delete('charset') || DEFAULT_CHARSET
-      ContentType.new(media_type, charset)
-    end
-
-    def to_s
-      "#{@media_type}; charset=#{@charset}"
-    end
-  end
-
-  class MediaRange
-    include Comparable
-
-    DEFAULT_Q = 1.0
-
-    attr_reader :type, :subtype, :q, :params
-
-    def initialize(type, subtype, params = {})
-      @type = type
-      @subtype = subtype
-      @q = Float(params.delete('q')) rescue DEFAULT_Q
-      @params = params
-    end
-
-    def self.parse(s)
-      tree = Parsers::MediaRange.new.parse(s)
-      Parsers::MediaTypeTransform.new.apply(tree)
-    rescue Parslet::ParseFailed
-      raise Xenon::ParseError.new("Invalid media range (#{s})")
-    end
-
-    def <=>(other)
-      dt = compare_types(@type, other.type)
-      return dt if dt != 0
-      ds = compare_types(@subtype, other.subtype)
-      return ds if ds != 0
-      dp = params.size <=> other.params.size
-      return dp if dp != 0
-      @q <=> other.q
-    end
-
-    def =~(media_type)
-      (type == '*' || type == media_type.type) &&
-      (subtype == '*' || subtype == media_type.subtype) &&
-      params.all? { |n, v| media_type.params[n] == v }
-    end
-
-    alias_method :===, :=~
-
-    def to_s
-      s = "#{@type}/#{@subtype}"
-      s << @params.map { |n, v| v ? "; #{n}=#{v}" : "; #{n}" }.join
-      s << "; q=#{@q}" if @q != DEFAULT_Q
-      s
-    end
-
-    private
-
-    def compare_types(a, b)
-      if a == b then 0
-      elsif a == '*' then -1
-      elsif b == '*' then 1
-      else 0
-      end
-    end
-  end
-
-end

data/lib/xenon/parsers/basic_rules.rb

@@ -1,86 +0,0 @@
-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
-
-      # 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) }
-
-      # 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?
-      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,60 +0,0 @@
-require 'xenon/quoted_string'
-require 'xenon/parsers/basic_rules'
-
-module Xenon
-  module Parsers
-
-    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) { 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
-end

data/lib/xenon/parsers/media_type.rb

@@ -1,53 +0,0 @@
-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_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) { 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? }
-
-      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

@@ -1,20 +0,0 @@
-module Xenon
-  module QuotedString
-    refine String do
-      def quote
-        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

@@ -1,14 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

data/lib/xenon/routing/method_directives.rb

@@ -1,26 +0,0 @@
-require 'xenon/routing/route_directives'
-
-module Xenon
-  module Routing
-    module MethodDirectives
-      include RouteDirectives
-
-      def request_method(method)
-        extract_request do |request|
-          if request.request_method == method
-            yield
-          else
-            reject Rejection.new(: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
-  end
-end