racket-mvc 0.0.3 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0f2546526bd1f65233e173fab47e53cd5ce9f82e
-  data.tar.gz: 0d7c4a9ae89bcddbb196cc44705d72d7c4cad104
+  metadata.gz: c2780584b9d4ab769bd0e1aef25544d15aee4eab
+  data.tar.gz: 391cf9ae48c6ed99634b0d224f3351c0b0b9c1a9
 SHA512:
-  metadata.gz: 23baf9988b840912916097826a3d63c3a238d7655756cf4f3af70d3a3c56f4c4f1b901b48ff65f0ff4627f806c1e5953a4721ff67db7338a5ecf35f8fb239f57
-  data.tar.gz: 0c6f205fef098a042290ff0c8984c6ff944a8de9e615ff7f8e215bdd173aeaf33d9df8c166d28b4017d891a7568c2653668e79160c0f66e82a0be4e0b23c8050
+  metadata.gz: 97cacd90e6986b5a0946cfbcb018c993521696aa54e654dc2d593eaf01129554e446ad9c3e4b4709c1186a7443f8ab24c7d9ef209e8c6f760561132b0131d01f
+  data.tar.gz: dd360e6ff448e1216008453962ccb8b091dee5c0c01804263b4e7495bd48802d39d546978aa64ee40a269fe6da23afa4083245f3c166316ac6a7053c3b1f00e4

data/lib/racket.rb

@@ -30,7 +30,6 @@ require_relative 'racket/router.rb'
 require_relative 'racket/session.rb'
 require_relative 'racket/view_cache.rb'
 require_relative 'racket/utils.rb'
-require_relative 'racket/version.rb'
 
 module Racket
   # Requires a file using the current application directory as a base path.
@@ -46,6 +45,7 @@ module Racket
   #
   # @return [String]
   def version
+    require_relative 'racket/version.rb'
     Version.current
   end
 

data/lib/racket/application.rb

@@ -24,16 +24,76 @@ module Racket
   # Racket main application class.
   class Application
 
-    attr_reader :options, :router
+    @options = nil
 
-    @current = nil
+    # Returns the internal application object. When called for the first time this method will use
+    # Rack::Builder to build
+    #
+    # @return [Rack::Builder]
+    def self.application
+      return @application if @application
+      @options[:middleware].unshift([Rack::ShowExceptions]) if dev_mode?
+      instance = self
+      @application = Rack::Builder.new do
+        instance.options[:middleware].each do |middleware|
+          klass, opts = middleware
+          instance.inform_dev("Loading middleware #{klass} with options #{opts}.")
+          if opts
+            use klass, opts
+          else
+            use klass
+          end
+        end
+        run lambda { |env|
+          static_result = instance.serve_static_file(env)
+          return static_result unless static_result.nil? || static_result.first >= 400
+          instance.router.route(env)
+        }
+      end
+    end
 
     # Called whenever Rack sends a request to the application.
     #
     # @param [Hash] env Rack environment
     # @return [Array] A Rack response array
     def self.call(env)
-      @current.call(env)
+      application.call(env.dup)
+    end
+
+    # Returns a list of default options for Racket::Application.
+    #
+    # @return [Hash]
+    def self.default_options
+      root_dir = Utils.build_path(Dir.pwd)
+      {
+        controller_dir: Utils.build_path(root_dir, 'controllers'),
+        default_action: :index,
+        default_layout: '_default.*',
+        default_view: nil,
+        layout_dir: Utils.build_path(root_dir, 'layouts'),
+        logger: Logger.new($stdout),
+        middleware: [
+          [
+            Rack::Session::Cookie,
+            {
+              key: 'racket.session',
+              old_secret: SecureRandom.hex(16),
+              secret: SecureRandom.hex(16)
+            }
+          ]
+        ],
+        mode: :live,
+        public_dir: Utils.build_path(root_dir, 'public'),
+        root_dir: root_dir,
+        view_dir: Utils.build_path(root_dir, 'views')
+      }
+    end
+
+    # Returns whether the application runs in dev mode.
+    #
+    # @return [true|false]
+    def self.dev_mode?
+      @options[:mode] == :dev
     end
 
     # Returns a route to the specified controller/action/parameter combination.
@@ -43,27 +103,24 @@ module Racket
     # @param [Array] params
     # @return [String]
     def self.get_route(controller, action, params)
-      router.get_route(controller, action, params)
+      @router.get_route(controller, action, params)
     end
 
     # Initializes a new Racket::Application object with default options.
     #
+    # @param [true|false] reboot
     # @return [Class]
-    def self.default
-      fail 'Application has already been initialized!' if @current
-      @current = self.new
-      @current.reload
-      self
+    def self.default(reboot = false)
+      init({}, reboot)
     end
 
-    # Sends a message to the logger, but only if the application is running in dev mode.
+    # Writes a message to the logger if there is one present.
     #
     # @param [String] message
     # @param [Symbol] level
     # @return nil
-    def self.inform_dev(message, level = :info)
-      @current.inform(message, level) if options[:mode] == :dev
-      nil
+    def self.inform(message, level)
+      (@options[:logger].send(level, message) if @options[:logger]) && nil
     end
 
     # Sends a message to the logger.
@@ -72,182 +129,134 @@ module Racket
     # @param [Symbol] level
     # @return nil
     def self.inform_all(message, level = :info)
-      @current.inform(message, level)
+      inform(message, level)
     end
 
-    # Returns options for the currently running Racket::Application.
-    #
-    # @return [Hash]
-    def self.options
-      @current.options
-    end
-
-    # Requires a file using the current application directory as a base path.
+    # Sends a message to the logger, but only if the application is running in dev mode.
     #
-    # @param [Object] args
+    # @param [String] message
+    # @param [Symbol] level
     # @return nil
-    def self.require(*args)
-      @current.require(*args)
-      nil
-    end
-
-    # Returns the router associated with the currenntly running Racket::Application.
-    #
-    # @return [Racket::Router]
-    def self.router
-      @current.router
+    def self.inform_dev(message, level = :debug)
+      (inform(message, level) if dev_mode?) && nil
     end
 
-    private_class_method :router
-
-    # Initializes a new Racket::Application object with options specified by +options+.
+    # Initializes the Racket application.
     #
     # @param [Hash] options
+    # @param [true|false] reboot
     # @return [Class]
-    def self.using(options)
-      fail 'Application has already been initialized!' if @current
-      @current = self.new(options)
-      @current.reload
+    def self.init(options, reboot)
+      instance_variables.each { |ivar| instance_variable_set(ivar, nil) } if reboot
+      fail 'Application has already been initialized!' if @options
+      @options = default_options.merge(options)
+      setup_static_server
+      reload
       self
     end
 
-    # Returns the view cache of the currently running application.
-    #
-    # @return [ViewCache]
-    def self.view_cache
-      @current.view_cache
-    end
-
-    # Internal dispatch handler. Should not be called directly.
+    # Loads controllers and associates each controller with a route.
     #
-    # @param [Hash] env Rack environment
-    # @return [Array] A Rack response array
-    def call(env)
-      app.call(env)
+    # @return [nil]
+    def self.load_controllers
+      inform_dev('Loading controllers.')
+      @options[:last_added_controller] = []
+      @controller = nil
+      Dir.chdir(@options[:controller_dir]) do
+        files = Pathname.glob(File.join('**', '*.rb'))
+        files.map! { |file| file.to_s }
+        # Sort by longest path so that the longer paths gets matched first
+        # HttpRouter claims to be doing this already, but this "hack" is needed in order
+        # for the router to work.
+        files.sort! do |a, b|
+          b.split('/').length <=> a.split('/').length
+        end
+        files.each do |file|
+          ::Kernel.require File.expand_path(file)
+          path = "/#{File.dirname(file)}"
+          path = '' if path == '/.'
+          @router.map(path, @options[:last_added_controller].pop)
+        end
+      end
+      @options.delete(:last_added_controller)
+      inform_dev('Done loading controllers.') && nil
     end
 
-    # Writes a message to the logger if there is one present.
+    # Returns options for the currently running Racket::Application.
     #
-    # @param [String] message
-    # @param [Symbol] level
-    # @return nil
-    def inform(message, level)
-      options[:logger].send(level, message) if options[:logger]
-      nil
+    # @return [Hash]
+    def self.options
+      @options
     end
 
     # Reloads the application, making any changes to the controller configuration visible
     # to the application.
     #
     # @return [nil]
-    def reload
+    def self.reload
       setup_routes
-      # @todo: Clear cached views/layouts
-      nil
+      @view_cache = nil
     end
 
     # Requires a file using the current application directory as a base path.
     #
     # @param [Object] args
-    # @return nil
-    def require(*args)
-      ::Kernel.require Utils.build_path(*args)
-      nil
+    # @return [nil]
+    def self.require(*args)
+      (::Kernel.require Utils.build_path(*args)) && nil
     end
 
-    # Returns the ViewCache object associated with the current application.
+    # Returns the router associated with the currenntly running Racket::Application.
     #
-    # @return [ViewCache]
-    def view_cache
-      @view_cache ||= ViewCache.new(options[:layout_dir], options[:view_dir])
-    end
-
-    private
-
-    def app
-      @app ||= build_app
+    # @return [Racket::Router]
+    def self.router
+      @router
     end
 
-    def build_app
-      instance = self
-      Rack::Builder.new do
-        instance.options[:middleware].each_pair do |klass, opts|
-          Application.inform_dev("Loading middleware #{klass} with options #{opts}.")
-          use klass, opts
-        end
-        run lambda { |env| instance.router.route(env) }
-      end
+    # Serves a static file (if Racket is configured to serve static files).
+    #
+    # @param [Hash] env Rack environment
+    # @return [Array|nil] A Rack response array if Rack::File handled the file, nil otherwise.
+    def self.serve_static_file(env)
+      return nil if @static_server.nil?
+      @static_server.call(env)
     end
 
-    # Creates a new instance of Racket::Application.
+    # Initializes routing.
     #
-    # @param [Hash] options
-    # @return [Racket::Application]
-    def initialize(options = {})
-      @options = default_options.merge(options)
+    # @return [nil]
+    def self.setup_routes
+      @router = Router.new
+      load_controllers
     end
 
-    # Returns a list of default options for Racket::Application.
+    # Initializes static server (if a public dir is specified).
     #
-    # @return [Hash]
-    def default_options
-      root_dir = Utils.build_path(Dir.pwd)
-      {
-        controller_dir: Utils.build_path(root_dir, 'controllers'),
-        default_action: :index,
-        default_layout: '_default.*',
-        default_view: nil,
-        layout_dir: Utils.build_path(root_dir, 'layouts'),
-        logger: Logger.new($stdout),
-        middleware: {
-          Rack::Session::Cookie => {
-            key: 'racket.session',
-            old_secret: SecureRandom.hex(16),
-            secret: SecureRandom.hex(16)
-          }
-        },
-        mode: :live,
-        root_dir: root_dir,
-        view_dir: Utils.build_path(root_dir, 'views')
-      }
+    # @return [nil]
+    def self.setup_static_server
+      @static_server = nil
+      return nil unless (public_dir = @options[:public_dir]) && Utils.dir_readable?(public_dir)
+      inform_dev("Setting up static server to serve files from #{public_dir}.")
+      (@static_server = Rack::File.new(public_dir)) && nil
     end
 
-    # Loads controllers and associates each controller with a route.
+    # Initializes a new Racket::Application object with options specified by +options+.
     #
-    # @return [nil]
-    def load_controllers
-      Application.inform_dev('Loading controllers.')
-      options[:last_added_controller] = []
-      @controller = nil
-      Dir.chdir(@options[:controller_dir]) do
-        files = Pathname.glob(File.join('**', '*.rb'))
-        files.map! { |file| file.to_s }
-        # Sort by longest path so that the longer paths gets matched first
-        # HttpRouter claims to be doing this already, but this "hack" is needed in order
-        # for the router to work.
-        files.sort! do |a, b|
-          b.split('/').length <=> a.split('/').length
-        end
-        files.each do |file|
-          ::Kernel.require File.expand_path(file)
-          path = "/#{File.dirname(file)}"
-          path = '' if path == '/.'
-          @router.map(path, options[:last_added_controller].pop)
-        end
-      end
-      options.delete(:last_added_controller)
-      Application.inform_dev('Done loading controllers.')
-      nil
+    # @param [Hash] options
+    # @param [true|false] reboot
+    # @return [Class]
+    def self.using(options, reboot = false)
+      init(options, reboot)
     end
 
-    # Initializes routing.
+    # Returns the view cache of the currently running application.
     #
-    # @return [nil]
-    def setup_routes
-      @router = Router.new
-      load_controllers
-      nil
+    # @return [ViewCache]
+    def self.view_cache
+      @view_cache ||= ViewCache.new(@options[:layout_dir], @options[:view_dir])
     end
 
+    private_class_method  :application, :default_options, :inform, :init, :load_controllers,
+                          :setup_routes, :setup_static_server
   end
 end

data/lib/racket/controller.rb

@@ -29,7 +29,7 @@ module Racket
     # @param [Array] methods
     # @param [Proc] blk
     # @return [nil]
-    def self.add_hook(type, methods, blk)
+    def self.__register_hook(type, methods, blk)
       key = "#{type}_hooks".to_sym
       meths = public_instance_methods(false)
       meths = meths & methods.map { |method| method.to_sym} unless methods.empty?
@@ -39,7 +39,7 @@ module Racket
       nil
     end
 
-    private_class_method :add_hook
+    private_class_method :__register_hook
 
     # Adds a before hook to one or more actions. Actions should be given as a list of symbols.
     # If no symbols are provided, *all* actions on the controller is affected.
@@ -47,7 +47,7 @@ module Racket
     # @param [Array] methods
     # @return [nil]
     def self.after(*methods, &blk)
-      add_hook(:after, methods, blk) if block_given?
+      __register_hook(:after, methods, blk) if block_given?
     end
 
     # Adds an after hook to one or more actions. Actions should be given as a list of symbols.
@@ -56,7 +56,7 @@ module Racket
     # @param [Array] methods
     # @return [nil]
     def self.before(*methods, &blk)
-      add_hook(:before, methods, blk) if block_given?
+      __register_hook(:before, methods, blk) if block_given?
     end
 
     # :nodoc:
@@ -113,14 +113,28 @@ module Racket
       Application.get_route(controller, action, params)
     end
 
-    # Redirects the client.
+    # Redirects the client. After hooks are
     #
-    # @param [String] target
-    # @param [Fixnum] status
+    # @param [String] target URL to redirect to
+    # @param [Fixnum] status HTTP status to send
+    # @param [true|false] run_after_hook Whether after hook should be run before redirecting
     # @return [Object]
-    def redirect(target, status = 302)
-      racket.redirected = true
+    def redirect(target, status = 302, run_after_hook = true)
       response.redirect(target, status)
+      respond(response.status, response.headers, '', run_after_hook);
+    end
+
+    # Stop processing request and send a custom response. After calling this method, no further
+    # processing of the request is done unless +run_after_hook+ is set to true. If +run_after_hook+
+    # is set to true, any after hook associated with the action (but no other code) will be run.
+    #
+    # @param [Fixnum] status
+    # @param [Hash] headers
+    # @param [String] body
+    # @param [true|false] run_after_hook Whether after hook should be run
+    def respond(status = 200, headers = {}, body = '', run_after_hook = false)
+      __run_hook(:after, racket.action) if run_after_hook
+      throw :response, [status, headers, body]
     end
 
     # Renders an action.
@@ -135,13 +149,16 @@ module Racket
     private
 
     def __execute(action)
-      before_hooks = controller_option(:before_hooks) || {}
-      self.instance_eval &before_hooks[action] if before_hooks.key?(action)
+      __run_hook(:before, action)
       meth = method(action)
       params = racket.params[0...meth.parameters.length]
       racket.action_result = meth.call(*params)
-      after_hooks = controller_option(:after_hooks) || {}
-      self.instance_eval &after_hooks[action] if after_hooks.key?(action)
+      __run_hook(:after, action)
+    end
+
+    def __run_hook(type, action)
+      hooks = controller_option("#{type}_hooks".to_sym) || {}
+      self.instance_eval &hooks[action] if hooks.key?(action)
     end
 
   end

data/lib/racket/current.rb

@@ -25,7 +25,7 @@ module Racket
   class Current
     # Holds Racket internal state, available to the controller instance but mostly used for keeping
     # track of things that don't belong to the actual request.
-    State = Struct.new(:action, :action_result, :params, :redirected)
+    State = Struct.new(:action, :action_result, :params)
 
     # Called whenever a new request needs to be processed.
     #
@@ -34,7 +34,7 @@ module Racket
     # @param [Array] params Parameters sent to the action
     # @return [Module] A module encapsulating all state relating to the current request
     def self.init(env, action, params)
-      racket = State.new(action, nil, params, false)
+      racket = State.new(action, nil, params)
       request = Request.new(env)
       response = Response.new
       session = Session.new(env['rack.session']) if env.key?('rack.session')

data/lib/racket/router.rb

@@ -76,8 +76,14 @@ module Racket
     end
 
     # @todo: Allow the user to set custom handlers for different errors
-    def render_404(message = '404 Not found')
-      [404, { 'Content-Type' => 'text/plain' }, message]
+    def render_error(status, error = nil)
+      # If running in dev mode, let Rack::ShowExceptions handle the error.
+      raise error if error && Application.dev_mode?
+
+      # Not running in dev mode, let us handle the error ourselves.
+      response = Response.new([], status, { 'Content-Type' => 'text/plain' })
+      response.write("#{status} #{Rack::Utils::HTTP_STATUS_CODES[status]}")
+      response.finish
     end
 
     # Routes a request and renders it.
@@ -85,28 +91,34 @@ module Racket
     # @param [Hash] env Rack environment
     # @return [Array] A Rack response triplet
     def route(env)
-      # Find controller in map
-      # If controller exists, call it
-      # Otherwise, send a 404
-      matching_routes = @router.recognize(env)
-      unless matching_routes.first.nil?
-        target_klass = matching_routes.first.first.route.dest
-        params = matching_routes.first.first.param_values.first.reject { |e| e.empty? }
-        action = params.empty? ? target_klass.get_option(:default_action) : params.shift.to_sym
+      begin
+        catch :response do # Catches early exits from Controller.respond.
+          # Find controller in map
+          # If controller exists, call it
+          # Otherwise, send a 404
+          matching_routes = @router.recognize(env)
+          unless matching_routes.first.nil?
+            target_klass = matching_routes.first.first.route.dest
+            params = matching_routes.first.first.param_values.first.reject { |e| e.empty? }
+            action = params.empty? ? target_klass.get_option(:default_action) : params.shift.to_sym
 
-        # Check if action is available on target
-        return render_404 unless @actions_by_controller[target_klass].include?(action)
+            # Check if action is available on target
+            return render_error(404) unless @actions_by_controller[target_klass].include?(action)
 
-        # Initialize target
-        target = target_klass.new
-        # @fixme: File.dirname should not be used on urls!
-        1.upto(params.count) do
-          env['PATH_INFO'] = File.dirname(env['PATH_INFO'])
+            # Initialize target
+            target = target_klass.new
+            # @fixme: File.dirname should not be used on urls!
+            1.upto(params.count) do
+              env['PATH_INFO'] = File.dirname(env['PATH_INFO'])
+            end
+            target.extend(Current.init(env, action, params))
+            target.render(action)
+          else
+            render_error(404)
+          end
         end
-        target.extend(Current.init(env, action, params))
-        target.render(action)
-      else
-        render_404
+      rescue => err
+        render_error(500, err)
       end
     end
 

data/lib/racket/utils.rb

@@ -21,5 +21,10 @@ module Racket
       end
       path.cleanpath.expand_path.to_s
     end
+
+    def self.dir_readable?(path)
+      pathname = Pathname.new(path)
+      pathname.exist? && pathname.directory? && pathname.readable?
+    end
   end
 end

data/lib/racket/version.rb

@@ -19,11 +19,19 @@ along with Racket.  If not, see <http://www.gnu.org/licenses/>.
 =end
 
 module Racket
+  # The only purpose of this module is to keep track of the current Racket version. It is *not*
+  # loaded automatically unless you make an explicit call to Racket.version.
   module Version
+    # Major version
     MAJOR = 0
+    # Minor version
     MINOR = 0
-    TEENY = 3
+    # Teeny version
+    TEENY = 5
 
+    # Returns the current version of Racket as a string.
+    #
+    # @return [String]
     def current
       [MAJOR, MINOR, TEENY].join('.')
     end

data/lib/racket/view_cache.rb

@@ -37,19 +37,17 @@ module Racket
     # @param [Controller] controller
     # @return [Hash]
     def render(controller)
-      unless controller.racket.redirected
-        template =
-          find_template(controller.request.path, controller.controller_option(:default_view))
-        if template
-          output = Tilt.new(template).render(controller)
-          layout =
-            find_layout(controller.request.path, controller.controller_option(:default_layout))
-          output = Tilt.new(layout).render(controller) { output } if layout
-        else
-          output = controller.racket.action_result
-        end
-        controller.response.write(output)
+      template =
+        find_template(controller.request.path, controller.controller_option(:default_view))
+      if template
+        output = Tilt.new(template).render(controller)
+        layout =
+          find_layout(controller.request.path, controller.controller_option(:default_layout))
+        output = Tilt.new(layout).render(controller) { output } if layout
+      else
+        output = controller.racket.action_result
       end
+      controller.response.write(output)
       controller.response.finish
     end
 
@@ -90,7 +88,7 @@ module Racket
       file_path = File.join(base_file_path, url_path)
       action = File.basename(file_path)
       file_path = File.dirname(file_path)
-      return nil unless File.exists?(file_path) && File.directory?(file_path)
+      return nil unless Utils.dir_readable?(file_path)
       Dir.chdir(file_path) do
         files = Pathname.glob("#{action}.*")
         if files.empty?

data/spec/_custom.rb

@@ -1,7 +1,10 @@
-describe 'The custom Racket test Application' do
+describe 'A custom Racket test Application' do
   extend Rack::Test::Methods
   def app
-    @app ||= Racket::Application.using(default_layout: 'zebra.*', view_dir: 'templates')
+    @app ||= Racket::Application.using(
+      { default_layout: 'zebra.*', logger: nil, mode: :dev, view_dir: 'templates' },
+      true
+    )
   end
 
   it 'should set requested options' do
@@ -19,7 +22,7 @@ describe 'The custom Racket test Application' do
   it 'should return a 404 on a nonexisting url' do
     get '/nosuchurl'
     last_response.status.should.equal(404)
-    last_response.body.should.equal('404 Not found')
+    last_response.body.should.equal('404 Not Found')
   end
 
   it 'should be able to render a template and a layout' do
@@ -45,4 +48,11 @@ describe 'The custom Racket test Application' do
     response = JSON.parse(last_response.body)
     response.should.equal(["Data added in before block", "Data added in action"])
   end
+
+  it 'should let Rack::ShowExceptions handle the error' do
+    get '/sub1/epic_fail'
+    last_response.status.should.equal(500)
+    last_response.headers['Content-Type'].should.equal('text/plain')
+    last_response.body.should.match(%r(^RuntimeError: Epic fail!))
+  end
 end

data/spec/_default.rb

@@ -1,4 +1,4 @@
-describe 'The default Racket test Application' do
+describe 'A default Racket test Application' do
   extend Rack::Test::Methods
 
   def app
@@ -28,7 +28,7 @@ describe 'The default Racket test Application' do
     actions_by_controller[DefaultRootController].include?(:index).should.equal(true)
     actions_by_controller[DefaultRootController].include?(:my_first_route).should.equal(true)
     actions_by_controller[DefaultRootController].include?(:my_second_route).should.equal(true)
-    actions_by_controller[DefaultSubController1].length.should.equal(3)
+    actions_by_controller[DefaultSubController1].length.should.equal(4)
     actions_by_controller[DefaultSubController1].include?(:route_to_root).should.equal(true)
     actions_by_controller[DefaultSubController1].include?(:route_to_nonexisting).should.equal(true)
     actions_by_controller[DefaultSubController2].length.should.equal(3)
@@ -79,11 +79,11 @@ describe 'The default Racket test Application' do
   it 'should return 404 on calling nonexisting action' do
     get '/nonono'
     last_response.status.should.equal(404)
-    last_response.body.should.equal('404 Not found')
+    last_response.body.should.equal('404 Not Found')
 
     get '/sub2/nonono'
     last_response.status.should.equal(404)
-    last_response.body.should.equal('404 Not found')
+    last_response.body.should.equal('404 Not Found')
   end
 
   it 'should be able to find routes within the same controller' do
@@ -172,4 +172,18 @@ describe 'The default Racket test Application' do
     )
   end
 
+  it 'should be able to serve static files' do
+    get '/hello.txt'
+    last_response.status.should.equal(200)
+    last_response.headers['Content-Type'].should.equal('text/plain')
+    last_response.body.should.equal("Hello there\n")
+  end
+
+  it 'should handle exceptions correctly' do
+    get '/sub1/epic_fail'
+    last_response.status.should.equal(500)
+    last_response.headers['Content-Type'].should.equal('text/plain')
+    last_response.body.should.equal('500 Internal Server Error')
+  end
+
 end

data/spec/_invalid.rb

@@ -0,0 +1,14 @@
+describe 'An invalid Racket test Application' do
+  extend Rack::Test::Methods
+
+  def app
+    @app ||= Racket::Application.default
+  end
+
+  it 'should never initialize' do
+    lambda { get '/' }
+      .should.raise(RuntimeError)
+      .message.should.equal('Application has already been initialized!')
+  end
+
+end

data/spec/racket.rb

@@ -18,7 +18,6 @@ require 'rack/test'
 require 'bacon'
 
 Dir.chdir(TEST_DEFAULT_APP_DIR) { require_relative '_default.rb' }
-
-Racket::Application.class_eval { @current = nil }
-
 Dir.chdir(TEST_CUSTOM_APP_DIR) { require_relative '_custom.rb' }
+
+require_relative '_invalid.rb'

data/spec/test_custom_app/controllers/sub1/custom_sub_controller_1.rb

@@ -11,5 +11,9 @@ class CustomSubController1 < Racket::Controller
   def route_to_nonexisting
     r(CustomInheritedController, :nonono, :with, :params)
   end
+  
+  def epic_fail
+    fail 'Epic fail!'
+  end
 
 end

data/spec/test_default_app/controllers/sub1/default_sub_controller_1.rb

@@ -12,4 +12,8 @@ class DefaultSubController1 < Racket::Controller
     r(DefaultInheritedController, :nonono, :with, :params)
   end
 
+  def epic_fail
+    fail 'Epic fail!'
+  end
+
 end

data/spec/test_default_app/public/hello.txt

@@ -0,0 +1 @@
+Hello there

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: racket-mvc
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.5
 platform: ruby
 authors:
 - Lars Olsson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-28 00:00:00.000000000 Z
+date: 2015-07-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http_router
@@ -158,6 +158,7 @@ files:
 - lib/racket/view_cache.rb
 - spec/_custom.rb
 - spec/_default.rb
+- spec/_invalid.rb
 - spec/racket.rb
 - spec/test_custom_app/controllers/sub1/custom_sub_controller_1.rb
 - spec/test_custom_app/controllers/sub2/custom_sub_controller_2.rb
@@ -172,6 +173,7 @@ files:
 - spec/test_default_app/controllers/sub2/default_sub_controller_2.rb
 - spec/test_default_app/controllers/sub3/default_sub_controller_3.rb
 - spec/test_default_app/controllers/sub3/inherited/default_inherited_controller.rb
+- spec/test_default_app/public/hello.txt
 homepage: https://github.com/lasso/racket
 licenses:
 - GNU AFFERO GENERAL PUBLIC LICENSE, version 3