xenon 0.0.2 → 0.0.3

data/lib/xenon/errors.rb

@@ -1,4 +1,5 @@
 module Xenon
   class Error < StandardError; end
   class ParseError < Error; end
+  class ProtocolError < Error; end
 end

data/lib/xenon/etag.rb

@@ -0,0 +1,48 @@
+require 'xenon/parsers/header_rules'
+
+module Xenon
+  class ETag
+    attr_reader :opaque_tag
+
+  	def initialize(opaque_tag, weak: false)
+      @opaque_tag = opaque_tag
+      @weak = weak
+  	end
+
+    def self.parse(s)
+      tree = Parsers::ETag.new.etag.parse(s)
+      Parsers::ETagHeaderTransform.new.apply(tree)
+    end
+
+  	def weak?
+  	  @weak
+  	end
+
+    def strong?
+      !weak?
+    end
+
+    def strong_eq?(other)
+      strong? && other.strong? && @opaque_tag == other.opaque_tag
+    end
+
+    def weak_eq?(other)
+      @opaque_tag == other.opaque_tag
+    end
+
+    def ==(other)
+      strong? == other.strong? && @opaque_tag == other.opaque_tag
+    end
+
+    def to_s
+      s = weak? ? "W/" : ""
+      s << '"' << @opaque_tag << '"'
+    end
+  end
+
+  module Parsers
+    class ETag < Parslet::Parser
+      include ETagHeaderRules
+    end
+  end
+end

data/lib/xenon/headers.rb

@@ -106,9 +106,7 @@ module Xenon
         @value
       end
     end
-
-    [:Accept, :AcceptCharset, :AcceptEncoding, :CacheControl, :ContentType].each do |sym|
-      autoload sym, "xenon/headers/#{sym.to_s.underscore}"
-    end
   end
 end
+
+Dir[File.join(__dir__, 'headers', '*.rb')].each { |f| require f }

data/lib/xenon/headers/accept.rb

@@ -1,4 +1,5 @@
 require 'xenon/headers'
+require 'xenon/parsers/header_rules'
 require 'xenon/parsers/media_type'
 
 module Xenon
@@ -20,8 +21,8 @@ module Xenon
 
   module Parsers
     class AcceptHeader < Parslet::Parser
-      include MediaTypeRules
-      rule(:accept) { (media_range >> (comma >> media_range).repeat).as(:accept) }
+      include HeaderRules, MediaTypeRules
+      rule(:accept) { (media_range >> (list_sep >> media_range).repeat).as(:accept) }
       root(:accept)
     end
 

data/lib/xenon/headers/accept_charset.rb

@@ -41,17 +41,17 @@ module Xenon
 
   module Parsers
     class AcceptCharsetHeader < Parslet::Parser
-      include BasicRules, WeightRules
+      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 >> (comma >> charset_range).repeat).as(:accept_charset) }
+      rule(:accept_charset) { (charset_range >> (list_sep >> 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) }
+    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

data/lib/xenon/headers/accept_encoding.rb

@@ -41,20 +41,20 @@ module Xenon
 
   module Parsers
     class AcceptEncodingHeader < Parslet::Parser
-      include BasicRules, WeightRules
+      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 >> (comma >> coding_range).repeat).maybe.as(:accept_encoding) }
+      rule(:accept_encoding) { (coding_range >> (list_sep >> 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) }
+    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 }

data/lib/xenon/headers/accept_language.rb

@@ -41,17 +41,17 @@ module Xenon
 
   module Parsers
     class AcceptLanguageHeader < Parslet::Parser
-      include BasicRules, WeightRules
+      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 >> (comma >> language_range).repeat).as(:accept_language) }
+      rule(:accept_language) { (language_range >> (list_sep >> 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) }
+    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

data/lib/xenon/headers/authorization.rb

@@ -1,51 +1,9 @@
 require 'base64'
+require 'xenon/auth'
 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'
@@ -58,6 +16,8 @@ module Xenon
       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
@@ -68,25 +28,19 @@ module Xenon
 
   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) }
+      include AuthHeaderRules
       rule(:credentials) { auth_scheme >> sp >> (token68 | auth_params) }
       rule(:authorization) { credentials.as(:authorization) }
       root(:authorization)
     end
 
-    class AuthorizationHeaderTransform < BasicTransform
+    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)) { 
+      rule(auth_scheme: simple(:s), token: simple(:t)) {
         case s
         when 'Basic' then BasicCredentials.decode(t)
-        else GenericCredentials.new(s, token: t) 
+        else GenericCredentials.new(s, token: t)
         end
       }
       rule(auth_scheme: simple(:s), auth_params: subtree(:p)) { GenericCredentials.new(s, params: Hash[p]) }

data/lib/xenon/headers/cache_control.rb

@@ -38,15 +38,15 @@ module Xenon
 
   module Parsers
     class CacheControlHeader < Parslet::Parser
-      include BasicRules
+      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 >> (comma >> directive).repeat).as(:cache_control) }
+      rule(:cache_control) { (directive >> (list_sep >> directive).repeat).as(:cache_control) }
       root(:cache_control)
     end
 
-    class CacheControlHeaderTransform < BasicTransform
+    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) }

data/lib/xenon/headers/content_type.rb

@@ -12,7 +12,7 @@ module Xenon
       end
 
       def self.parse(s)
-        ContentType.new(Xenon::ContentType.parse(s))
+        new(Xenon::ContentType.parse(s))
       end
 
       def to_s

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