xenon-routing 0.0.4 → 0.0.5

data/xenon-http/lib/xenon/headers/accept.rb

@@ -1,34 +0,0 @@
-require 'xenon/headers'
-require 'xenon/parsers/header_rules'
-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 HeaderRules, MediaTypeRules
-      rule(:accept) { (media_range >> (list_sep >> 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/xenon-http/lib/xenon/headers/accept_charset.rb

@@ -1,59 +0,0 @@
-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 HeaderRules
-      rule(:charset) { token.as(:charset) >> sp? }
-      rule(:wildcard) { str('*').as(:charset) >> sp? }
-      rule(:charset_range) { (charset | wildcard) >> weight.maybe }
-      rule(:accept_charset) { (charset_range >> (list_sep >> charset_range).repeat).as(:accept_charset) }
-      root(:accept_charset)
-    end
-
-    class AcceptCharsetHeaderTransform < HeaderTransform
-      rule(charset: simple(:c), q: simple(:q)) { CharsetRange.new(c, q) }
-      rule(charset: simple(:c)) { CharsetRange.new(c) }
-      rule(accept_charset: sequence(:cr)) { Headers::AcceptCharset.new(*cr) }
-      rule(accept_charset: simple(:cr)) { Headers::AcceptCharset.new(cr) }
-    end
-  end
-end

data/xenon-http/lib/xenon/headers/accept_encoding.rb

@@ -1,63 +0,0 @@
-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 HeaderRules
-      %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 >> (list_sep >> coding_range).repeat).maybe.as(:accept_encoding) }
-      root(:accept_encoding)
-    end
-
-    class AcceptEncodingHeaderTransform < HeaderTransform
-      rule(coding: simple(:c), q: simple(:q)) { ContentCodingRange.new(c, q) }
-      rule(coding: simple(:c)) { ContentCodingRange.new(c) }
-      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/xenon-http/lib/xenon/headers/accept_language.rb

@@ -1,59 +0,0 @@
-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 HeaderRules
-      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 >> (list_sep >> language_range).repeat).as(:accept_language) }
-      root(:accept_language)
-    end
-
-    class AcceptLanguageHeaderTransform < HeaderTransform
-      rule(language: simple(:e), q: simple(:q)) { LanguageRange.new(e, q) }
-      rule(language: simple(:e)) { LanguageRange.new(e) }
-      rule(accept_language: sequence(:lr)) { Headers::AcceptLanguage.new(*lr) }
-      rule(accept_language: simple(:lr)) { Headers::AcceptLanguage.new(lr) }
-    end
-  end
-end

data/xenon-http/lib/xenon/headers/authorization.rb

@@ -1,50 +0,0 @@
-require 'base64'
-require 'xenon/auth'
-require 'xenon/headers'
-require 'xenon/parsers/header_rules'
-
-module Xenon
-  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)
-      rescue Parslet::ParseFailed
-        raise Xenon::ParseError.new("Invalid Authorization header (#{s}).")
-      end
-
-      def to_s
-        @credentials.to_s
-      end
-    end
-  end
-
-  module Parsers
-    class AuthorizationHeader < Parslet::Parser
-      include AuthHeaderRules
-      rule(:credentials) { auth_scheme >> sp >> (token68 | auth_params) }
-      rule(:authorization) { credentials.as(:authorization) }
-      root(:authorization)
-    end
-
-    class AuthorizationHeaderTransform < HeaderTransform
-      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/xenon-http/lib/xenon/headers/cache_control.rb

@@ -1,56 +0,0 @@
-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 HeaderRules
-      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 >> (list_sep >> directive).repeat).as(:cache_control) }
-      root(:cache_control)
-    end
-
-    class CacheControlHeaderTransform < HeaderTransform
-      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/xenon-http/lib/xenon/headers/content_type.rb

@@ -1,23 +0,0 @@
-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)
-        new(Xenon::ContentType.parse(s))
-      end
-
-      def to_s
-        @content_type.to_s
-      end
-    end
-  end
-end

data/xenon-http/lib/xenon/headers/if_match.rb

@@ -1,53 +0,0 @@
-require 'xenon/headers'
-require 'xenon/parsers/header_rules'
-require 'xenon/errors'
-require 'xenon/etag'
-
-module Xenon
-  class Headers
-    # http://tools.ietf.org/html/rfc7232#section-3.1
-    class IfMatch < ListHeader 'If-Match'
-      def initialize(*etags)
-        super(etags)
-      end
-
-      alias_method :etags, :values
-
-      def self.wildcard
-        new
-      end
-
-      def self.parse(s)
-        tree = Parsers::IfMatchHeader.new.parse(s)
-        Parsers::IfMatchHeaderTransform.new.apply(tree)
-      end
-
-      def wildcard?
-        etags.empty?
-      end
-
-      def merge(other)
-        raise Xenon::ProtocolError.new('Cannot merge wildcard headers') if wildcard? || other.wildcard?
-        super
-      end
-
-      def to_s
-        wildcard? ? '*' : super
-      end
-    end
-  end
-
-  module Parsers
-    class IfMatchHeader < Parslet::Parser
-      include ETagHeaderRules
-      rule(:if_match) { (wildcard | (etag >> (list_sep >> etag).repeat)).as(:if_match) }
-      root(:if_match)
-    end
-
-    class IfMatchHeaderTransform < ETagHeaderTransform
-      rule(if_match: { wildcard: simple(:w) }) { Headers::IfMatch.new }
-      rule(if_match: sequence(:et)) { Headers::IfMatch.new(*et) }
-      rule(if_match: simple(:et)) { Headers::IfMatch.new(et) }
-    end
-  end
-end

data/xenon-http/lib/xenon/headers/if_modified_since.rb

@@ -1,22 +0,0 @@
-require 'xenon/headers'
-
-module Xenon
-  class Headers
-    # http://tools.ietf.org/html/rfc7232#section-3.3
-    class IfModifiedSince < Header 'If-Modified-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/xenon-http/lib/xenon/headers/if_none_match.rb

@@ -1,53 +0,0 @@
-require 'xenon/headers'
-require 'xenon/parsers/header_rules'
-require 'xenon/errors'
-require 'xenon/etag'
-
-module Xenon
-  class Headers
-    # http://tools.ietf.org/html/rfc7232#section-3.2
-    class IfNoneMatch < ListHeader 'If-None-Match'
-      def initialize(*etags)
-        super(etags)
-      end
-
-      alias_method :etags, :values
-
-      def self.wildcard
-        new
-      end
-
-      def self.parse(s)
-        tree = Parsers::IfNoneMatchHeader.new.parse(s)
-        Parsers::IfNoneMatchHeaderTransform.new.apply(tree)
-      end
-
-      def wildcard?
-        etags.empty?
-      end
-
-      def merge(other)
-        raise Xenon::ProtocolError.new('Cannot merge wildcard headers') if wildcard? || other.wildcard?
-        super
-      end
-
-      def to_s
-        wildcard? ? '*' : super
-      end
-    end
-  end
-
-  module Parsers
-    class IfNoneMatchHeader < Parslet::Parser
-      include ETagHeaderRules
-      rule(:if_none_match) { (wildcard | (etag >> (list_sep >> etag).repeat)).as(:if_none_match) }
-      root(:if_none_match)
-    end
-
-    class IfNoneMatchHeaderTransform < ETagHeaderTransform
-      rule(if_none_match: { wildcard: simple(:w) }) { Headers::IfNoneMatch.new }
-      rule(if_none_match: sequence(:et)) { Headers::IfNoneMatch.new(*et) }
-      rule(if_none_match: simple(:et)) { Headers::IfNoneMatch.new(et) }
-    end
-  end
-end