xenon 0.0.3 → 0.0.4

data/lib/xenon/auth.rb

@@ -1,63 +0,0 @@
-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 BasicAuth
-    attr_reader :auth_params
-
-    def initialize(auth_params = {}, &store)
-      @auth_params = auth_params
-      @store = store
-    end
-
-    def scheme
-      'Basic'
-    end
-
-    def call(request)
-      header = request.header('Authorization') rescue nil
-      @store.call(header.credentials) if header && header.credentials.is_a?(BasicCredentials)
-    end
-  end
-end

data/lib/xenon/errors.rb

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

data/lib/xenon/etag.rb

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

@@ -1,112 +0,0 @@
-require 'active_support/core_ext/string'
-
-module Xenon
-  class Headers
-    include Enumerable
-
-    def initialize
-      @hash = {}
-    end
-
-    def initialize_dup(other)
-      super
-      @hash = @hash.dup
-    end
-
-    def freeze
-      @hash.freeze
-      super
-    end
-
-    def each(&block)
-      @hash.values.each(&block)
-    end
-
-    def set!(header)
-      @hash[header.name] = header
-      self
-    end
-
-    def add!(header)
-      existing = @hash[header.name]
-      if existing
-        if existing.respond_to?(:merge)
-          set!(existing.merge(header))
-        else
-          raise "Unmergeable header '#{header.name}' already exists"
-        end
-      else
-        set!(header)
-      end
-      self
-    end
-
-    %i(set add).each do |name|
-      define_method name do |header|
-        dup.send("#{name}!", header)
-      end
-    end
-
-    alias_method :<<, :add!
-
-    class << self
-      def register(klass)
-        (@registered ||= {})[klass.const_get(:NAME)] = klass
-      end
-
-      def header_class(name)
-        (@registered || {})[name]
-      end
-
-      def Header(name)
-        klass = Class.new do
-          def name
-            self.class.const_get(:NAME)
-          end
-
-          def self.inherited(base)
-            Headers.register(base)
-          end
-        end
-        Headers.const_set("#{name.tr('-', '_').classify}Header", klass)
-        klass.const_set(:NAME, name)
-        klass
-      end
-
-      def ListHeader(name)
-        klass = Header(name)
-        klass.class_eval do
-          attr_reader :values
-
-          def initialize(values)
-            @values = values
-          end
-
-          def merge(other)
-            self.class.new(*(@values + other.values))
-          end
-
-          def to_s
-            @values.map(&:to_s).join(', ')
-          end
-        end
-        klass
-      end
-    end
-
-    class Raw
-      attr_reader :name, :value
-
-      def initialize(name, value)
-        @name = name
-        @value = value
-      end
-
-      def to_s
-        @value
-      end
-    end
-  end
-end
-
-Dir[File.join(__dir__, 'headers', '*.rb')].each { |f| require f }

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