xenon 0.0.1 → 0.0.2

data/lib/xenon/headers/accept.rb

@@ -0,0 +1,33 @@
+require 'xenon/headers'
+require 'xenon/parsers/media_type'
+
+module Xenon
+  class Headers
+    # http://tools.ietf.org/html/rfc7231#section-5.3.2
+    class Accept < ListHeader 'Accept'
+      def initialize(*media_ranges)
+        super(media_ranges.sort_by.with_index { |mr, i| [mr, -i] }.reverse!)
+      end
+
+      alias_method :media_ranges, :values
+
+      def self.parse(s)
+        tree = Parsers::AcceptHeader.new.parse(s)
+        Parsers::AcceptHeaderTransform.new.apply(tree)
+      end
+    end
+  end
+
+  module Parsers
+    class AcceptHeader < Parslet::Parser
+      include MediaTypeRules
+      rule(:accept) { (media_range >> (comma >> media_range).repeat).as(:accept) }
+      root(:accept)
+    end
+
+    class AcceptHeaderTransform < MediaTypeTransform
+      rule(accept: sequence(:mr)) { Headers::Accept.new(*mr) }
+      rule(accept: simple(:mr)) { Headers::Accept.new(mr) }
+    end
+  end
+end

data/lib/xenon/headers/accept_charset.rb

@@ -0,0 +1,59 @@
+require 'xenon/headers'
+require 'xenon/parsers/header_rules'
+
+module Xenon
+  class CharsetRange
+    attr_reader :charset, :q
+
+    DEFAULT_Q = 1.0
+
+    def initialize(charset, q = DEFAULT_Q)
+      @charset = charset
+      @q = Float(q) || DEFAULT_Q
+    end
+
+    def <=>(other)
+      @q <=> other.q
+    end
+
+    def to_s
+      s = @charset.dup
+      s << "; q=#{@q}" if @q != DEFAULT_Q
+      s
+    end
+  end
+
+  class Headers
+    # http://tools.ietf.org/html/rfc7231#section-5.3.3
+    class AcceptCharset < ListHeader 'Accept-Charset'
+      def initialize(*charset_ranges)
+        super(charset_ranges.sort_by.with_index { |mr, i| [mr, -i] }.reverse!)
+      end
+
+      alias_method :charset_ranges, :values
+
+      def self.parse(s)
+        tree = Parsers::AcceptCharsetHeader.new.parse(s)
+        Parsers::AcceptCharsetHeaderTransform.new.apply(tree)
+      end
+    end
+  end
+
+  module Parsers
+    class AcceptCharsetHeader < Parslet::Parser
+      include BasicRules, WeightRules
+      rule(:charset) { token.as(:charset) >> sp? }
+      rule(:wildcard) { str('*').as(:charset) >> sp? }
+      rule(:charset_range) { (charset | wildcard) >> weight.maybe }
+      rule(:accept_charset) { (charset_range >> (comma >> charset_range).repeat).as(:accept_charset) }
+      root(:accept_charset)
+    end
+
+    class AcceptCharsetHeaderTransform < Parslet::Transform
+      rule(charset: simple(:c), q: simple(:q)) { CharsetRange.new(c.str, q.str) }
+      rule(charset: simple(:c)) { CharsetRange.new(c.str) }
+      rule(accept_charset: sequence(:cr)) { Headers::AcceptCharset.new(*cr) }
+      rule(accept_charset: simple(:cr)) { Headers::AcceptCharset.new(cr) }
+    end
+  end
+end

data/lib/xenon/headers/accept_encoding.rb

@@ -0,0 +1,63 @@
+require 'xenon/headers'
+require 'xenon/parsers/header_rules'
+
+module Xenon
+  class ContentCodingRange
+    attr_reader :coding, :q
+
+    DEFAULT_Q = 1.0
+
+    def initialize(coding, q = DEFAULT_Q)
+      @coding = coding
+      @q = Float(q) || DEFAULT_Q
+    end
+
+    def <=>(other)
+      @q <=> other.q
+    end
+
+    def to_s
+      s = @coding.dup
+      s << "; q=#{@q}" if @q != DEFAULT_Q
+      s
+    end
+  end
+
+  class Headers
+    # http://tools.ietf.org/html/rfc7231#section-5.3.4
+    class AcceptEncoding < ListHeader 'Accept-Encoding'
+      def initialize(*coding_ranges)
+        super(coding_ranges.sort_by.with_index { |mr, i| [mr, -i] }.reverse!)
+      end
+
+      alias_method :coding_ranges, :values
+
+      def self.parse(s)
+        tree = Parsers::AcceptEncodingHeader.new.parse(s)
+        Parsers::AcceptEncodingHeaderTransform.new.apply(tree)
+      end
+    end
+  end
+
+  module Parsers
+    class AcceptEncodingHeader < Parslet::Parser
+      include BasicRules, WeightRules
+      %w(identity compress x-compress deflate gzip x-gzip).each do |c|
+        rule(c.tr('-', '_').to_sym) { str(c).as(:coding) >> sp? }
+      end
+      rule(:coding) { compress | x_compress | deflate | gzip | x_gzip }
+      rule(:wildcard) { str('*').as(:coding) >> sp? }
+      rule(:coding_range) { (coding | identity | wildcard) >> weight.maybe }
+      rule(:accept_encoding) { (coding_range >> (comma >> coding_range).repeat).maybe.as(:accept_encoding) }
+      root(:accept_encoding)
+    end
+
+    class AcceptEncodingHeaderTransform < Parslet::Transform
+      rule(coding: simple(:c), q: simple(:q)) { ContentCodingRange.new(c.str, q.str) }
+      rule(coding: simple(:c)) { ContentCodingRange.new(c.str) }
+      rule(accept_encoding: sequence(:er)) { Headers::AcceptEncoding.new(*er) }
+      rule(accept_encoding: simple(:cc)) { Headers::AcceptEncoding.new(cc) }
+      rule(accept_encoding: nil) { Headers::AcceptEncoding.new }
+    end
+  end
+end

data/lib/xenon/headers/accept_language.rb

@@ -0,0 +1,59 @@
+require 'xenon/headers'
+require 'xenon/parsers/header_rules'
+
+module Xenon
+  class LanguageRange
+    attr_reader :language, :q
+
+    DEFAULT_Q = 1.0
+
+    def initialize(language, q = DEFAULT_Q)
+      @language = language
+      @q = Float(q) || DEFAULT_Q
+    end
+
+    def <=>(other)
+      @q <=> other.q
+    end
+
+    def to_s
+      s = @language.dup
+      s << "; q=#{@q}" if @q != DEFAULT_Q
+      s
+    end
+  end
+
+  class Headers
+    # http://tools.ietf.org/html/rfc7231#section-5.3.5
+    class AcceptLanguage < ListHeader 'Accept-Language'
+      def initialize(*language_ranges)
+        super(language_ranges.sort_by.with_index { |mr, i| [mr, -i] }.reverse!)
+      end
+
+      alias_method :language_ranges, :values
+
+      def self.parse(s)
+        tree = Parsers::AcceptLanguageHeader.new.parse(s)
+        Parsers::AcceptLanguageHeaderTransform.new.apply(tree)
+      end
+    end
+  end
+
+  module Parsers
+    class AcceptLanguageHeader < Parslet::Parser
+      include BasicRules, WeightRules
+      rule(:language) { (alpha.repeat(1, 8) >> (str('-') >> alphanum.repeat(1, 8)).maybe).as(:language) >> sp? }
+      rule(:wildcard) { str('*').as(:language) >> sp? }
+      rule(:language_range) { (language | wildcard) >> weight.maybe }
+      rule(:accept_language) { (language_range >> (comma >> language_range).repeat).as(:accept_language) }
+      root(:accept_language)
+    end
+
+    class AcceptLanguageHeaderTransform < Parslet::Transform
+      rule(language: simple(:e), q: simple(:q)) { LanguageRange.new(e.str, q.str) }
+      rule(language: simple(:e)) { LanguageRange.new(e.str) }
+      rule(accept_language: sequence(:lr)) { Headers::AcceptLanguage.new(*lr) }
+      rule(accept_language: simple(:lr)) { Headers::AcceptLanguage.new(lr) }
+    end
+  end
+end

data/lib/xenon/headers/authorization.rb

@@ -0,0 +1,96 @@
+require 'base64'
+require 'xenon/headers'
+require 'xenon/parsers/header_rules'
+require 'xenon/quoted_string'
+
+module Xenon
+  class BasicCredentials
+    attr_reader :username, :password
+
+    def initialize(username, password)
+      @username = username
+      @password = password
+    end
+
+    def token
+      Base64.strict_encode64("#{@username}:#{@password}")
+    end
+
+    def self.decode(s)
+      str = Base64.strict_decode64(s)
+      username, password = str.split(':', 2)
+      BasicCredentials.new(username, password)
+    end
+
+    def to_s
+      "Basic #{token}"
+    end
+  end
+
+  class GenericCredentials
+    using QuotedString
+
+    attr_reader :scheme, :token, :params
+
+    def initialize(scheme, token: nil, params: {})
+      @scheme = scheme
+      @token = token
+      @params = params
+    end
+
+    def to_s
+      s = @scheme.dup
+      s << ' ' << @token if @token
+      s << ' ' << @params.map { |n, v| "#{n}=#{v.quote}" }.join(', ')
+      s
+    end
+  end
+
+  class Headers
+    # http://tools.ietf.org/html/rfc7235#section-4.2
+    class Authorization < Header 'Authorization'
+      attr_reader :credentials
+
+      def initialize(credentials)
+        @credentials = credentials
+      end
+
+      def self.parse(s)
+        tree = Parsers::AuthorizationHeader.new.parse(s)
+        Parsers::AuthorizationHeaderTransform.new.apply(tree)
+      end
+
+      def to_s
+        @credentials.to_s
+      end
+    end
+  end
+
+  module Parsers
+    class AuthorizationHeader < Parslet::Parser
+      include BasicRules
+      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) }
+      rule(:credentials) { auth_scheme >> sp >> (token68 | auth_params) }
+      rule(:authorization) { credentials.as(:authorization) }
+      root(:authorization)
+    end
+
+    class AuthorizationHeaderTransform < BasicTransform
+      rule(auth_param: { name: simple(:n), value: simple(:v) }) { [n, v] }
+      rule(auth_params: subtree(:x)) { { foo: x } }
+      rule(auth_scheme: simple(:s), token: simple(:t)) { 
+        case s
+        when 'Basic' then BasicCredentials.decode(t)
+        else GenericCredentials.new(s, token: t) 
+        end
+      }
+      rule(auth_scheme: simple(:s), auth_params: subtree(:p)) { GenericCredentials.new(s, params: Hash[p]) }
+      rule(authorization: simple(:c)) { Headers::Authorization.new(c) }
+    end
+  end
+end

data/lib/xenon/headers/cache_control.rb

@@ -0,0 +1,56 @@
+require 'xenon/headers'
+require 'xenon/parsers/header_rules'
+require 'xenon/quoted_string'
+
+module Xenon
+  class CacheDirective
+    using QuotedString
+
+    attr_reader :name, :value
+
+    def initialize(name, value = nil)
+      @name = name
+      @value = value
+    end
+
+    def to_s
+      s = @name.dup
+      s << '=' << @value.quote if @value
+      s
+    end
+  end
+
+  class Headers
+    # http://tools.ietf.org/html/rfc7234#section-5.2
+    class CacheControl < ListHeader 'Cache-Control'
+      def initialize(*directives)
+        super(directives)
+      end
+      
+      alias_method :directives, :values
+
+      def self.parse(s)
+        tree = Parsers::CacheControlHeader.new.parse(s)
+        Parsers::CacheControlHeaderTransform.new.apply(tree)
+      end
+    end
+  end
+
+  module Parsers
+    class CacheControlHeader < Parslet::Parser
+      include BasicRules
+      rule(:name) { token.as(:name) }
+      rule(:value) { str('=') >> (token | quoted_string).as(:value) }
+      rule(:directive) { (name >> value.maybe).as(:directive) >> sp? }
+      rule(:cache_control) { (directive >> (comma >> directive).repeat).as(:cache_control) }
+      root(:cache_control)
+    end
+
+    class CacheControlHeaderTransform < BasicTransform
+      rule(directive: { name: simple(:n), value: simple(:v) }) { CacheDirective.new(n, v) }
+      rule(directive: { name: simple(:n) }) { CacheDirective.new(n) }
+      rule(cache_control: sequence(:d)) { Headers::CacheControl.new(*d) }
+      rule(cache_control: simple(:d)) { Headers::CacheControl.new(d) }
+    end
+  end
+end

data/lib/xenon/headers/content_type.rb

@@ -0,0 +1,23 @@
+require 'xenon/headers'
+require 'xenon/media_type'
+
+module Xenon
+  class Headers
+    # http://tools.ietf.org/html/rfc7231#section-3.1.1.5
+    class ContentType < Header 'Content-Type'
+      attr_reader :content_type
+
+      def initialize(content_type)
+        @content_type = content_type
+      end
+
+      def self.parse(s)
+        ContentType.new(Xenon::ContentType.parse(s))
+      end
+
+      def to_s
+        @content_type.to_s
+      end
+    end
+  end
+end

data/lib/xenon/media_type.rb

@@ -0,0 +1,140 @@
+require 'xenon/errors'
+require 'xenon/parsers/media_type'
+
+module Xenon
+
+  class MediaType
+    attr_reader :type, :subtype, :params
+
+    def initialize(type, subtype, params = {})
+      @type = type
+      @subtype = subtype
+      @params = params
+    end
+
+    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
+
+    def with_q(q)
+      MediaRange.new(self, q)
+    end
+
+    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
+
+  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