regal 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ddd9f8426b202a6cd710732b5d90121c1be6de3d
+  data.tar.gz: 923b6298aeaa7086e43e3856e4a3a1cfc840037b
+SHA512:
+  metadata.gz: 875dc13b486d7d0629ecce89564c3f26b2084a0c72fb6a98cca6ef3316527be8482d9dbfbe7b3216326afdf85e930bc7ab33bf5a672ddeb24a4077ce20efda01
+  data.tar.gz: 47ef101e32275bacc1019a74d7a54ab040b020fc31931b92c5fd8ddee4dd9108524efa74003a167655b04a39d6e12f9ad5e06458c92ff9066da33c8cfa297f99

data/.yardopts

@@ -0,0 +1,4 @@
+--no-private
+--markup markdown
+lib/**/*.rb
+-- README

data/lib/regal.rb

@@ -0,0 +1,6 @@
+module Regal
+end
+
+require 'regal/app'
+require 'regal/request'
+require 'regal/response'

data/lib/regal/app.rb

@@ -0,0 +1,236 @@
+require 'rack'
+
+module Regal
+  module App
+    def self.create(*args, &block)
+      Class.new(Route).create(nil, &block)
+    end
+
+    def self.new(*args, &block)
+      create(&block).new(*args)
+    end
+  end
+
+  module RouterDsl
+    attr_reader :name
+
+    def create(name=nil, &block)
+      @mounted_apps = []
+      @static_routes = {}
+      @dynamic_route = nil
+      @handlers = {}
+      @befores = []
+      @afters = []
+      @setups = []
+      @middlewares = []
+      @rescuers = []
+      @name = name
+      class_exec(&block)
+      self
+    end
+
+    def setups
+      if superclass.respond_to?(:setups) && (setups = superclass.setups)
+        setups + @setups
+      else
+        @setups && @setups.dup
+      end
+    end
+
+    def befores
+      if superclass.respond_to?(:befores) && (befores = superclass.befores)
+        befores + @befores
+      else
+        @befores && @befores.dup
+      end
+    end
+
+    def afters
+      if superclass.respond_to?(:afters) && (afters = superclass.afters)
+        afters + @afters
+      else
+        @afters && @afters.dup
+      end
+    end
+
+    def middlewares
+      if superclass.respond_to?(:middlewares) && (middlewares = superclass.middlewares)
+        middlewares + @middlewares
+      else
+        @middlewares && @middlewares.dup
+      end
+    end
+
+    def rescuers
+      if superclass.respond_to?(:rescuers) && (rescuers = superclass.rescuers)
+      rescuers + @rescuers
+      else
+        @rescuers && @rescuers.dup
+      end
+    end
+
+    def create_routes(args)
+      routes = {}
+      if @dynamic_route
+        routes.default = @dynamic_route.new(*args)
+      end
+      @mounted_apps.each do |app|
+        routes.merge!(app.create_routes(args))
+      end
+      @static_routes.each do |path, cls|
+        routes[path] = cls.new(*args)
+      end
+      routes
+    end
+
+    def handlers
+      @handlers.dup
+    end
+
+    def route(s, &block)
+      r = Class.new(self).create(s, &block)
+      if s.is_a?(Symbol)
+        @dynamic_route = r
+      else
+        @static_routes[s] = r
+      end
+    end
+
+    def mount(app)
+      @mounted_apps << app
+    end
+
+    def use(middleware, *args, &block)
+      @middlewares << [middleware, args, block]
+    end
+
+    def setup(&block)
+      @setups << block
+    end
+
+    def before(&block)
+      @befores << block
+    end
+
+    def after(&block)
+      @afters << block
+    end
+
+    def rescue_from(type, &block)
+      @rescuers << [type, block]
+    end
+
+    [:get, :head, :options, :delete, :post, :put, :patch].each do |name|
+      upcased_name = name.to_s.upcase
+      define_method(name) do |&block|
+        @handlers[upcased_name] = block
+      end
+    end
+
+    def any(&block)
+      @handlers.default = block
+    end
+  end
+
+  class Route
+    extend RouterDsl
+
+    SLASH = '/'.freeze
+    PATH_CAPTURES_KEY = 'regal.path_captures'.freeze
+    PATH_COMPONENTS_KEY = 'regal.path_components'.freeze
+    PATH_INFO_KEY = 'PATH_INFO'.freeze
+    REQUEST_METHOD_KEY = 'REQUEST_METHOD'.freeze
+    METHOD_NOT_ALLOWED_RESPONSE = [405, {}.freeze, [].freeze].freeze
+    NOT_FOUND_RESPONSE = [404, {}.freeze, [].freeze].freeze
+    EMPTY_BODY = ''.freeze
+
+    attr_reader :name
+
+    def initialize(*args)
+      @actual = self.dup
+      self.class.setups.each do |setup|
+        @actual.instance_exec(*args, &setup)
+      end
+      @befores = self.class.befores
+      @afters = self.class.afters.reverse
+      @rescuers = self.class.rescuers
+      @routes = self.class.create_routes(args)
+      @handlers = self.class.handlers
+      @name = self.class.name
+      if !self.class.middlewares.empty?
+        @app = self.class.middlewares.reduce(method(:handle)) do |app, (middleware, args, block)|
+          middleware.new(app, *args, &block)
+        end
+      end
+      freeze
+    end
+
+    def call(env)
+      path_components = env[PATH_COMPONENTS_KEY] ||= env[PATH_INFO_KEY].split(SLASH).drop(1)
+      path_component = path_components.shift
+      if path_component && (app = @routes[path_component])
+        dynamic_route = !@routes.key?(path_component)
+        if dynamic_route
+          env[PATH_CAPTURES_KEY] ||= {}
+          env[PATH_CAPTURES_KEY][app.name] = path_component
+        end
+        app.call(env)
+      elsif path_component.nil?
+        if @app
+          @app.call(env)
+        else
+          handle(env)
+        end
+      else
+        NOT_FOUND_RESPONSE
+      end
+    end
+
+    private
+
+    def handle(env)
+      if (handler = @handlers[env[REQUEST_METHOD_KEY]])
+        request = Request.new(env)
+        response = Response.new
+        begin
+          @befores.each do |before|
+            break if response.finished?
+            @actual.instance_exec(request, response, &before)
+          end
+          unless response.finished?
+            result = @actual.instance_exec(request, response, &handler)
+            if request.head? || response.status < 200 || response.status == 204 || response.status == 205 || response.status == 304
+              response.no_body
+            elsif !response.finished?
+              response.body = result
+            end
+          end
+        rescue => e
+          handle_error(e, request, response)
+        end
+        @afters.each do |after|
+          begin
+            @actual.instance_exec(request, response, &after)
+          rescue => e
+            handle_error(e, request, response)
+          end
+        end
+        response
+      else
+        METHOD_NOT_ALLOWED_RESPONSE
+      end
+    end
+
+    def handle_error(e, request, response)
+      handled = false
+      @rescuers.each do |type, handler|
+        if type === e
+          handler.call(e, request, response)
+          handled = true
+          break
+        end
+      end
+      raise unless handled
+    end
+  end
+end

data/lib/regal/request.rb

@@ -0,0 +1,61 @@
+module Regal
+  class Request
+    attr_reader :env, :attributes
+
+    def initialize(env)
+      @env = env
+      @attributes = {}
+    end
+
+    def request_method
+      @env[REQUEST_METHOD_KEY]
+    end
+
+    def head?
+      request_method == HEAD_METHOD
+    end
+
+    def parameters
+      @parameters ||= begin
+        path_captures = @env[Route::PATH_CAPTURES_KEY]
+        query = Rack::Utils.parse_query(@env[QUERY_STRING_KEY])
+        query.merge!(path_captures) if path_captures
+        query.freeze
+      end
+    end
+
+    def headers
+      @headers ||= begin
+        headers = @env.each_with_object({}) do |(key, value), headers|
+          if key.start_with?(HEADER_PREFIX)
+            normalized_key = key[HEADER_PREFIX.length, key.length - HEADER_PREFIX.length]
+            normalized_key.gsub!(/(?<=^.|_.)[^_]+/) { |str| str.downcase }
+            normalized_key.gsub!('_', '-')
+          elsif key == CONTENT_LENGTH_KEY
+            normalized_key = CONTENT_LENGTH_HEADER
+          elsif key == CONTENT_TYPE_KEY
+            normalized_key = CONTENT_TYPE_HEADER
+          end
+          if normalized_key
+            headers[normalized_key] = value
+          end
+        end
+        headers.freeze
+      end
+    end
+
+    def body
+      @env[RACK_INPUT_KEY]
+    end
+
+    HEADER_PREFIX = 'HTTP_'.freeze
+    QUERY_STRING_KEY = 'QUERY_STRING'.freeze
+    CONTENT_LENGTH_KEY = 'CONTENT_LENGTH'.freeze
+    CONTENT_LENGTH_HEADER = 'Content-Length'.freeze
+    CONTENT_TYPE_KEY = 'CONTENT_TYPE'.freeze
+    CONTENT_TYPE_HEADER = 'Content-Type'.freeze
+    RACK_INPUT_KEY = 'rack.input'.freeze
+    REQUEST_METHOD_KEY = 'REQUEST_METHOD'.freeze
+    HEAD_METHOD = 'HEAD'.freeze
+  end
+end

data/lib/regal/response.rb

@@ -0,0 +1,61 @@
+module Regal
+  class Response
+    attr_accessor :status, :body, :raw_body
+    attr_reader :headers
+
+    EMPTY_BODY = [].freeze
+
+    def initialize
+      @status = 200
+      @headers = {}
+      @body = nil
+      @raw_body = nil
+      @finished = false
+    end
+
+    def finish
+      @finished = true
+    end
+
+    def finished?
+      @finished
+    end
+
+    def no_body
+      @raw_body = EMPTY_BODY
+    end
+
+    def [](n)
+      case n
+      when 0 then @status
+      when 1 then @headers
+      when 2 then rack_body
+      end
+    end
+
+    def []=(n, v)
+      case n
+      when 0 then @status = v
+      when 1 then @headers = v
+      when 2 then @raw_body = v
+      end
+    end
+
+    def to_ary
+      [@status, @headers, rack_body]
+    end
+    alias_method :to_a, :to_ary
+
+    private
+
+    def rack_body
+      if @raw_body
+        @raw_body
+      elsif @body.is_a?(String)
+        [@body]
+      else
+        @body
+      end
+    end
+  end
+end

data/lib/regal/version.rb

@@ -0,0 +1,3 @@
+module Regal
+  VERSION = '0.1.0'.freeze
+end

data/spec/regal/app_spec.rb

@@ -0,0 +1,924 @@
+require 'spec_helper'
+require 'json'
+
+module Regal
+  describe App do
+    include Rack::Test::Methods
+
+    context 'a basic app' do
+      let :app do
+        App.new do
+          get do
+            'root'
+          end
+
+          route 'hello' do
+            get do
+              'hello'
+            end
+
+            route 'world' do
+              get do
+                'hello world'
+              end
+            end
+          end
+        end
+      end
+
+      it 'routes a request' do
+        get '/hello'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('hello')
+      end
+
+      it 'routes a request to the root' do
+        get '/'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('root')
+      end
+
+      it 'routes a request with more than one path component' do
+        get '/hello/world'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('hello world')
+      end
+
+      it 'responds with 404 when the path does not match any route' do
+        get '/hello/fnord'
+        expect(last_response.status).to eq(404)
+      end
+
+      it 'responds with 405 when the path matches a route but there is no handler for the HTTP method' do
+        delete '/hello/world'
+        expect(last_response.status).to eq(405)
+      end
+    end
+
+    context 'a simple interactive app' do
+      let :app do
+        App.new do
+          route 'echo' do
+            get do |request|
+              request.parameters['s']
+            end
+
+            post do |request|
+              request.body.read
+            end
+          end
+
+          route 'international-hello' do
+            get do |request|
+              case request.headers['Accept-Language']
+              when 'sv_SE'
+                'hej'
+              when 'fr_FR'
+                'bonjour'
+              else
+                '?'
+              end
+            end
+          end
+        end
+      end
+
+      it 'can access the query parameters' do
+        get '/echo?s=hallo'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('hallo')
+      end
+
+      it 'can access the request headers' do
+        get '/international-hello', nil, {'HTTP_ACCEPT_LANGUAGE' => 'sv_SE'}
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('hej')
+        get '/international-hello', nil, {'HTTP_ACCEPT_LANGUAGE' => 'fr_FR'}
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('bonjour')
+      end
+
+      it 'can access the request body' do
+        post '/echo', 'blobblobblob'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('blobblobblob')
+      end
+    end
+
+    context 'an app that does more than just respond with a body' do
+      let :app do
+        App.new do
+          route 'redirect' do
+            get do |_, response|
+              response.status = 307
+              response.headers['Location'] = 'somewhere/else'
+            end
+          end
+        end
+      end
+
+      it 'can change the response code' do
+        get '/redirect'
+        expect(last_response.status).to eq(307)
+      end
+
+      it 'can set response headers' do
+        get '/redirect'
+        expect(last_response.headers).to include('Location' => 'somewhere/else')
+      end
+    end
+
+    context 'an app doing work before route handlers' do
+      let :app do
+        App.new do
+          before do |request|
+            request.attributes[:some_key] = [1]
+          end
+
+          get do |request|
+            request.attributes[:some_key].join(',')
+          end
+
+          route 'one-before' do
+            before do |request|
+              request.attributes[:some_key] << 2
+            end
+
+            get do |request|
+              request.attributes[:some_key].join(',')
+            end
+          end
+
+          route 'two-before' do
+            before do |request|
+              request.attributes[:some_key] << 2
+            end
+
+            before do |request|
+              request.attributes[:some_key] << 3
+            end
+
+            get do |request|
+              request.attributes[:some_key].join(',')
+            end
+
+            route 'another-before' do
+              before do |request|
+                request.attributes[:some_key] << 4
+              end
+
+              get do |request|
+                request.attributes[:some_key].join(',')
+              end
+            end
+          end
+
+          route 'redirect-before' do
+            before do |_, response|
+              response.headers['Location'] = 'somewhere/else'
+              response.status = 307
+              response.body = 'Go somewhere else'
+              response.finish
+            end
+
+            before do |_, response|
+              response.body = 'whoopiedoo'
+            end
+
+            get do
+              "I'm not called!"
+            end
+
+            after do |_, response|
+              response.headers['WasAfterCalled'] = 'yes'
+            end
+          end
+        end
+      end
+
+      it 'calls the before block before the request handler' do
+        get '/'
+        expect(last_response.body).to eq('1')
+      end
+
+      it 'calls the before blocks of all routes before the request handler' do
+        get '/one-before'
+        expect(last_response.body).to eq('1,2')
+      end
+
+      it 'calls the before blocks of a route in order' do
+        get '/two-before'
+        expect(last_response.body).to eq('1,2,3')
+      end
+
+      it 'calls all before blocks of a route before the request handler' do
+        get '/two-before/another-before'
+        expect(last_response.body).to eq('1,2,3,4')
+      end
+
+      it 'gives the before blocks access to the response' do
+        get '/redirect-before'
+        expect(last_response.status).to eq(307)
+      end
+
+      context 'when the response is marked as finished' do
+        before do
+          get '/redirect-before'
+        end
+
+        it 'does not call further handlers or before blocks when the response is marked as finished' do
+          expect(last_response.body).to eq('Go somewhere else')
+        end
+
+        it 'calls after blocks' do
+          expect(last_response.headers).to include('WasAfterCalled' => 'yes')
+        end
+      end
+    end
+
+    context 'an app doing work after route handlers' do
+      let :app do
+        App.new do
+          after do |_, response|
+            response.headers['Content-Type'] = 'application/json'
+            response.body = JSON.dump(response.body)
+          end
+
+          get do |request|
+            {'root' => true}
+          end
+
+          route 'one-after' do
+            after do |_, response|
+              response.body['list'] << 1
+            end
+
+            get do |request|
+              {'list' => []}
+            end
+          end
+
+          route 'two-after' do
+            after do |request, response|
+              response.body['list'] << 1
+            end
+
+            after do |request, response|
+              response.body['list'] << 2
+            end
+
+            get do |request|
+              {'list' => []}
+            end
+
+            route 'another-after' do
+              after do |request, response|
+                response.body['list'] << 3
+              end
+
+              get do |request|
+                {'list' => []}
+              end
+            end
+          end
+        end
+      end
+
+      it 'calls the after block after the request handler' do
+        get '/'
+        expect(last_response.body).to eq('{"root":true}')
+      end
+
+      it 'calls the after blocks of all routes after the request handler' do
+        get '/one-after'
+        expect(last_response.body).to eq('{"list":[1]}')
+      end
+
+      it 'calls all after blocks of a route in order' do
+        get '/two-after'
+        expect(last_response.body).to eq('{"list":[2,1]}')
+      end
+
+      it 'calls all after blocks of a route after the request handler' do
+        get '/two-after/another-after'
+        expect(last_response.body).to eq('{"list":[3,2,1]}')
+      end
+    end
+
+    context 'an app that has capturing routes' do
+      let :app do
+        App.new do
+          route 'foo' do
+            route :bar do
+              get do
+                'whatever'
+              end
+
+              route 'echo' do
+                get do |request|
+                  request.parameters[:bar]
+                end
+              end
+            end
+
+            route 'bar' do
+              get do
+                'bar'
+              end
+            end
+          end
+        end
+      end
+
+      it 'matches anything for the capture route' do
+        get '/foo/something'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('whatever')
+        get '/foo/something-else'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('whatever')
+      end
+
+      it 'picks static routes first' do
+        get '/foo/bar'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('bar')
+      end
+
+      it 'captures the path component as a parameter using a symbol as key' do
+        get '/foo/zzz/echo'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('zzz')
+        get '/foo/q/echo'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('q')
+      end
+    end
+
+    context 'an app that mounts another app' do
+      GoodbyeApp = App.create do
+        route 'goodbye' do
+          get do
+            'goodbye'
+          end
+        end
+      end
+
+      HelloApp = App.create do
+        route 'hello' do
+          get do
+            'hello'
+          end
+
+          route 'you' do
+            route 'say' do
+              mount GoodbyeApp
+            end
+          end
+        end
+      end
+
+      let :app do
+        App.new do
+          route 'i' do
+            route 'say' do
+              mount HelloApp
+              mount GoodbyeApp
+            end
+          end
+
+          route 'oh' do
+            mount HelloApp
+          end
+        end
+      end
+
+      it 'routes a request into the other app' do
+        get '/i/say/hello'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('hello')
+      end
+
+      it 'can mount multiple apps' do
+        get '/i/say/goodbye'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('goodbye')
+      end
+
+      it 'routes a request into apps that mount yet more apps' do
+        get '/i/say/hello/you/say/goodbye'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('goodbye')
+      end
+
+      it 'can mount the same app multiple times' do
+        get '/oh/hello'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('hello')
+      end
+    end
+
+    context 'an app that supports all HTTP methods' do
+      let :app do
+        App.new do
+          get do |request|
+            request.request_method
+          end
+
+          head do |request|
+            request.request_method
+          end
+
+          options do |request|
+            request.request_method
+          end
+
+          delete do |request|
+            request.request_method
+          end
+
+          post do |request|
+            request.request_method
+          end
+
+          put do |request|
+            request.request_method
+          end
+
+          patch do |request|
+            request.request_method
+          end
+
+          route 'anything' do
+            any do |request|
+              request.request_method
+            end
+          end
+        end
+      end
+
+      it 'routes GET requests' do
+        get '/'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('GET')
+      end
+
+      it 'routes HEAD requests, but does not respond with any body' do
+        head '/'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to be_empty
+      end
+
+      it 'routes OPTIONS requests' do
+        options '/'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('OPTIONS')
+      end
+
+      it 'routes DELETE requests' do
+        delete '/'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('DELETE')
+      end
+
+      it 'routes POST requests' do
+        post '/'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('POST')
+      end
+
+      it 'routes PUT requests' do
+        put '/'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('PUT')
+      end
+
+      it 'routes PATCH requests' do
+        patch '/'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('PATCH')
+      end
+
+      it 'routes all HTTP requests when there is an any handler' do
+        get '/anything'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('GET')
+        delete '/anything'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('DELETE')
+        head '/anything'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to be_empty
+        put '/anything'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('PUT')
+      end
+    end
+
+    context 'an app with helper methods' do
+      let :app do
+        App.new do
+          def top_level_helper
+            'top_level_helper'
+          end
+
+          route 'one' do
+            def first_level_helper
+              'first_level_helper'
+            end
+
+            get do
+              first_level_helper
+            end
+
+            route 'two' do
+              def second_level_helper
+                'second_level_helper'
+              end
+
+              before do |_, response|
+                response.body = 'before:' << [top_level_helper, first_level_helper, second_level_helper].join(',')
+              end
+
+              after do |_, response|
+                response.body += '|after:' << [top_level_helper, first_level_helper, second_level_helper].join(',')
+              end
+
+              get do |_, response|
+                response.body + '|handler:' << [top_level_helper, first_level_helper, second_level_helper].join(',')
+              end
+            end
+          end
+        end
+      end
+
+      it 'can use the helper methods defined on the same route as the handler' do
+        get '/one'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('first_level_helper')
+      end
+
+      it 'can use the helper methods defined on all routes above a handler' do
+        get '/one/two'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to include('handler:top_level_helper,first_level_helper,second_level_helper')
+      end
+
+      it 'can use the helper methods in before blocks' do
+        get '/one/two'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to include('before:top_level_helper,first_level_helper,second_level_helper')
+      end
+
+      it 'can use the helper methods in after blocks' do
+        get '/one/two'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to include('after:top_level_helper,first_level_helper,second_level_helper')
+      end
+    end
+
+    context 'an app that receives configuration when created' do
+      let :app do
+        App.new(this_thing, that_other_thing) do
+          setup do |*args|
+            @args = args
+          end
+
+          get do
+            @args.join(',')
+          end
+
+          route 'one' do
+            setup do |thing1, thing2|
+              @thing1 = thing1
+              @thing2 = thing2
+            end
+
+            get do
+              [*@args, @thing1, @thing2].join(',')
+            end
+          end
+
+          route 'two' do
+            setup do |thing1, thing2|
+              @thing1 = thing1
+              @thing2 = thing2
+            end
+
+            setup do |_, thing_two|
+              @thing_two = thing_two
+            end
+
+            get do
+              [*@args, @thing1, @thing2, @thing_two].join(',')
+            end
+          end
+        end
+      end
+
+      let :this_thing do
+        double(:this_thing, to_s: 'this_thing')
+      end
+
+      let :that_other_thing do
+        double(:that_other_thing, to_s: 'that_other_thing')
+      end
+
+      it 'calls its setup methods with the configuration' do
+        get '/'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('this_thing,that_other_thing')
+      end
+
+      it 'calls the setup methods of all routes' do
+        get '/one'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('this_thing,that_other_thing,this_thing,that_other_thing')
+      end
+
+      it 'calls all setup methods' do
+        get '/two'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('this_thing,that_other_thing,this_thing,that_other_thing,that_other_thing')
+      end
+    end
+
+    context 'an app that uses Rack middleware' do
+      class Reverser
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          response = @app.call(env)
+          body = response[2][0]
+          body && body.reverse!
+          response
+        end
+      end
+
+      class Uppercaser
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          response = @app.call(env)
+          body = response[2][0]
+          body && body.upcase!
+          response
+        end
+      end
+
+      class Mutator
+        def initialize(app, &block)
+          @app = app
+          @block = block
+        end
+
+        def call(env)
+          @app.call(@block.call(env))
+        end
+      end
+
+      let :app do
+        App.new do
+          use Reverser
+
+          get do
+            'lorem ipsum'
+          end
+
+          route 'more' do
+            use Uppercaser
+
+            get do
+              'dolor sit'
+            end
+          end
+
+          route 'hello' do
+            use Rack::Runtime, 'Regal'
+            use Mutator do |env|
+              env['app.greeting'] = 'Bonjour'
+              env
+            end
+
+            get do |request|
+              request.env['app.greeting'] + ', ' + request.parameters['name']
+            end
+          end
+        end
+      end
+
+      it 'calls the middleware when processing the request' do
+        get '/'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('muspi merol')
+      end
+
+      it 'calls the middleware of all routes' do
+        get '/more'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('TIS ROLOD')
+      end
+
+      it 'passes arguments when instantiating the middleware' do
+        get '/hello?name=Eve'
+        expect(last_response.status).to eq(200)
+        expect(last_response.headers).to have_key('X-Runtime-Regal')
+      end
+
+      it 'passes blocks when instantiating the middleware' do
+        get '/hello?name=Eve'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('Bonjour, Eve'.reverse)
+      end
+    end
+
+    context 'an app which needs more control over the response body' do
+      let :app do
+        App.new do
+          route 'no-overwrite' do
+            get do |_, response|
+              response.body = 'foobar'
+              response.finish
+            end
+          end
+
+          route 'raw-body' do
+            get do |_, response|
+              response.raw_body = 'a'..'z'
+            end
+          end
+
+          route 'no-body' do
+            before do |_, response|
+              response.no_body
+            end
+
+            get do
+              'I will not be used'
+            end
+          end
+        end
+      end
+
+      it 'can finish the response so that the result of the handler will not be used as body' do
+        get '/no-overwrite'
+        expect(last_response.body).to eq('foobar')
+      end
+
+      it 'can set the raw body of the response' do
+        get '/raw-body'
+        expect(last_response.body).to eq('abcdefghijklmnopqrstuvwxyz')
+      end
+
+      it 'can disable the response body completely' do
+        get '/no-body'
+        expect(last_response.body).to be_empty
+      end
+    end
+
+    context 'an app that responds with no-body response codes' do
+      let :app do
+        App.new do
+          [111, 204, 205, 304].each do |status|
+            route status.to_s do
+              get do |_, response|
+                response.status = status
+                'this will not be returned'
+              end
+            end
+          end
+        end
+      end
+
+      it 'ignore the response body' do
+        [111, 204, 205, 304].each do |status|
+          get "/#{status}"
+          expect(last_response.status).to eq(status)
+          expect(last_response.body).to be_empty
+        end
+      end
+    end
+
+    context 'an app that raises exceptions' do
+      class SomeNastyError < StandardError; end
+      class AppError < StandardError; end
+      class SpecificError < AppError; end
+
+      let :app do
+        App.new do
+          route 'unhandled' do
+            get do
+              raise 'Bork!'
+            end
+          end
+
+          route 'handled' do
+            rescue_from AppError do |error, request, response|
+              response.body = error.message
+            end
+
+            after do |_, response|
+              response.headers['WasAfterCalled'] = 'yes'
+            end
+
+            get do
+              raise SpecificError, 'Boom!'
+            end
+
+            route 'handled' do
+              get do
+                raise AppError, 'Crash!'
+              end
+            end
+
+            route 'unhandled' do
+              get do
+                raise SomeNastyError
+              end
+            end
+
+            route 'from-before' do
+              before do
+                raise SpecificError, 'Bang!'
+              end
+
+              get do
+              end
+            end
+
+            route 'from-after' do
+              after do
+                raise SpecificError, 'Kazam!'
+              end
+
+              after do |_, response|
+                response.headers['NextAfterWasCalled'] = 'yes'
+              end
+
+              get do
+              end
+            end
+
+            route 'handled-locally' do
+              rescue_from SpecificError do |error, request, response|
+              end
+
+              get do
+                raise SpecificError, 'Bam!'
+              end
+            end
+          end
+        end
+      end
+
+      context 'from handlers' do
+        it 'does not catch them' do
+          expect { get '/unhandled' }.to raise_error('Bork!')
+        end
+
+        it 'delegates them to matching error handlers' do
+          get '/handled'
+          expect(last_response.body).to eq('Boom!')
+        end
+
+        it 'calls after blocks when errors are handled' do
+          get '/handled'
+          expect(last_response.headers['WasAfterCalled']).to eq('yes')
+        end
+
+        it 'lets them bubble all the way up when there are no matching error handlers' do
+          expect { get '/handled/unhandled' }.to raise_error(SomeNastyError)
+        end
+      end
+
+      context 'from before blocks' do
+        it 'delegates them to matching error handlers' do
+          get '/handled/from-before'
+          expect(last_response.body).to eq('Bang!')
+        end
+
+        it 'calls after blocks when errors are handled' do
+          get '/handled/from-before'
+          expect(last_response.headers['WasAfterCalled']).to eq('yes')
+        end
+      end
+
+      context 'from after blocks' do
+        it 'delegates them to matching error handlers' do
+          get '/handled/from-after'
+          expect(last_response.body).to eq('Kazam!')
+        end
+
+        it 'calls the rest of the after blocks when errors are handled' do
+          get '/handled/from-after'
+          expect(last_response.headers['NextAfterWasCalled']).to eq('yes')
+          expect(last_response.headers['WasAfterCalled']).to eq('yes')
+        end
+      end
+    end
+  end
+end