xenon-http 0.0.4

data/xenon-http/spec/xenon/headers/www_authenticate_spec.rb

@@ -0,0 +1,43 @@
+require 'xenon/headers/www_authenticate'
+
+describe Xenon::Headers::WWWAuthenticate do
+
+  context '::parse' do
+
+    it 'can parse a Basic challenge with a realm' do
+      header = Xenon::Headers::WWWAuthenticate.parse('Basic realm="simple"')
+      expect(header.challenges.size).to eq(1)
+      expect(header.challenges[0].auth_scheme).to eq('Basic')
+      expect(header.challenges[0].realm).to eq('simple')
+    end
+
+    it 'can parse a Digest challenge with a realm' do
+      header = Xenon::Headers::WWWAuthenticate.parse('Digest realm="testrealm@host.com", qop="auth,auth-int", nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093", opaque="5ccc069c403ebaf9f0171e9517f40e41"')
+      expect(header.challenges.size).to eq(1)
+      expect(header.challenges[0].auth_scheme).to eq('Digest')
+      expect(header.challenges[0].realm).to eq('testrealm@host.com')
+      expect(header.challenges[0].qop).to eq('auth,auth-int')
+      expect(header.challenges[0].nonce).to eq('dcd98b7102dd2f0e8b11d0f600bfb0c093')
+      expect(header.challenges[0].opaque).to eq('5ccc069c403ebaf9f0171e9517f40e41')
+    end
+
+    it 'can parse a custom challenge' do
+      header = Xenon::Headers::WWWAuthenticate.parse('Newauth realm="apps", type=1, title="Login to \"apps\""')
+      expect(header.challenges.size).to eq(1)
+      expect(header.challenges[0].auth_scheme).to eq('Newauth')
+      expect(header.challenges[0].realm).to eq('apps')
+      expect(header.challenges[0].type).to eq('1')
+      expect(header.challenges[0].title).to eq('Login to "apps"')
+    end
+
+    it 'can parse multiple challenges' do
+      header = Xenon::Headers::WWWAuthenticate.parse('Digest realm="testrealm@host.com", qop="auth,auth-int", nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093", opaque="5ccc069c403ebaf9f0171e9517f40e41", Basic realm="simple", Newauth realm="apps", type=1, title="Login to \"apps\""')
+      expect(header.challenges.size).to eq(3)
+      expect(header.challenges[0].auth_scheme).to eq('Digest')
+      expect(header.challenges[1].auth_scheme).to eq('Basic')
+      expect(header.challenges[2].auth_scheme).to eq('Newauth')
+    end
+
+
+  end
+end

data/xenon-http/spec/xenon/media_type_spec.rb

@@ -0,0 +1,267 @@
+require 'xenon/media_type'
+
+describe Xenon::MediaType do
+
+  context '::parse' do
+    it 'can parse basic media types' do
+      mt = Xenon::MediaType.parse('application/json')
+      expect(mt.type).to eq('application')
+      expect(mt.subtype).to eq('json')
+    end
+    it 'can parse media types with a subtype suffix' do
+      mt = Xenon::MediaType.parse('application/rss+xml')
+      expect(mt.type).to eq('application')
+      expect(mt.subtype).to eq('rss+xml')
+    end
+
+    it 'can parse media types with parameters' do
+      mt = Xenon::MediaType.parse('text/plain; format=flowed; paged')
+      expect(mt.type).to eq('text')
+      expect(mt.subtype).to eq('plain')
+      expect(mt.params).to eq({ 'format' => 'flowed', 'paged' => nil })
+    end
+
+    it 'strips whitespace around separators' do
+      mt = Xenon::MediaType.parse('text/plain ; format = flowed ; paged')
+      expect(mt.type).to eq('text')
+      expect(mt.subtype).to eq('plain')
+      expect(mt.params).to eq({ 'format' => 'flowed', 'paged' => nil })
+    end
+
+    it 'raises an error when the media type contains wildcards' do
+      expect { Xenon::MediaType.parse('*/*') }.to raise_error(Xenon::ParseError)
+      expect { Xenon::MediaType.parse('application/*') }.to raise_error(Xenon::ParseError)
+    end
+
+    it 'raises an error when the media type is invalid' do
+      expect { Xenon::MediaType.parse('application') }.to raise_error(Xenon::ParseError)
+      expect { Xenon::MediaType.parse('application; foo=bar') }.to raise_error(Xenon::ParseError)
+      expect { Xenon::MediaType.parse('/json') }.to raise_error(Xenon::ParseError)
+      expect { Xenon::MediaType.parse('/json; foo=bar') }.to raise_error(Xenon::ParseError)
+    end
+  end
+
+  %w(application audio image message multipart text video).each do |type|
+    context "#{type}?" do
+      it "returns true when the root type is '#{type}'" do
+        mt = Xenon::MediaType.new(type, 'dummy')
+        expect(mt.send("#{type}?")).to eq(true)
+      end
+
+      it "returns false when the root type is not '#{type}'" do
+        mt = Xenon::MediaType.new('dummy', 'dummy')
+        expect(mt.send("#{type}?")).to eq(false)
+      end
+    end
+  end
+
+  { experimental?: 'x', personal?: 'prs', vendor?: 'vnd' }.each do |method, prefix|
+    context method do
+      it "returns true when the subtype starts with '#{prefix}.'" do
+        mt = Xenon::MediaType.new('application', "#{prefix}.dummy")
+        expect(mt.send(method)).to eq(true)
+      end
+
+      it "returns false when the subtype does not start with '#{prefix}.'" do
+        mt = Xenon::MediaType.new('application', "dummy.dummy")
+        expect(mt.send(method)).to eq(false)
+      end
+    end
+  end
+
+  %w(ber der fastinfoset json wbxml xml zip).each do |format|
+    context "#{format}?" do
+      it "returns true when the subtype is '#{format}'" do
+        mt = Xenon::MediaType.new('application', format)
+        expect(mt.send("#{format}?")).to eq(true)
+      end
+
+      it "returns true when the subtype ends with '+#{format}'" do
+        mt = Xenon::MediaType.new('application', "dummy+#{format}")
+        expect(mt.send("#{format}?")).to eq(true)
+      end
+
+      it "returns false when the subtype is not '#{format}' and does not end with '+#{format}'" do
+        mt = Xenon::MediaType.new('dummy', 'dummy+dummy')
+        expect(mt.send("#{format}?")).to eq(false)
+      end
+    end
+  end
+
+  context '#to_s' do
+    it 'returns the string representation of a media type' do
+      mt = Xenon::MediaType.new('text', 'plain', 'format' => 'flowed', 'paged' => nil)
+      expect(mt.to_s).to eq('text/plain; format=flowed; paged')
+    end
+  end
+  
+end
+
+describe Xenon::MediaRange do
+
+  context '::parse' do
+    it 'can parse basic media ranges' do
+      mt = Xenon::MediaRange.parse('application/json')
+      expect(mt.type).to eq('application')
+      expect(mt.subtype).to eq('json')
+    end
+
+    it 'can parse media ranges with parameters' do
+      mt = Xenon::MediaRange.parse('text/plain; format=flowed; paged')
+      expect(mt.type).to eq('text')
+      expect(mt.subtype).to eq('plain')
+      expect(mt.params).to eq({ 'format' => 'flowed', 'paged' => nil })
+    end
+
+    it 'strips whitespace around separators' do
+      mt = Xenon::MediaRange.parse('text/plain ; format = flowed ; paged')
+      expect(mt.type).to eq('text')
+      expect(mt.subtype).to eq('plain')
+      expect(mt.params).to eq({ 'format' => 'flowed', 'paged' => nil })
+    end
+
+    it 'can parse media ranges with subtype wildcards' do
+      mt = Xenon::MediaRange.parse('application/*')
+      expect(mt.type).to eq('application')
+      expect(mt.subtype).to eq('*')
+    end
+
+    it 'can parse media ranges with type and subtype wildcards' do
+      mt = Xenon::MediaRange.parse('*/*')
+      expect(mt.type).to eq('*')
+      expect(mt.subtype).to eq('*')
+    end
+
+    it 'extracts q from the parameters' do
+      mt = Xenon::MediaRange.parse('text/plain; q=0.8; format=flowed; paged')
+      expect(mt.type).to eq('text')
+      expect(mt.subtype).to eq('plain')
+      expect(mt.q).to eq(0.8)
+      expect(mt.params).to eq({ 'format' => 'flowed', 'paged' => nil })
+    end
+
+    it 'uses the default value for q if the value is not numeric' do
+      mt = Xenon::MediaRange.parse('application/json; q=foo')
+      expect(mt.type).to eq('application')
+      expect(mt.subtype).to eq('json')
+      expect(mt.q).to eq(Xenon::MediaRange::DEFAULT_Q)
+    end
+
+    it 'raises an error when the media range is invalid' do
+      expect { Xenon::MediaRange.parse('application') }.to raise_error(Xenon::ParseError)
+      expect { Xenon::MediaRange.parse('application; foo=bar') }.to raise_error(Xenon::ParseError)
+      expect { Xenon::MediaRange.parse('*/json') }.to raise_error(Xenon::ParseError)
+      expect { Xenon::MediaRange.parse('/json') }.to raise_error(Xenon::ParseError)
+      expect { Xenon::MediaRange.parse('/json; foo=bar') }.to raise_error(Xenon::ParseError)
+    end
+  end
+
+  context '#<=>' do
+    it 'considers a wildcard type less than a regular type' do
+      mr1 = Xenon::MediaRange.new('*', '*')
+      mr2 = Xenon::MediaRange.new('text', '*')
+      expect(mr1 <=> mr2).to eq(-1)
+    end
+
+    it 'considers a wildcard subtype less than a regular subtype' do
+      mr1 = Xenon::MediaRange.new('application', '*')
+      mr2 = Xenon::MediaRange.new('text', 'plain')
+      expect(mr1 <=> mr2).to eq(-1)
+    end
+
+    it 'considers media ranges with type and subtype equal' do
+      mr1 = Xenon::MediaRange.new('application', 'json')
+      mr2 = Xenon::MediaRange.new('text', 'plain')
+      expect(mr1 <=> mr2).to eq(0)
+    end
+
+    it 'considers a media range with parameters greater than one without' do
+      mr1 = Xenon::MediaRange.new('text', 'plain', 'format' => 'flowed')
+      mr2 = Xenon::MediaRange.new('text', 'plain')
+      expect(mr1 <=> mr2).to eq(1)
+    end
+
+    it 'does not consider the quality when one media range is more specific' do
+      mr1 = Xenon::MediaRange.new('application', '*', 'q' => '0.3')
+      mr2 = Xenon::MediaRange.new('*', '*', 'q' => '0.5')
+      expect(mr1 <=> mr2).to eq(1)
+    end
+
+    it 'considers the quality when media ranges are equally specific' do
+      mr1 = Xenon::MediaRange.new('application', 'json', 'q' => '0.8')
+      mr2 = Xenon::MediaRange.new('application', 'xml')
+      expect(mr1 <=> mr2).to eq(-1)
+    end
+  end
+
+  %i(=~ ===).each do |name|
+    context "##{name}" do
+      it 'returns true when the type and subtype are wildcards' do
+        mr = Xenon::MediaRange.new('*', '*')
+        mt = Xenon::MediaType.new('application', 'json')
+        expect(mr.send(name, mt)).to eq(true)
+      end
+
+      it 'returns true when the type matches and subtype is a wildcard' do
+        mr = Xenon::MediaRange.new('application', '*')
+        mt = Xenon::MediaType.new('application', 'json')
+        expect(mr.send(name, mt)).to eq(true)
+      end
+
+      it 'returns true when the type and subtype match exactly' do
+        mr = Xenon::MediaRange.new('application', 'json')
+        mt = Xenon::MediaType.new('application', 'json')
+        expect(mr.send(name, mt)).to eq(true)
+      end
+
+      it 'returns true when the type, subtype and parameters match exactly' do
+        mr = Xenon::MediaRange.new('text', 'plain', 'format' => 'flowed')
+        mt = Xenon::MediaType.new('text', 'plain', 'format' => 'flowed', 'paged' => nil)
+        expect(mr.send(name, mt)).to eq(true)
+      end
+
+      it 'returns true when the the media type has more specific parameters' do
+        mr = Xenon::MediaRange.new('text', 'plain')
+        mt = Xenon::MediaType.new('text', 'plain', 'format' => 'flowed', 'paged' => nil)
+        expect(mr.send(name, mt)).to eq(true)
+      end
+
+      it 'returns false when the type is different' do
+        mr = Xenon::MediaRange.new('text', 'json')
+        mt = Xenon::MediaType.new('application', 'json')
+        expect(mr.send(name, mt)).to eq(false)
+      end
+
+      it 'returns false when the type matches but subtype is different' do
+        mr = Xenon::MediaRange.new('application', 'xml')
+        mt = Xenon::MediaType.new('application', 'json')
+        expect(mr.send(name, mt)).to eq(false)
+      end
+
+      it 'returns false when the media range has more specific parameters' do
+        mr = Xenon::MediaRange.new('text', 'plain', 'format' => 'flowed', 'paged' => nil)
+        mt = Xenon::MediaType.new('text', 'plain')
+        expect(mr.send(name, mt)).to eq(false)
+      end
+
+      it 'returns false when the media range has a different parameter value' do
+        mr = Xenon::MediaRange.new('text', 'plain', 'format' => 'flowed')
+        mt = Xenon::MediaType.new('text', 'plain', 'format' => 'linear')
+        expect(mr.send(name, mt)).to eq(false)
+      end
+    end
+  end
+
+  context '#to_s' do
+    it 'returns the string representation of a media range' do
+      mt = Xenon::MediaRange.new('text', 'plain', 'q' => 0.8, 'format' => 'flowed', 'paged' => nil)
+      expect(mt.to_s).to eq('text/plain; format=flowed; paged; q=0.8')
+    end
+
+    it 'omits the q parameter when it is 1.0' do
+      mt = Xenon::MediaRange.new('application', 'json', 'q' => 1.0)
+      expect(mt.to_s).to eq('application/json')
+    end
+  end
+
+end

data/xenon-http/xenon-http.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'xenon/http_version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'xenon-http'
+  spec.version       = Xenon::HTTP_VERSION
+  spec.authors       = ['Greg Beech']
+  spec.email         = ['greg@gregbeech.com']
+  spec.summary       = %q{An HTTP framework for building RESTful APIs.}
+  spec.description   = %q{Provides a model for the HTTP protocol and a tree-based routing syntax.}
+  spec.homepage      = 'https://github.com/gregbeech/xenon'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^xenon-http/bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^xenon-http/(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 2.2.0'
+
+  spec.add_runtime_dependency 'activesupport', '~> 4.0'
+  spec.add_runtime_dependency 'parslet', '~> 1.7'
+end

data/xenon-routing/lib/xenon/api.rb

@@ -0,0 +1,118 @@
+require 'json'
+require 'rack'
+require 'xenon/routing'
+
+module Xenon
+  class API
+    include Xenon::Routing::Directives
+
+    DEFAULT_MARSHALLERS = [JsonMarshaller.new]
+
+    class << self
+      def marshallers(*marshallers)
+        @marshallers = marshallers unless marshallers.nil? || marshallers.empty?
+        (@marshallers.nil? || @marshallers.empty?) ? DEFAULT_MARSHALLERS : @marshallers
+      end
+
+      def select_marshaller(media_ranges)
+        weighted = marshallers.map do |marshaller|
+          media_range = media_ranges.find { |media_range| marshaller.marshal_to?(media_range) }
+          [marshaller, media_range ? media_range.q : 0]
+        end
+        weighted.select { |_, q| q > 0 }.sort_by { |_, q| q }.map { |m, _| m }.last
+      end
+    end
+
+    attr_reader :context
+
+    class << self
+      def routes
+        @routes ||= []
+      end
+
+      def method_missing(name, *args, &block)
+        if instance_methods.include?(name)
+          routes << [name, args, block]
+        else
+          super
+        end
+      end
+    end
+
+    def call(env)
+      dup.call!(env)
+    end
+
+    def call!(env)
+      @context = Routing::Context.new(Request.new(Rack::Request.new(env)), Response.new)
+
+      accept = @context.request.header('Accept')
+      marshaller = accept ? self.class.select_marshaller(accept.media_ranges) : self.class.marshallers.first
+
+      catch (:complete) do
+        begin
+          if marshaller
+            self.class.routes.each do |route|
+              name, args, block = route
+              route_block = proc { instance_eval(&block) }
+              send(name, *args, &route_block)
+            end
+          else
+            reject :accept, supported: self.class.marshallers.map(&:media_type)
+          end
+          handle_rejections(@context.rejections)
+        rescue => e
+          handle_error(e)
+        end
+      end
+
+      marshaller ||= self.class.marshallers.first
+      resp = @context.response.copy(
+        headers: @context.response.headers.set(Headers::ContentType.new(marshaller.content_type)),
+        body: marshaller.marshal(@context.response.body))
+      [resp.status, resp.headers.map { |h| [h.name, h.to_s] }.to_h, resp.body]
+    end
+
+    def handle_error(e)
+      puts "handle_error: #{e.class}: #{e}\n  #{e.backtrace.join("\n  ")}"
+      case e
+      when ParseError
+        fail 400, e.message
+      else
+        fail 500, e.message # TODO: Only if verbose errors configured
+      end
+    end
+
+    def handle_rejections(rejections)
+      puts "handle_rejections: #{rejections}"
+      if rejections.empty?
+        fail 404
+      else
+        rejection = rejections.first
+        case rejection.reason
+        when :accept
+          fail 406, "Supported media types: #{rejection[:supported].join(", ")}"
+        when :forbidden
+          fail 403
+        when :header
+          fail 400, "Missing required header: #{rejection[:required]}"
+        when :method
+          supported = rejections.take_while { |r| r.reason == :method }.map { |r| r[:supported].upcase }
+          fail 405, "Supported methods: #{supported.join(", ")}"
+        when :unauthorized
+          if rejection[:scheme]
+            challenge = Headers::Challenge.new(rejection[:scheme], rejection.info.except(:scheme))
+            respond_with_header Headers::WWWAuthenticate.new(challenge) do
+              fail 401
+            end
+          else
+            fail 401
+          end
+        else
+          fail 500
+        end
+      end
+    end
+
+  end
+end