xenon 0.0.3 → 0.0.4

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

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

@@ -1,70 +0,0 @@
-require 'active_support/core_ext/hash/indifferent_access'
-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