xenon-routing 0.0.4 → 0.0.5

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

@@ -1,45 +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/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

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

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

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

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

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

data/xenon-http/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/xenon-http/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