deas 0.36.0 → 0.37.0

data/lib/deas/server_data.rb

@@ -0,0 +1,22 @@
+module Deas
+
+  class ServerData
+
+    # The server uses this to "compile" its configuration for speed. NsOptions
+    # is relatively slow everytime an option is read. To avoid this, we read the
+    # options one time here and memoize their values. This way, we don't pay the
+    # NsOptions overhead when reading them while handling a request.
+
+    attr_reader :error_procs, :logger, :router, :template_source
+
+    def initialize(args = nil)
+      args ||= {}
+      @error_procs     = args[:error_procs] || []
+      @logger          = args[:logger]
+      @router          = args[:router]
+      @template_source = args[:template_source]
+    end
+
+  end
+
+end

data/lib/deas/sinatra_app.rb

@@ -1,21 +1,23 @@
 require 'sinatra/base'
 require 'deas/error_handler'
+require 'deas/server_data'
 
 module Deas
+
   module SinatraApp
 
     def self.new(server_config)
+      # This is generic server initialization stuff.  Eventually do this in the
+      # server's initialization logic more like Sanford does.
       server_config.validate!
+      server_data = ServerData.new(server_config.to_hash)
 
       Sinatra.new do
-
         # built-in settings
-        set :environment, server_config.env
-        set :root,        server_config.root
-
-        set :public_folder, server_config.public_root
-        set :views,         server_config.views_root
-
+        set :environment,      server_config.env
+        set :root,             server_config.root
+        set :public_folder,    server_config.public_root
+        set :views,            server_config.views_root
         set :dump_errors,      server_config.dump_errors
         set :method_override,  server_config.method_override
         set :sessions,         server_config.sessions
@@ -24,18 +26,18 @@ module Deas
         set :default_encoding, server_config.default_encoding
         set :logging,          false
 
-        # raise_errors and show_exceptions prevent Deas error handlers from
-        # being called and Deas' logging doesn't finish. They should always be
-        # false.
+        # TODO: sucks to have to do this but b/c or Rack there is no better way
+        # to make the server data available to middleware.  We should remove this
+        # once we remove Sinatra.  Whatever rack app implemenation will needs to
+        # provide the server data or maybe the server data *will be* the rack app.
+        # Not sure right now, just jotting down notes.
+        set :deas_server_data, server_data
+
+        # raise_errors and show_exceptions prevent Deas error handlers from being
+        # called and Deas' logging doesn't finish. They should always be false.
         set :raise_errors,     false
         set :show_exceptions,  false
 
-        # custom settings
-        set :deas_error_procs, server_config.error_procs
-        set :logger,           server_config.logger
-        set :router,           server_config.router
-        set :template_source,  server_config.template_source
-
         # TODO: rework with `server_config.default_encoding` once we move off of using Sinatra
         # TODO: could maybe move into a deas-json mixin once off of Sinatra
         # Add charset to json content type responses - by default only added to these:
@@ -47,20 +49,39 @@ module Deas
 
         # routes
         server_config.routes.each do |route|
-          send(route.method, route.path){ route.run(self) }
+          # TODO: `self` is the sinatra_call; eventually stop sending it
+          # (part of phasing out Sinatra)
+          send(route.method, route.path){ route.run(server_data, self) }
         end
 
         # error handling
         not_found do
+          # `self` is the sinatra call in this context
           env['sinatra.error'] ||= Sinatra::NotFound.new
-          ErrorHandler.run(env['sinatra.error'], self, settings.deas_error_procs)
+          ErrorHandler.run(env['sinatra.error'], {
+            :server_data   => server_data,
+            :request       => self.request,
+            :response      => self.response,
+            :handler_class => self.request.env['deas.handler_class'],
+            :handler       => self.request.env['deas.handler'],
+            :params        => self.request.env['deas.params'],
+          })
         end
         error do
-          ErrorHandler.run(env['sinatra.error'], self, settings.deas_error_procs)
+          # `self` is the sinatra call in this context
+          ErrorHandler.run(env['sinatra.error'], {
+            :server_data   => server_data,
+            :request       => self.request,
+            :response      => self.response,
+            :handler_class => self.request.env['deas.handler_class'],
+            :handler       => self.request.env['deas.handler'],
+            :params        => self.request.env['deas.params'],
+          })
         end
 
       end
     end
 
   end
+
 end

data/lib/deas/version.rb

@@ -1,3 +1,3 @@
 module Deas
-  VERSION = "0.36.0"
+  VERSION = "0.37.0"
 end

data/test/support/factory.rb

@@ -1,6 +1,31 @@
 require 'assert/factory'
+require 'deas/logger'
+require 'deas/router'
+require 'deas/server_data'
+require 'deas/template_source'
+require 'test/support/fake_sinatra_call'
 
 module Factory
   extend Assert::Factory
 
+  def self.exception(klass = nil, message = nil)
+    klass ||= StandardError
+    message ||= Factory.text
+    exception = nil
+    begin; raise(klass, message); rescue klass => exception; end
+    exception
+  end
+
+  def self.server_data(opts = nil)
+    Deas::ServerData.new({
+      :logger          => Deas::NullLogger.new,
+      :router          => Deas::Router.new,
+      :template_source => Deas::NullTemplateSource.new
+    }.merge(opts || {}))
+  end
+
+  def self.sinatra_call(settings = nil)
+    FakeSinatraCall.new(settings)
+  end
+
 end

data/test/support/fake_sinatra_call.rb

@@ -1,7 +1,4 @@
 require 'ostruct'
-require 'deas/logger'
-require 'deas/router'
-require 'deas/template_source'
 
 class FakeSinatraCall
 
@@ -11,7 +8,7 @@ class FakeSinatraCall
   attr_accessor :request, :response, :params, :logger, :router, :session
   attr_accessor :settings
 
-  def initialize(settings = {})
+  def initialize(settings = nil)
     @request         = FakeRequest.new('GET','/something', {}, OpenStruct.new)
     @response        = FakeResponse.new
     @session         = @request.session
@@ -25,10 +22,8 @@ class FakeSinatraCall
     @headers      = {}
 
     @settings = OpenStruct.new({
-      :logger => @logger,
-      :router => @router,
-      :template_source => @template_source
-    }.merge(settings))
+      :deas_server_data => Factory.server_data
+    }.merge(settings || {}))
   end
 
   def halt(*args)

data/test/support/routes.rb

@@ -10,12 +10,12 @@ class DeasTestServer
 
   set :a_setting, 'something'
 
-  error do |exception|
+  error do |exception, context|
     case exception
     when Sinatra::NotFound
-      halt 404, "Couldn't be found"
+      [404, "Couldn't be found"]
     when Exception
-      halt 500, "Oops, something went wrong"
+      [500, "Oops, something went wrong"]
     end
   end
 

data/test/unit/error_handler_tests.rb

@@ -1,106 +1,155 @@
 require 'assert'
 require 'deas/error_handler'
 
-require 'test/support/fake_sinatra_call'
-
 class Deas::ErrorHandler
 
   class UnitTests < Assert::Context
     desc "Deas::ErrorHandler"
     setup do
-      @exception = RuntimeError.new
-      @fake_sinatra_call  = FakeSinatraCall.new
-      @error_handler = Deas::ErrorHandler.new(@exception, @fake_sinatra_call, [])
+      # always make sure there are multiple error procs or tests can be false
+      # positives
+      @error_proc_spies = (Factory.integer(3) + 1).times.map{ ErrorProcSpy.new }
+      @server_data      = Factory.server_data(:error_procs => @error_proc_spies)
+      @request          = Factory.string
+      @response         = Factory.string
+      @handler_class    = Factory.string
+      @handler          = Factory.string
+      @params           = Factory.string
+
+      @context_hash = {
+        :server_data   => @server_data,
+        :request       => @request,
+        :response      => @response,
+        :handler_class => @handler_class,
+        :handler       => @handler,
+        :params        => @params,
+      }
+
+      @handler_class = Deas::ErrorHandler
     end
-    subject{ @error_handler }
+    subject{ @handler_class }
 
-    should have_instance_methods :run
-    should have_class_methods :run
+    should have_imeths :run
 
   end
 
-  class RunTests < UnitTests
-    desc "run"
+  class InitTests < UnitTests
+    desc "when init"
     setup do
-      @error_procs = [ proc do |exception|
-        settings.exception_that_occurred = exception
-        "my return value"
-      end ]
+      @exception = Factory.exception
+      @error_handler = @handler_class.new(@exception, @context_hash)
+    end
+    subject{ @error_handler }
+
+    should have_readers :exception, :context, :error_procs
+    should have_imeths :run
+
+    should "know its attrs" do
+      assert_equal @exception, subject.exception
+
+      exp = Context.new(@context_hash)
+      assert_equal exp, subject.context
 
-      @error_handler = Deas::ErrorHandler.new(@exception, @fake_sinatra_call, @error_procs)
+      exp = @server_data.error_procs.reverse
+      assert_equal exp, subject.error_procs
+    end
+
+  end
+
+  class RunTests < InitTests
+    desc "and run"
+    setup do
       @response = @error_handler.run
     end
 
-    should "run the proc in the context of the app" do
-      assert_equal @exception, @fake_sinatra_call.settings.exception_that_occurred
+    should "call each of its procs" do
+      subject.error_procs.each do |proc_spy|
+        assert_true proc_spy.called
+        assert_equal subject.exception, proc_spy.exception
+        assert_equal subject.context,   proc_spy.context
+      end
     end
 
-    should "return whatever the proc returns" do
-      assert_equal "my return value", @response
+    should "return the last non-nil response" do
+      assert_nil @response
+
+      exp = Factory.string
+      subject.error_procs.first.response = exp
+      assert_equal exp, subject.run
     end
 
   end
 
-  class RunWithMultipleProcsTests < UnitTests
-    desc "run with multiple procs"
+  class RunWithProcsThatRaiseTests < InitTests
+    desc "and run with procs that raise exceptions"
     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_sinatra_call, @error_procs)
-      @response = @error_handler.run
+      @first_exception, @last_exception = Factory.exception, Factory.exception
+      @error_handler.error_procs.first.raise_exception = @first_exception
+      @error_handler.error_procs.last.raise_exception  = @last_exception
+
+      @error_handler.run
     end
 
-    should "run all the error procs" do
-      assert_equal true, @fake_sinatra_call.settings.first_proc_run
-      assert_equal true, @fake_sinatra_call.settings.second_proc_run
-      assert_equal true, @fake_sinatra_call.settings.third_proc_run
+    should "call each of its procs" do
+      subject.error_procs.each{ |proc_spy| assert_true proc_spy.called }
     end
 
-    should "return the last non-nil response" do
-      assert_equal 'second', @response
+    should "call each proc with the most recently raised exception" do
+      assert_equal @exception,       @error_handler.error_procs.first.exception
+      assert_equal @first_exception, @error_handler.error_procs.last.exception
+    end
+
+    should "alter the handler's exception to be the last raised exception" do
+      assert_equal @last_exception, subject.exception
     end
 
   end
 
-  class RunWithProcsThatHaltTests < UnitTests
-    desc "run with a proc that halts"
+  class ContextTests < UnitTests
+    desc "Context"
     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_sinatra_call, @error_procs)
-      @response = catch(:halt){ @error_handler.run }
+      @context = Context.new(@context_hash)
+    end
+    subject{ @context }
+
+    should have_readers :server_data
+    should have_readers :request, :response, :handler_class, :handler, :params
+
+    should "know its attributes" do
+      assert_equal @context_hash[:server_data],   subject.server_data
+      assert_equal @context_hash[:request],       subject.request
+      assert_equal @context_hash[:response],      subject.response
+      assert_equal @context_hash[:handler_class], subject.handler_class
+      assert_equal @context_hash[:handler],       subject.handler
+      assert_equal @context_hash[:params],        subject.params
     end
 
-    should "run error procs until one halts" do
-      assert_equal true, @fake_sinatra_call.settings.first_proc_run
-      assert_nil @fake_sinatra_call.settings.second_proc_run
+    should "know if it equals another context" do
+      exp = Context.new(@context_hash)
+      assert_equal exp, subject
+
+      exp = Context.new({})
+      assert_not_equal exp, subject
     end
 
-    should "return whatever was halted" do
-      assert_equal [ 401 ], @response
+  end
+
+  class ErrorProcSpy
+    attr_reader :called, :exception, :context
+    attr_accessor :response, :raise_exception
+
+    def initialize
+      @called = false
     end
 
+    def call(exception, context)
+      @called    = true
+      @exception = exception
+      @context   = context
+
+      raise self.raise_exception if self.raise_exception
+      @response
+    end
   end
 
 end

data/test/unit/handler_proxy_tests.rb

@@ -3,7 +3,6 @@ require 'deas/handler_proxy'
 
 require 'deas/exceptions'
 require 'deas/sinatra_runner'
-require 'test/support/fake_sinatra_call'
 require 'test/support/view_handlers'
 
 class Deas::HandlerProxy
@@ -39,41 +38,43 @@ class Deas::HandlerProxy
 
       Assert.stub(@proxy, :handler_class){ EmptyViewHandler }
 
-      @fake_sinatra_call = FakeSinatraCall.new
-      @proxy.run(@fake_sinatra_call)
+      @server_data       = Factory.server_data
+      @fake_sinatra_call = Factory.sinatra_call
+      @proxy.run(@server_data, @fake_sinatra_call)
     end
 
     should "build and run a sinatra runner" do
       assert_equal subject.handler_class, @runner_spy.handler_class
 
       exp_args = {
-        :sinatra_call => @fake_sinatra_call,
-        :request      => @fake_sinatra_call.request,
-        :response     => @fake_sinatra_call.response,
-        :session      => @fake_sinatra_call.session,
-        :params       => @fake_sinatra_call.params,
-        :logger       => @fake_sinatra_call.settings.logger,
-        :router       => @fake_sinatra_call.settings.router,
-        :template_source => @fake_sinatra_call.settings.template_source
+        :sinatra_call    => @fake_sinatra_call,
+        :request         => @fake_sinatra_call.request,
+        :response        => @fake_sinatra_call.response,
+        :session         => @fake_sinatra_call.session,
+        :params          => @fake_sinatra_call.params,
+        :logger          => @server_data.logger,
+        :router          => @server_data.router,
+        :template_source => @server_data.template_source
       }
       assert_equal exp_args, @runner_spy.args
 
       assert_true @runner_spy.run_called
     end
 
-    should "add the runner params to the request env" do
+    should "add data to the request env to make it available to Rack" do
+      exp = subject.handler_class
+      assert_equal exp, @fake_sinatra_call.request.env['deas.handler_class']
+
+      exp = @runner_spy.handler
+      assert_equal exp, @fake_sinatra_call.request.env['deas.handler']
+
       exp = @runner_spy.params
       assert_equal exp, @fake_sinatra_call.request.env['deas.params']
     end
 
-    should "add the handler class name to the request env" do
-      exp = subject.handler_class.name
-      assert_equal exp, @fake_sinatra_call.request.env['deas.handler_class_name']
-    end
-
-    should "log the handler and params" do
+    should "log the handler class name and the params" do
       exp_msgs = [
-        "  Handler: #{subject.handler_class}",
+        "  Handler: #{subject.handler_class.name}",
         "  Params:  #{@runner_spy.params.inspect}"
       ]
       assert_equal exp_msgs, @fake_sinatra_call.request.logging_msgs
@@ -84,7 +85,7 @@ class Deas::HandlerProxy
   class SinatraRunnerSpy
 
     attr_reader :run_called
-    attr_reader :handler_class, :args
+    attr_reader :handler_class, :handler, :args
     attr_reader :sinatra_call
     attr_reader :request, :response, :session, :params
     attr_reader :logger, :router, :template_source
@@ -94,15 +95,17 @@ class Deas::HandlerProxy
     end
 
     def build(handler_class, args)
-      @handler_class, @args = handler_class, args
-
-      @sinatra_call = args[:sinatra_call]
-      @request      = args[:request]
-      @response     = args[:response]
-      @session      = args[:session]
-      @params       = args[:params]
-      @logger       = args[:logger]
-      @router       = args[:router]
+      @handler_class = handler_class
+      @handler       = handler_class.new(self)
+      @args          = args
+
+      @sinatra_call    = args[:sinatra_call]
+      @request         = args[:request]
+      @response        = args[:response]
+      @session         = args[:session]
+      @params          = args[:params]
+      @logger          = args[:logger]
+      @router          = args[:router]
       @template_source = args[:template_source]
     end