deas 0.2.1 → 0.3.0

data/lib/deas.rb

@@ -36,4 +36,12 @@ module Deas
     option :routes_file,  Pathname, :default => ENV['DEAS_ROUTES_FILE']
   end
 
+  class NullLogger
+    require 'logger'
+
+    ::Logger::Severity.constants.each do |name|
+      define_method(name.downcase){|*args| } # no-op
+    end
+  end
+
 end

data/lib/deas/error_handler.rb

@@ -0,0 +1,35 @@
+module Deas
+
+  class ErrorHandler
+
+    def self.run(*args)
+      self.new(*args).run
+    end
+
+    def initialize(exception, sinatra_call, error_procs)
+      @exception    = exception
+      @sinatra_call = sinatra_call
+
+      @error_procs = [*error_procs].compact
+    end
+
+    def run
+      response = nil
+      @error_procs.each do |error_proc|
+        begin
+          result = @sinatra_call.instance_exec(@exception, &error_proc)
+          response = result if result
+        rescue Exception => proc_exception
+          @exception = proc_exception
+          # reset the response if an exception occurs while evaulating the
+          # error procs -- a new exception will now be handled by the
+          # remaining procs
+          response = nil
+        end
+      end
+      response
+    end
+
+  end
+
+end

data/lib/deas/logging.rb

@@ -0,0 +1,126 @@
+require 'benchmark'
+require 'sinatra/base'
+
+module Deas
+
+  module Logging
+    def self.middleware(verbose)
+      verbose ? VerboseLogging : SummaryLogging
+    end
+  end
+
+  class BaseLogging
+
+    def initialize(app)
+      @app    = app
+      @logger = Deas.app.settings.logger
+    end
+
+    # The Rack call interface. The receiver acts as a prototype and runs
+    # each request in a clone object unless the +rack.run_once+ variable is
+    # set in the environment. Ripped from:
+    # http://github.com/rtomayko/rack-cache/blob/master/lib/rack/cache/context.rb
+    def call(env)
+      if env['rack.run_once']
+        call! env
+      else
+        clone.call! env
+      end
+    end
+
+    # The real Rack call interface.
+    # This is the common behavior for both the verbose and summary logging
+    # middlewares. It times the response and returns it as is.
+    def call!(env)
+      status, headers, body = nil, nil, nil
+      benchmark = Benchmark.measure do
+        status, headers, body = @app.call(env)
+      end
+      log_error(env['sinatra.error'])
+      env['deas.time_taken'] = RoundedTime.new(benchmark.real)
+      [ status, headers, body ]
+    end
+
+    def log(message)
+      @logger.info "[Deas] #{message}"
+    end
+
+    def log_error(exception)
+      return if !exception || exception.kind_of?(Sinatra::NotFound)
+      log "#{exception.class}: #{exception.message}\n" \
+          "#{exception.backtrace.join("\n")}"
+    end
+
+  end
+
+  class VerboseLogging < BaseLogging
+
+    RESPONSE_STATUS_NAMES = {
+      200 => 'OK',
+      400 => 'BAD REQUEST' ,
+      401 => 'UNAUTHORIZED',
+      403 => 'FORBIDDEN',
+      404 => 'NOT FOUND',
+      408 => 'TIMEOUT',
+      500 => 'ERROR'
+    }
+
+    # This the real Rack call interface. It adds logging before and after
+    # super-ing to the common logging behavior.
+    def call!(env)
+      log "===== Received request ====="
+      Rack::Request.new(env).tap do |request|
+        log "  Method:  #{request.request_method.inspect}"
+        log "  Path:    #{request.path.inspect}"
+      end
+      env['deas.logging'] = Proc.new{ |msg| log(msg) }
+      status, headers, body = super(env)
+      log "===== Completed in #{env['deas.time_taken']}ms (#{response_display(status)}) ====="
+      [ status, headers, body ]
+    end
+
+    def response_display(status)
+      [ status, RESPONSE_STATUS_NAMES[status.to_i] ].compact.join(', ')
+    end
+
+  end
+
+  class SummaryLogging < BaseLogging
+
+    # This the real Rack call interface. It adds logging after super-ing to the
+    # common logging behavior.
+    def call!(env)
+      env['deas.logging'] = Proc.new{ |msg| } # no-op
+      status, headers, body = super(env)
+      request = Rack::Request.new(env)
+      log SummaryLine.new({
+        'method'  => request.request_method,
+        'path'    => request.path,
+        'handler' => env['deas.handler_class'],
+        'params'  => env['sinatra.params'],
+        'time'    => env['deas.time_taken'],
+        'status'  => status
+      })
+      [ status, headers, body ]
+    end
+
+  end
+
+  module SummaryLine
+    def self.keys
+      %w{time status method path handler params}
+    end
+    def self.new(line_attrs)
+      self.keys.map{ |k| "#{k}=#{line_attrs[k].inspect}" }.join(' ')
+    end
+  end
+
+  module RoundedTime
+    ROUND_PRECISION = 2
+    ROUND_MODIFIER = 10 ** ROUND_PRECISION
+    def self.new(time_in_seconds)
+      (time_in_seconds * 1000 * ROUND_MODIFIER).to_i / ROUND_MODIFIER.to_f
+    end
+  end
+
+end

data/lib/deas/route.rb

@@ -17,8 +17,14 @@ module Deas
       raise(NoHandlerClassError.new(handler_class_name)) if !@handler_class
     end
 
-    def runner(sinatra_call)
-      Deas::SinatraRunner.new(@handler_class, sinatra_call)
+    def run(sinatra_call)
+      sinatra_call.request.env.tap do |env|
+        env['sinatra.params']     = sinatra_call.params
+        env['deas.handler_class'] = @handler_class
+        env['deas.logging'].call "  Handler: #{env['deas.handler_class']}"
+        env['deas.logging'].call "  Params:  #{env['sinatra.params'].inspect}"
+      end
+      Deas::SinatraRunner.run(@handler_class, sinatra_call)
     end
 
     private

data/lib/deas/server.rb

@@ -2,8 +2,6 @@ require 'ns-options'
 require 'ns-options/boolean'
 require 'pathname'
 require 'singleton'
-
-require 'deas/logger'
 require 'deas/route'
 
 module Deas
@@ -22,13 +20,15 @@ module Deas
       option :public_folder, Pathname
       option :views_folder,  Pathname
 
-      option :dump_errors,     NsOptions::Boolean, :default => false
-      option :method_override, NsOptions::Boolean, :default => true
-      option :sessions,        NsOptions::Boolean, :default => true
-      option :show_exceptions, NsOptions::Boolean, :default => false
-      option :static_files,    NsOptions::Boolean, :default => true
+      option :dump_errors,      NsOptions::Boolean, :default => false
+      option :method_override,  NsOptions::Boolean, :default => true
+      option :sessions,         NsOptions::Boolean, :default => false
+      option :show_exceptions,  NsOptions::Boolean, :default => false
+      option :static_files,     NsOptions::Boolean, :default => true
+      option :reload_templates, NsOptions::Boolean, :default => false
 
-      # Deas specific options
+      # server handling options
+      option :error_procs,     Array, :default => []
       option :init_proc,       Proc,  :default => proc{ }
       option :logger,                 :default => proc{ Deas::NullLogger.new }
       option :middlewares,     Array, :default => []
@@ -48,9 +48,6 @@ module Deas
         })
       end
 
-      def runner_logger
-        Deas::RunnerLogger.new(self.logger, self.verbose_logging)
-      end
     end
 
     attr_reader :configuration
@@ -59,6 +56,8 @@ module Deas
       @configuration = Configuration.new
     end
 
+    # sinatra settings DSL
+
     def env(*args)
       self.configuration.env *args
     end
@@ -95,6 +94,16 @@ module Deas
       self.configuration.static_files *args
     end
 
+    def reload_templates(*args)
+      self.configuration.reload_templates *args
+    end
+
+    # Server handling DSL
+
+    def error(&block)
+      self.configuration.error_procs << block
+    end
+
     def init(&block)
       self.configuration.init_proc = block
     end
@@ -103,10 +112,6 @@ module Deas
       self.configuration.logger *args
     end
 
-    def use(*args)
-      self.configuration.middlewares << args
-    end
-
     def verbose_logging(*args)
       self.configuration.verbose_logging *args
     end
@@ -115,6 +120,10 @@ module Deas
       self.configuration.view_handler_ns *args
     end
 
+    def use(*args)
+      self.configuration.middlewares << args
+    end
+
     def get(path, handler_class_name)
       self.route(:get, path, handler_class_name)
     end

data/lib/deas/sinatra_app.rb

@@ -1,4 +1,6 @@
 require 'sinatra/base'
+require 'deas/error_handler'
+require 'deas/logging'
 
 module Deas
 
@@ -18,36 +20,37 @@ module Deas
         set :public_folder, server_config.public_folder
         set :views,         server_config.views_folder
 
-        set :dump_errors,     server_config.dump_errors
+        set :dump_errors,      server_config.dump_errors
+        set :method_override,  server_config.method_override
+        set :sessions,         server_config.sessions
+        set :show_exceptions,  server_config.show_exceptions
+        set :static,           server_config.static_files
+        set :reload_templates, server_config.reload_templates
         set :logging,         false
-        set :method_override, server_config.method_override
-        set :sessions,        server_config.sessions
-        set :show_exceptions, server_config.show_exceptions
-        set :static,          server_config.static_files
 
         # custom settings
-        set :logger,        server_config.logger
-        set :runner_logger, server_config.runner_logger
+        set :deas_error_procs, server_config.error_procs
+        set :logger,           server_config.logger
 
         server_config.middlewares.each do |middleware_args|
           use *middleware_args
         end
+        use Deas::Logging.middleware(server_config.verbose_logging)
 
         # routes
         server_config.routes.each do |route|
           # defines Sinatra routes like:
-          #   before('/'){ ... }
           #   get('/'){ ... }
-          #   after('/'){ ... }
-          before(route.path) do
-            @runner = route.runner(self).setup
-          end
-          send(route.method, route.path) do
-            @runner.run
-          end
-          after(route.path) do
-            @runner.teardown
-          end
+          send(route.method, route.path){ route.run(self) }
+        end
+
+        # error handling
+        not_found do
+          env['sinatra.error'] ||= Sinatra::NotFound.new
+          ErrorHandler.run(env['sinatra.error'], self, settings.deas_error_procs)
+        end
+        error do
+          ErrorHandler.run(env['sinatra.error'], self, settings.deas_error_procs)
         end
 
       end

data/lib/deas/sinatra_runner.rb

@@ -5,30 +5,21 @@ module Deas
 
   class SinatraRunner < Runner
 
+    def self.run(*args)
+      self.new(*args).run
+    end
+
     def initialize(handler_class, sinatra_call)
       @sinatra_call  = sinatra_call
       @handler_class = handler_class
       @logger        = @sinatra_call.settings.logger
-      @runner_logger = @sinatra_call.settings.runner_logger
       @params        = @sinatra_call.params
       @request       = @sinatra_call.request
       @response      = @sinatra_call.response
       @session       = @sinatra_call.session
-      @time_taken    = nil
-      @started_at    = nil
       super(handler_class)
     end
 
-    def setup
-      @started_at = Time.now
-      log_verbose "===== Received request ====="
-      log_verbose "  Method:  #{@request.request_method.inspect}"
-      log_verbose "  Path:    #{@request.path.inspect}"
-      log_verbose "  Params:  #{@sinatra_call.params.inspect}"
-      log_verbose "  Handler: #{@handler_class}"
-      self
-    end
-
     def run
       run_callbacks @handler_class.before_callbacks
       @handler.init
@@ -37,42 +28,6 @@ module Deas
       response_data
     end
 
-    # expects that `setup` has been run; this method is dependent on it
-    CODE_NAMES = {
-      200 => 'OK',
-      400 => 'BAD REQUEST' ,
-      401 => 'UNAUTHORIZED',
-      403 => 'FORBIDDEN',
-      404 => 'NOT FOUND',
-      408 => 'TIMEOUT',
-      500 => 'ERROR'
-    }
-    def teardown
-      @time_taken = RoundedTime.new(Time.now - @started_at)
-      @response.status.tap do |code|
-        response_display = [ code, CODE_NAMES[code.to_i] ].compact.join(', ')
-        log_verbose "===== Completed in #{@time_taken}ms " \
-                    "#{response_display} ====="
-      end
-      log_summary SummaryLine.new({
-        'status'  => @response.status,
-        'method'  => @request.request_method,
-        'path'    => @request.path,
-        'params'  => @params,
-        'time'    => @time_taken,
-        'handler' => @handler_class
-      })
-      self
-    end
-
-    def log_verbose(message, level = :info)
-      @runner_logger.verbose.send(level, "[Deas] #{message}")
-    end
-
-    def log_summary(message, level = :info)
-      @runner_logger.summary.send(level, "[Deas] #{message}")
-    end
-
     # Helpers
 
     def halt(*args)
@@ -100,20 +55,5 @@ module Deas
       callbacks.each{|proc| @handler.instance_eval(&proc) }
     end
 
-    module RoundedTime
-      ROUND_PRECISION = 2
-      ROUND_MODIFIER = 10 ** ROUND_PRECISION
-      def self.new(time_in_seconds)
-        (time_in_seconds * 1000 * ROUND_MODIFIER).to_i / ROUND_MODIFIER.to_f
-      end
-    end
-
-    module SummaryLine
-      def self.new(line_attrs)
-        attr_keys = %w{time status handler method path params}
-        attr_keys.map{ |k| "#{k}=#{line_attrs[k].inspect}" }.join(' ')
-      end
-    end
-
   end
 end

data/lib/deas/test_runner.rb

@@ -1,4 +1,3 @@
-require 'deas/logger'
 require 'deas/runner'
 
 module Deas

data/lib/deas/version.rb

@@ -1,3 +1,3 @@
 module Deas
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

data/lib/deas/view_handler.rb

@@ -41,11 +41,6 @@ module Deas
 
     protected
 
-    def before_init; end
-    def after_init;  end
-    def before_run;  end
-    def after_run;   end
-
     # Helpers
 
     def halt(*args);        @deas_runner.halt(*args);        end
@@ -63,7 +58,9 @@ module Deas
     def session;  @deas_runner.session;  end
 
     def run_callback(callback)
-      self.send(callback.to_s)
+      (self.class.send("#{callback}_callbacks") || []).each do |callback|
+        self.instance_eval(&callback)
+      end
     end
 
     module ClassMethods
@@ -84,6 +81,38 @@ module Deas
         @after_callbacks ||= []
       end
 
+      def before_init(&block)
+        self.before_init_callbacks << block
+      end
+
+      def before_init_callbacks
+        @before_init_callbacks ||= []
+      end
+
+      def after_init(&block)
+        self.after_init_callbacks << block
+      end
+
+      def after_init_callbacks
+        @after_init_callbacks ||= []
+      end
+
+      def before_run(&block)
+        self.before_run_callbacks << block
+      end
+
+      def before_run_callbacks
+        @before_run_callbacks ||= []
+      end
+
+      def after_run(&block)
+        self.after_run_callbacks << block
+      end
+
+      def after_run_callbacks
+        @after_run_callbacks ||= []
+      end
+
       def layout(*args)
         @layouts = args unless args.empty?
         @layouts

data/test/support/fake_app.rb

@@ -1,4 +1,4 @@
-require 'deas/logger'
+require 'deas'
 require 'ostruct'
 
 class FakeApp
@@ -13,9 +13,7 @@ class FakeApp
     @params   = @request.params
     @session  = @request.session
     @response = FakeResponse.new
-    @settings = OpenStruct.new({
-      :runner_logger => Deas::RunnerLogger.new(Deas::NullLogger.new, false)
-    })
+    @settings = OpenStruct.new({ })
   end
 
   def halt(*args)

data/test/support/routes.rb

@@ -9,15 +9,24 @@ class Deas::Server
   logger Logger.new(File.open(log_file_path, 'w'))
   verbose_logging true
 
-  get '/show',            'ShowHandler'
-  get '/halt',            'HaltHandler'
-  get '/error',           'ErrorHandler'
-  get '/with_layout',     'WithLayoutHandler'
-  get '/alt_with_layout', 'AlternateWithLayoutHandler'
-  get '/redirect',        'RedirectHandler'
-  get '/redirect_to',     'RedirectToHandler'
-  get '/set_session',     'SetSessionHandler'
-  get '/use_session',     'UseSessionHandler'
+  error do |exception|
+    case exception
+    when Sinatra::NotFound
+      halt 404, "Couldn't be found"
+    when Exception
+      halt 500, "Oops, something went wrong"
+    end
+  end
+
+  get  '/show',            'ShowHandler'
+  get  '/halt',            'HaltHandler'
+  get  '/error',           'ErrorHandler'
+  get  '/with_layout',     'WithLayoutHandler'
+  get  '/alt_with_layout', 'AlternateWithLayoutHandler'
+  get  '/redirect',        'RedirectHandler'
+  get  '/redirect_to',     'RedirectToHandler'
+  post '/session',         'SetSessionHandler'
+  get  '/session',         'UseSessionHandler'
 
 end
 
@@ -102,7 +111,7 @@ class SetSessionHandler
 
   def run!
     session[:secret] = 'session_secret'
-    redirect_to '/use_session'
+    redirect_to '/session'
   end
 
 end

data/test/support/view_handlers.rb

@@ -13,21 +13,24 @@ class FlagViewHandler
 
   attr_reader :before_init_called, :init_bang_called, :after_init_called,
     :before_run_called, :run_bang_called, :after_run_called,
-    :before_hook_called, :after_hook_called
+    :before_hook_called, :after_hook_called, :second_before_init_called
 
-  def before_init
+  before_init do
     @before_init_called = true
   end
+  before_init do
+    @second_before_init_called = true
+  end
 
   def init!
     @init_bang_called = true
   end
 
-  def after_init
+  after_init do
     @after_init_called = true
   end
 
-  def before_run
+  before_run do
     @before_run_called = true
   end
 
@@ -35,7 +38,7 @@ class FlagViewHandler
     @run_bang_called = true
   end
 
-  def after_run
+  after_run do
     @after_run_called = true
   end
 

data/test/system/making_requests_tests.rb

@@ -1,78 +1,95 @@
 require 'assert'
 require 'rack/test'
 
-class MakingRequestsTests < Assert::Context
-  include Rack::Test::Methods
+module Deas
 
-  desc "Making requests using rack test"
-  setup do
-    @app = Deas.app.new
-  end
+  class RackTests < Assert::Context
+    include Rack::Test::Methods
 
-  should "return a 200 response with a GET to '/show'" do
-    get '/show', 'message' => 'this is a test'
+    desc "Deas' the rack app"
+    setup do
+      @app = Deas.app.new
+    end
 
-    expected_body = "show page: this is a test\n" \
-                    "Stuff: Show Info\n"
-    assert_equal 200,           last_response.status
-    assert_equal expected_body, last_response.body
-  end
+    def app; @app; end
 
-  should "allow halting with a custom response" do
-    get '/halt', 'with' => 234
+    should "return a 200 response with a GET to '/show'" do
+      get '/show', 'message' => 'this is a test'
 
-    assert_equal 234, last_response.status
-  end
+      expected_body = "show page: this is a test\n" \
+                      "Stuff: Show Info\n"
+      assert_equal 200,           last_response.status
+      assert_equal expected_body, last_response.body
+    end
 
-  should "return a 404 response with an undefined route" do
-    get '/not_defined'
+    should "allow halting with a custom response" do
+      get '/halt', 'with' => 234
 
-    assert_equal 404, last_response.status
-  end
+      assert_equal 234, last_response.status
+    end
 
-  should "return a 500 response with an error route" do
-    get '/error'
+    should "return a 404 response with an undefined route and " \
+           "run the defined error procs" do
+      get '/not_defined'
 
-    assert_equal 500, last_response.status
-  end
+      assert_equal 404, last_response.status
+      assert_equal "Couldn't be found", last_response.body
+    end
 
-  should "return a 200 response and use all the layouts" do
-    get '/with_layout'
+    should "return a 500 response with an error route and " \
+           "run the defined error procs" do
+      get '/error'
 
-    expected_body = "Layout 1\nLayout 2\nLayout 3\nWith Layout\n"
-    assert_equal 200,           last_response.status
-    assert_equal expected_body, last_response.body
+      assert_equal 500, last_response.status
+      assert_equal "Oops, something went wrong", last_response.body
+    end
 
-    get '/alt_with_layout'
+    should "return a 200 response and use all the layouts" do
+      get '/with_layout'
 
-    assert_equal 200,           last_response.status
-    assert_equal expected_body, last_response.body
-  end
+      expected_body = "Layout 1\nLayout 2\nLayout 3\nWith Layout\n"
+      assert_equal 200,           last_response.status
+      assert_equal expected_body, last_response.body
 
-  should "return a 302 redirecting to the expected locations" do
-    get '/redirect'
-    expected_location = 'http://google.com'
+      get '/alt_with_layout'
 
-    assert_equal 302,               last_response.status
-    assert_equal expected_location, last_response.headers['Location']
+      assert_equal 200,           last_response.status
+      assert_equal expected_body, last_response.body
+    end
 
-    get '/redirect_to'
-    expected_location = 'http://example.org/somewhere'
+    should "return a 302 redirecting to the expected locations" do
+      get '/redirect'
+      expected_location = 'http://google.com'
 
-    assert_equal 302,               last_response.status
-    assert_equal expected_location, last_response.headers['Location']
-  end
+      assert_equal 302,               last_response.status
+      assert_equal expected_location, last_response.headers['Location']
+
+      get '/redirect_to'
+      expected_location = 'http://example.org/somewhere'
 
-  should "return a 200 response and the session value" do
-    get '/set_session'
-    follow_redirect!
+      assert_equal 302,               last_response.status
+      assert_equal expected_location, last_response.headers['Location']
+    end
 
-    assert_equal 200,              last_response.status
-    assert_equal 'session_secret', last_response.body
   end
 
-  def app
-    @app
+  class SessionTests < RackTests
+    desc "with sessions enabled"
+    setup do
+      orig_sessions = Deas.app.settings.sessions
+      Deas.app.set :sessions, true
+      @app = Deas.app.new
+      Deas.app.set :sessions, orig_sessions
+    end
+
+    should "return a 200 response and the session value" do
+      post '/session'
+      follow_redirect!
+
+      assert_equal 200,              last_response.status
+      assert_equal 'session_secret', last_response.body
+    end
+
   end
 
 end

data/test/unit/error_handler_tests.rb

@@ -0,0 +1,104 @@
+require 'assert'
+require 'deas/error_handler'
+
+class Deas::ErrorHandler
+
+  class BaseTests < Assert::Context
+    desc "Deas::ErrorHandler"
+    setup do
+      @exception = RuntimeError.new
+      @fake_app  = FakeApp.new
+      @error_handler = Deas::ErrorHandler.new(@exception, @fake_app, [])
+    end
+    subject{ @error_handler }
+
+    should have_instance_methods :run
+    should have_class_methods :run
+
+  end
+
+  class RunTests < BaseTests
+    desc "run"
+    setup do
+      @error_procs = [ proc do |exception|
+        settings.exception_that_occurred = exception
+        "my return value"
+      end ]
+
+      @error_handler = Deas::ErrorHandler.new(@exception, @fake_app, @error_procs)
+      @response = @error_handler.run
+    end
+
+    should "run the proc in the context of the app" do
+      assert_equal @exception, @fake_app.settings.exception_that_occurred
+    end
+
+    should "return whatever the proc returns" do
+      assert_equal "my return value", @response
+    end
+
+  end
+
+  class RunWithMultipleProcsTests < BaseTests
+    desc "run with multiple procs"
+    setup do
+      @error_procs = [
+        proc do |exception|
+          settings.first_proc_run = true
+          'first'
+        end,
+        proc do |exception|
+          settings.second_proc_run = true
+          'second'
+        end,
+        proc do |exception|
+          settings.third_proc_run = true
+          nil
+        end
+      ]
+
+      @error_handler = Deas::ErrorHandler.new(@exception, @fake_app, @error_procs)
+      @response = @error_handler.run
+    end
+
+    should "run all the error procs" do
+      assert_equal true, @fake_app.settings.first_proc_run
+      assert_equal true, @fake_app.settings.second_proc_run
+      assert_equal true, @fake_app.settings.third_proc_run
+    end
+
+    should "return the last non-nil response" do
+      assert_equal 'second', @response
+    end
+
+  end
+
+  class RunWithProcsThatHaltTests < BaseTests
+    desc "run with a proc that halts"
+    setup do
+      @error_procs = [
+        proc do |exception|
+          settings.first_proc_run = true
+          halt 401
+        end,
+        proc do |exception|
+          settings.second_proc_run = true
+        end
+      ]
+
+      @error_handler = Deas::ErrorHandler.new(@exception, @fake_app, @error_procs)
+      @response = catch(:halt){ @error_handler.run }
+    end
+
+    should "run error procs until one halts" do
+      assert_equal true, @fake_app.settings.first_proc_run
+      assert_nil @fake_app.settings.second_proc_run
+    end
+
+    should "return whatever was halted" do
+      assert_equal [ 401 ], @response
+    end
+
+  end
+
+end

data/test/unit/logging_tests.rb

@@ -0,0 +1,72 @@
+require 'assert'
+require 'deas/logging'
+
+module Deas::Logging
+
+  class BaseTests < Assert::Context
+    desc "Deas::Logging"
+    subject{ Deas::Logging }
+
+    should have_imeths :middleware
+
+  end
+
+  class VerboseLoggingTests < Assert::Context
+    desc "Deas::VerboseLogging"
+    setup do
+      @middleware = Deas::VerboseLogging.new('a rack app goes here')
+    end
+    subject{ @middleware }
+
+    should have_imeths :call, :call!
+
+    should "be a kind of Deas::BaseLogging middleware" do
+      assert_kind_of Deas::BaseLogging, subject
+    end
+
+  end
+
+  class SummaryLoggingTests < Assert::Context
+    desc "Deas::SummaryLogging"
+    setup do
+      @middleware = Deas::SummaryLogging.new('a rack app goes here')
+    end
+    subject{ @middleware }
+
+    should have_imeths :call, :call!
+
+    should "be a kind of Deas::BaseLogging middleware" do
+      assert_kind_of Deas::BaseLogging, subject
+    end
+
+  end
+
+  class SummaryLineTests < Assert::Context
+    desc "Deas::SummaryLine"
+    subject{ Deas::SummaryLine }
+
+    should "output its attributes in a specific order" do
+      assert_equal %w{time status method path handler params}, subject.keys
+    end
+
+    should "output its attributes in a single line" do
+      line_attrs = {
+        'time' => 't',
+        'status' => 's',
+        'method' => 'm',
+        'path' => 'pth',
+        'handler' => 'h',
+        'params' => 'p',
+      }
+      exp_line = "time=\"t\" "\
+                 "status=\"s\" "\
+                 "method=\"m\" "\
+                 "path=\"pth\" "\
+                 "handler=\"h\" "\
+                 "params=\"p\""
+      assert_equal exp_line, subject.new(line_attrs)
+    end
+
+  end
+
+end

data/test/unit/route_tests.rb

@@ -14,7 +14,7 @@ class Deas::Route
     subject{ @route }
 
     should have_instance_methods :method, :path, :handler_class_name,
-      :handler_class, :runner
+      :handler_class, :run
 
     should "constantize the handler class with #constantize!" do
       assert_nil subject.handler_class
@@ -33,11 +33,6 @@ class Deas::Route
       end
     end
 
-    should "return an instance of the Runner class with supplied variables" do
-      subject.constantize!
-      returned = subject.runner(FakeApp.new)
-      assert_instance_of Deas::SinatraRunner, returned
-    end
   end
 
 end

data/test/unit/server_tests.rb

@@ -1,5 +1,4 @@
 require 'assert'
-require 'deas/logger'
 require 'deas/route'
 require 'deas/server'
 require 'logger'
@@ -22,8 +21,16 @@ class Deas::Server
     end
     subject{ Deas::Server }
 
-    should have_instance_methods :configuration, :init, :view_handler_ns,
-      :get, :post, :put, :patch, :delete, :route, :use
+    should have_reader :configuration
+
+    # DSL for sinatra settings
+    should have_imeths :env, :root, :public_folder, :views_folder
+    should have_imeths :dump_errors, :method_override, :sessions, :show_exceptions
+    should have_imeths :static_files, :reload_templates
+
+    # DSL for server handling
+    should have_imeths :init, :logger, :use, :view_handler_ns, :use
+    should have_imeths :get, :post, :put, :patch, :delete, :route
 
     should "be a singleton" do
       assert_includes Singleton, subject.included_modules
@@ -59,6 +66,9 @@ class Deas::Server
       subject.static_files false
       assert_equal false, config.static_files
 
+      subject.reload_templates true
+      assert_equal true, config.reload_templates
+
       subject.use 'MyMiddleware'
       assert_equal [ ['MyMiddleware'] ], config.middlewares
 
@@ -156,10 +166,14 @@ class Deas::Server
     end
     subject{ @configuration }
 
-    should have_instance_methods :env, :root, :app_file, :public_folder,
-      :views_folder, :dump_errors, :method_override, :sessions, :static_files,
-      :init_proc, :logger, :routes, :view_handler_ns, :show_exceptions,
-      :middlewares
+    # sinatra related options
+    should have_imeths :env, :root, :app_file, :public_folder, :views_folder
+    should have_imeths :dump_errors, :method_override, :sessions, :show_exceptions
+    should have_imeths :static_files, :reload_templates
+
+    # server handling options
+    should have_imeths :init_proc, :logger, :verbose_logging, :middlewares
+    should have_imeths :routes, :view_handler_ns
 
     should "default the env to 'development'" do
       assert_equal 'development', subject.env
@@ -189,9 +203,10 @@ class Deas::Server
     should "default the Sinatra flags" do
       assert_equal false, subject.dump_errors
       assert_equal true,  subject.method_override
+      assert_equal false, subject.sessions
       assert_equal false, subject.show_exceptions
-      assert_equal true,  subject.sessions
       assert_equal true,  subject.static_files
+      assert_equal false, subject.reload_templates
     end
 
     should "default the logger to a NullLogger" do

data/test/unit/sinatra_app_tests.rb

@@ -12,14 +12,15 @@ module Deas::SinatraApp
     setup do
       @route = Deas::Route.new(:get, '/something', 'TestViewHandler')
       @configuration = Deas::Server::Configuration.new.tap do |c|
-        c.env             = 'staging'
-        c.root            = 'path/to/somewhere'
-        c.dump_errors     = true
-        c.method_override = false
-        c.sessions        = false
-        c.show_exceptions = true
-        c.static          = true
-        c.routes          = [ @route ]
+        c.env              = 'staging'
+        c.root             = 'path/to/somewhere'
+        c.dump_errors      = true
+        c.method_override  = false
+        c.sessions         = false
+        c.show_exceptions  = true
+        c.static           = true
+        c.reload_templates = true
+        c.routes           = [ @route ]
       end
       @sinatra_app = Deas::SinatraApp.new(@configuration)
     end
@@ -54,7 +55,7 @@ module Deas::SinatraApp
         assert_equal false,                      settings.sessions
         assert_equal true,                       settings.show_exceptions
         assert_equal true,                       settings.static
-        assert_instance_of Deas::RunnerLogger,   settings.runner_logger
+        assert_equal true,                       settings.reload_templates
         assert_instance_of Deas::NullLogger,     settings.logger
       end
     end

data/test/unit/sinatra_runner_tests.rb

@@ -69,11 +69,6 @@ class Deas::SinatraRunner
       assert_equal expected, return_value
     end
 
-    should "not throw an exception with the setup or teardown methods" do
-      assert_nothing_raised{ subject.setup }
-      assert_nothing_raised{ subject.teardown }
-    end
-
   end
 
   class RunTests < BaseTests

data/test/unit/view_handler_tests.rb

@@ -15,8 +15,13 @@ module Deas::ViewHandler
     subject{ @handler }
 
     should have_instance_methods :init, :init!, :run, :run!
-    should have_class_methods :before, :before_callbacks, :after,
-      :after_callbacks, :layout, :layouts
+    should have_class_methods :before,      :before_callbacks
+    should have_class_methods :after,       :after_callbacks
+    should have_class_methods :before_init, :before_init_callbacks
+    should have_class_methods :after_init,  :after_init_callbacks
+    should have_class_methods :before_run,  :before_run_callbacks
+    should have_class_methods :after_run,   :after_run_callbacks
+    should have_class_methods :layout, :layouts
 
     should "raise a NotImplementedError if run! is not overwritten" do
       assert_raises(NotImplementedError){ subject.run! }
@@ -36,6 +41,34 @@ module Deas::ViewHandler
       assert_includes after_proc, TestViewHandler.after_callbacks
     end
 
+    should "store procs in #before_init_callbacks with #before_init" do
+      before_init_proc = proc{ }
+      TestViewHandler.before_init(&before_init_proc)
+
+      assert_includes before_init_proc, TestViewHandler.before_init_callbacks
+    end
+
+    should "store procs in #after_init_callbacks with #after_init" do
+      after_init_proc = proc{ }
+      TestViewHandler.after_init(&after_init_proc)
+
+      assert_includes after_init_proc, TestViewHandler.after_init_callbacks
+    end
+
+    should "store procs in #before_run_callbacks with #before_run" do
+      before_run_proc = proc{ }
+      TestViewHandler.before_run(&before_run_proc)
+
+      assert_includes before_run_proc, TestViewHandler.before_run_callbacks
+    end
+
+    should "store procs in #after_run_callbacks with #after_run" do
+      after_run_proc = proc{ }
+      TestViewHandler.after_run(&after_run_proc)
+
+      assert_includes after_run_proc, TestViewHandler.after_run_callbacks
+    end
+
     should "allow specifying the layouts using #layout or #layouts" do
       handler_class = Class.new{ include Deas::ViewHandler }
 
@@ -55,6 +88,7 @@ module Deas::ViewHandler
 
     should "have called `init!` and it's callbacks" do
       assert_equal true, subject.before_init_called
+      assert_equal true, subject.second_before_init_called
       assert_equal true, subject.init_bang_called
       assert_equal true, subject.after_init_called
     end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: deas
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 19
   prerelease: 
   segments: 
   - 0
-  - 2
-  - 1
-  version: 0.2.1
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Kelly Redding
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-05-02 00:00:00 Z
+date: 2013-05-07 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   prerelease: false
@@ -134,7 +134,8 @@ files:
 - Rakefile
 - deas.gemspec
 - lib/deas.rb
-- lib/deas/logger.rb
+- lib/deas/error_handler.rb
+- lib/deas/logging.rb
 - lib/deas/rack_request_fix.rb
 - lib/deas/route.rb
 - lib/deas/runner.rb
@@ -159,7 +160,8 @@ files:
 - test/support/views/with_layout.erb
 - test/system/making_requests_tests.rb
 - test/unit/deas_tests.rb
-- test/unit/logger_tests.rb
+- test/unit/error_handler_tests.rb
+- test/unit/logging_tests.rb
 - test/unit/route_tests.rb
 - test/unit/runner_tests.rb
 - test/unit/server_tests.rb
@@ -214,7 +216,8 @@ test_files:
 - test/support/views/with_layout.erb
 - test/system/making_requests_tests.rb
 - test/unit/deas_tests.rb
-- test/unit/logger_tests.rb
+- test/unit/error_handler_tests.rb
+- test/unit/logging_tests.rb
 - test/unit/route_tests.rb
 - test/unit/runner_tests.rb
 - test/unit/server_tests.rb

data/lib/deas/logger.rb

@@ -1,23 +0,0 @@
-module Deas
-
-  class RunnerLogger
-    attr_reader :summary, :verbose
-
-    def initialize(logger, verbose = true)
-      loggers = [ logger, Deas::NullLogger.new ]
-      loggers.reverse! if !verbose
-      @verbose, @summary = loggers
-    end
-
-  end
-
-  class NullLogger
-    require 'logger'
-
-    ::Logger::Severity.constants.each do |name|
-      define_method(name.downcase){|*args| } # no-op
-    end
-
-  end
-
-end

data/test/unit/logger_tests.rb

@@ -1,33 +0,0 @@
-require 'assert'
-
-class Deas::RunnerLogger
-
-  class BaseTests < Assert::Context
-    desc "Deas::RunnerLogger"
-    setup do
-      @logger = Logger.new(File.open("/dev/null", 'w'))
-      @runner_logger = Deas::RunnerLogger.new(@logger)
-    end
-    subject{ @runner_logger }
-
-    should have_instance_methods :verbose, :summary
-
-    should "use the passed logger as #verbose and a null logger as #summary " \
-           "when passed true as the second arg" do
-      runner_logger = Deas::RunnerLogger.new(@logger, true)
-
-      assert_equal @logger, runner_logger.verbose
-      assert_instance_of Deas::NullLogger, runner_logger.summary
-    end
-
-    should "use the passed logger as #summary and a null logger as #verbose " \
-           "when passed false as the second arg" do
-      runner_logger = Deas::RunnerLogger.new(@logger, false)
-
-      assert_instance_of Deas::NullLogger, runner_logger.verbose
-      assert_equal @logger, runner_logger.summary
-    end
-
-  end
-
-end