xenon-routing 0.0.4

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

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

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

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

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

@@ -0,0 +1,45 @@
+require 'xenon/headers'
+require 'xenon/parsers/header_rules'
+require 'xenon/errors'
+require 'xenon/etag'
+
+module Xenon
+  class Headers
+    # http://tools.ietf.org/html/rfc7233#section-3.2
+    class IfRange < Header 'If-Range'
+      attr_reader :date, :etag
+
+      def initialize(value)
+        case value
+        when Time, DateTime, Date then @date = value
+        when ETag then @etag = value
+        when String then @etag = ETag.parse(value)
+        else raise ArgumentError, 'Value must be a time or an etag.'
+        end
+
+        raise ProtocolError, 'If-Range headers must use strong ETags.' if @etag && @etag.weak?
+      end
+
+      def self.parse(s)
+        tree = Parsers::IfRangeHeader.new.parse(s)
+        Parsers::IfRangeHeaderTransform.new.apply(tree)
+      end
+
+      def to_s
+        @etag ? @etag.to_s : @date.httpdate
+      end
+    end
+  end
+
+  module Parsers
+    class IfRangeHeader < Parslet::Parser
+      include ETagHeaderRules
+      rule(:if_range) { (etag | http_date).as(:if_range) }
+      root(:if_range)
+    end
+
+    class IfRangeHeaderTransform < ETagHeaderTransform
+      rule(if_range: simple(:v)) { Headers::IfRange.new(v) }
+    end
+  end
+end

data/xenon-http/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/xenon-http/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/xenon-http/lib/xenon/headers/www_authenticate.rb

@@ -0,0 +1,71 @@
+require 'active_support/core_ext/hash/indifferent_access'
+require 'forwardable'
+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/xenon-http/lib/xenon/http.rb

@@ -0,0 +1,7 @@
+require 'xenon/http_version'
+require 'xenon/auth'
+require 'xenon/errors'
+require 'xenon/etag'
+require 'xenon/headers'
+require 'xenon/media_type'
+require 'xenon/quoted_string'

data/xenon-http/lib/xenon/http_version.rb

@@ -0,0 +1,3 @@
+module Xenon
+  HTTP_VERSION = File.read(File.join(__dir__, '..', '..', '..', 'VERSION'))
+end

data/xenon-http/lib/xenon/media_type.rb

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