deas 0.36.0 → 0.37.0

data/lib/deas/error_handler.rb

@@ -6,28 +6,59 @@ module Deas
       self.new(*args).run
     end
 
-    def initialize(exception, sinatra_call, error_procs)
-      @exception    = exception
-      @sinatra_call = sinatra_call
+    attr_reader :exception, :context, :error_procs
 
-      @error_procs = [*error_procs].compact
+    def initialize(exception, context_hash)
+      @exception   = exception
+      @context     = Context.new(context_hash)
+      @error_procs = context_hash[:server_data].error_procs.reverse
     end
 
+    # The exception that we are generating a response for can change in the case
+    # that the configured error proc raises an exception. If this occurs, a
+    # response will be generated for that exception, instead of the original
+    # one. This is designed to avoid "hidden" errors happening, this way the
+    # server will respond and log based on the last exception that occurred.
+
     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
+      @error_procs.inject(nil) do |response, error_proc|
+        result = begin
+          error_proc.call(@exception, @context)
+        rescue StandardError => 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
+          response = nil # reset response
+        end
+        response || result
+      end
+    end
+
+    class Context
+
+      attr_reader :server_data
+      attr_reader :request, :response, :handler_class, :handler, :params
+
+      def initialize(args)
+        @server_data   = args[:server_data]
+        @request       = args[:request]
+        @response      = args[:response]
+        @handler_class = args[:handler_class]
+        @handler       = args[:handler]
+        @params        = args[:params]
+      end
+
+      def ==(other)
+        if other.kind_of?(self.class)
+          self.server_data   == other.server_data &&
+          self.handler_class == other.handler_class &&
+          self.request       == other.request &&
+          self.response      == other.response &&
+          self.handler       == other.handler &&
+          self.params        == other.params
+        else
+          super
         end
       end
-      response
+
     end
 
   end

data/lib/deas/handler_proxy.rb

@@ -15,24 +15,32 @@ module Deas
       raise NotImplementedError
     end
 
-    def run(sinatra_call)
+    def run(server_data, sinatra_call)
       runner = SinatraRunner.new(self.handler_class, {
-        :sinatra_call => sinatra_call,
-        :request      => sinatra_call.request,
-        :response     => sinatra_call.response,
-        :session      => sinatra_call.session,
-        :params       => sinatra_call.params,
-        :logger       => sinatra_call.settings.logger,
-        :router       => sinatra_call.settings.router,
-        :template_source => sinatra_call.settings.template_source
+        :sinatra_call    => sinatra_call,
+        :request         => sinatra_call.request,
+        :response        => sinatra_call.response,
+        :session         => sinatra_call.session,
+        :params          => sinatra_call.params,
+        :logger          => server_data.logger,
+        :router          => server_data.router,
+        :template_source => server_data.template_source
       })
 
-      sinatra_call.request.env.tap do |env|
-        env['deas.params'] = runner.params
-        env['deas.handler_class_name'] = self.handler_class.name
-        env['deas.logging'].call "  Handler: #{env['deas.handler_class_name']}"
-        env['deas.logging'].call "  Params:  #{env['deas.params'].inspect}"
+      runner.request.env.tap do |env|
+        # make runner data available to Rack (ie middlewares)
+        # this is specifically needed by the Logging middleware
+        # this is also needed by the Sinatra error handlers so they can provide
+        # error context.  This may change when we eventually remove Sinatra.
+        env['deas.handler_class'] = self.handler_class
+        env['deas.handler']       = runner.handler
+        env['deas.params']        = runner.params
+
+        # this handles the verbose logging (it is a no-op if summary logging)
+        env['deas.logging'].call "  Handler: #{self.handler_class.name}"
+        env['deas.logging'].call "  Params:  #{runner.params.inspect}"
       end
+
       runner.run
     end
 

data/lib/deas/logging.rb

@@ -13,7 +13,7 @@ module Deas
 
     def initialize(app)
       @app    = app
-      @logger = @app.settings.logger
+      @logger = @app.settings.deas_server_data.logger
     end
 
     # The Rack call interface. The receiver acts as a prototype and runs
@@ -101,7 +101,7 @@ module Deas
       line_attrs = {
         'method'  => request.request_method,
         'path'    => request.path,
-        'handler' => env['deas.handler_class_name'],
+        'handler' => env['deas.handler_class'].name,
         'params'  => env['deas.params'],
         'time'    => env['deas.time_taken'],
         'status'  => status

data/lib/deas/route.rb

@@ -16,14 +16,15 @@ module Deas
       end
     end
 
-    def run(sinatra_call)
-      type = sinatra_call.settings.router.request_type_name(sinatra_call.request)
+    def run(server_data, sinatra_call)
+      type = server_data.router.request_type_name(sinatra_call.request)
       proxy = begin
         @handler_proxies[type]
       rescue HandlerProxyNotFound
         sinatra_call.halt(404)
       end
-      proxy.run(sinatra_call)
+      # TODO: eventually stop sending sinatra call (part of phasing out Sinatra)
+      proxy.run(server_data, sinatra_call)
     end
 
   end

data/lib/deas/server.rb

@@ -9,220 +9,236 @@ require 'deas/show_exceptions'
 require 'deas/sinatra_app'
 require 'deas/template_source'
 
-module Deas; end
-module Deas::Server
-
-  class Configuration
-    include NsOptions::Proxy
-
-    # Sinatra-based options
-
-    option :env,  String,   :default => 'development'
-
-    option :root,        Pathname, :required => true
-    option :public_root, Pathname
-    option :views_root,  Pathname
-
-    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
-    option :default_encoding, String,             :default => 'utf-8'
-
-    # server handling options
-
-    option :verbose_logging, NsOptions::Boolean, :default => true
-    option :logger,                              :default => proc{ Deas::NullLogger.new }
-    option :template_source,                     :default => proc{ Deas::NullTemplateSource.new }
-
-    attr_accessor :settings, :error_procs, :init_procs, :template_helpers
-    attr_accessor :middlewares, :router
-
-    def initialize(values = nil)
-      # these are defaulted here because we want to use the Configuration
-      # instance `root`. If we define a proc above, we will be using the
-      # Configuration class `root`, which will not update these options as
-      # expected.
-      super((values || {}).merge({
-        :public_root => proc{ self.root.join('public') },
-        :views_root  => proc{ self.root.join('views') }
-      }))
-      @settings = {}
-      @error_procs, @init_procs, @template_helpers, @middlewares = [], [], [], []
-      @router = Deas::Router.new
-      @valid = nil
+module Deas
+
+  module Server
+
+    def self.included(receiver)
+      receiver.class_eval do
+        extend ClassMethods
+        include InstanceMethods
+      end
     end
 
-    def valid?
-      !!@valid
+    module InstanceMethods
+      # TODO: once Deas is no longer powered by Sinatra, this should define an
+      # `initialize` method that builds a server instance.  Right now there is
+      # a `new` class method that builds a SinatraApp which does this init
+      # behavior
     end
 
-    # for the config to be considered "valid", a few things need to happen.  The
-    # key here is that this only needs to be done _once_ for each config.
+    module ClassMethods
 
-    def validate!
-      return @valid if !@valid.nil?  # only need to run this once per config
+      # TODO: needed while Deas is powered by Sinatra
+      # eventually do an initialize method more like Sanford does
+      def new
+        Deas::SinatraApp.new(self.configuration)
+      end
 
-      # ensure all user and plugin configs/settings are applied
-      self.init_procs.each{ |p| p.call }
-      raise Deas::ServerRootError if self.root.nil?
+      def configuration
+        @configuration ||= Configuration.new
+      end
 
-      # validate the routes
-      self.routes.each(&:validate!)
+      # sinatra settings DSL
 
-      # set the :erb :outvar setting if it hasn't been set.  this is used
-      # by template helpers and plugins and needs to be queryable.  the actual
-      # value doesn't matter - it just needs to be set
-      self.settings[:erb] ||= {}
-      self.settings[:erb][:outvar] ||= '@_out_buf'
+      def env(*args)
+        self.configuration.env *args
+      end
 
-      # append the show exceptions and loggine middlewares last.  This ensures
-      # that the logging and exception showing happens just before the app gets
-      # the request and just after the app sends a response.
-      self.middlewares << [Deas::ShowExceptions] if self.show_exceptions
-      [*Deas::Logging.middleware(self.verbose_logging)].tap do |mw_args|
-        self.middlewares << mw_args
+      def root(*args)
+        self.configuration.root *args
       end
 
-      @valid = true  # if it made it this far, its valid!
-    end
+      def public_root(*args)
+        self.configuration.public_root *args
+      end
 
-    def urls
-      self.router.urls
-    end
+      def views_root(*args)
+        self.configuration.views_root *args
+      end
 
-    def routes
-      self.router.routes
-    end
+      def dump_errors(*args)
+        self.configuration.dump_errors *args
+      end
 
-  end
+      def method_override(*args)
+        self.configuration.method_override *args
+      end
 
-  def self.included(receiver)
-    receiver.class_eval{ extend ClassMethods }
-  end
+      def sessions(*args)
+        self.configuration.sessions *args
+      end
 
-  module ClassMethods
+      def show_exceptions(*args)
+        self.configuration.show_exceptions *args
+      end
 
-    def new
-      Deas::SinatraApp.new(self.configuration)
-    end
+      def static_files(*args)
+        self.configuration.static_files *args
+      end
 
-    def configuration
-      @configuration ||= Configuration.new
-    end
+      def reload_templates(*args)
+        self.configuration.reload_templates *args
+      end
 
-    # sinatra settings DSL
+      # Server handling DSL
 
-    def env(*args)
-      self.configuration.env *args
-    end
+      def init(&block)
+        self.configuration.init_procs << block
+      end
 
-    def root(*args)
-      self.configuration.root *args
-    end
+      def error(&block)
+        self.configuration.error_procs << block
+      end
 
-    def public_root(*args)
-      self.configuration.public_root *args
-    end
+      def template_helpers(*helper_modules)
+        helper_modules.each{ |m| self.configuration.template_helpers << m }
+        self.configuration.template_helpers
+      end
 
-    def views_root(*args)
-      self.configuration.views_root *args
-    end
+      def template_helper?(helper_module)
+        self.configuration.template_helpers.include?(helper_module)
+      end
 
-    def dump_errors(*args)
-      self.configuration.dump_errors *args
-    end
+      def use(*args)
+        self.configuration.middlewares << args
+      end
 
-    def method_override(*args)
-      self.configuration.method_override *args
-    end
+      def set(name, value)
+        self.configuration.settings[name.to_sym] = value
+      end
 
-    def sessions(*args)
-      self.configuration.sessions *args
-    end
+      def verbose_logging(*args)
+        self.configuration.verbose_logging *args
+      end
 
-    def show_exceptions(*args)
-      self.configuration.show_exceptions *args
-    end
+      def logger(*args)
+        self.configuration.logger *args
+      end
 
-    def static_files(*args)
-      self.configuration.static_files *args
-    end
+      def default_encoding(*args)
+        self.configuration.default_encoding *args
+      end
 
-    def reload_templates(*args)
-      self.configuration.reload_templates *args
-    end
+      def template_source(*args)
+        self.configuration.template_source *args
+      end
 
-    # Server handling DSL
+      # router handling
 
-    def init(&block)
-      self.configuration.init_procs << block
-    end
+      def router(value = nil)
+        self.configuration.router = value if !value.nil?
+        self.configuration.router
+      end
 
-    def error(&block)
-      self.configuration.error_procs << block
-    end
+      def view_handler_ns(*args); self.router.view_handler_ns(*args); end
+      def base_url(*args);        self.router.base_url(*args);        end
 
-    def template_helpers(*helper_modules)
-      helper_modules.each{ |m| self.configuration.template_helpers << m }
-      self.configuration.template_helpers
-    end
+      def url(*args, &block);     self.router.url(*args, &block);     end
+      def url_for(*args, &block); self.router.url_for(*args, &block); end
 
-    def template_helper?(helper_module)
-      self.configuration.template_helpers.include?(helper_module)
-    end
+      def default_request_type_name(*args); self.router.default_request_type_name(*args); end
+      def add_request_type(*args, &block);  self.router.add_request_type(*args, &block);  end
+      def request_type_name(*args);         self.router.request_type_name(*args);         end
 
-    def use(*args)
-      self.configuration.middlewares << args
-    end
+      def get(*args, &block);    self.router.get(*args, &block);    end
+      def post(*args, &block);   self.router.post(*args, &block);   end
+      def put(*args, &block);    self.router.put(*args, &block);    end
+      def patch(*args, &block);  self.router.patch(*args, &block);  end
+      def delete(*args, &block); self.router.delete(*args, &block); end
 
-    def set(name, value)
-      self.configuration.settings[name.to_sym] = value
-    end
+      def route(*args, &block);    self.router.route(*args, &block);    end
+      def redirect(*args, &block); self.router.redirect(*args, &block); end
 
-    def verbose_logging(*args)
-      self.configuration.verbose_logging *args
     end
 
-    def logger(*args)
-      self.configuration.logger *args
-    end
+    class Configuration
+      include NsOptions::Proxy
 
-    def default_encoding(*args)
-      self.configuration.default_encoding *args
-    end
+      # Sinatra-based options
 
-    def template_source(*args)
-      self.configuration.template_source *args
-    end
+      option :env,  String,   :default => 'development'
 
-    # router handling
+      option :root,        Pathname, :required => true
+      option :public_root, Pathname
+      option :views_root,  Pathname
 
-    def router(value = nil)
-      self.configuration.router = value if !value.nil?
-      self.configuration.router
-    end
+      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
+      option :default_encoding, String,             :default => 'utf-8'
 
-    def view_handler_ns(*args); self.router.view_handler_ns(*args); end
-    def base_url(*args);        self.router.base_url(*args);        end
+      # server handling options
 
-    def url(*args, &block);     self.router.url(*args, &block);     end
-    def url_for(*args, &block); self.router.url_for(*args, &block); end
+      option :verbose_logging, NsOptions::Boolean, :default => true
+      option :logger,                              :default => proc{ Deas::NullLogger.new }
+      option :template_source,                     :default => proc{ Deas::NullTemplateSource.new }
 
-    def default_request_type_name(*args); self.router.default_request_type_name(*args); end
-    def add_request_type(*args, &block);  self.router.add_request_type(*args, &block);  end
-    def request_type_name(*args);         self.router.request_type_name(*args);         end
+      attr_accessor :settings, :init_procs, :error_procs, :template_helpers
+      attr_accessor :middlewares, :router
 
-    def get(*args, &block);    self.router.get(*args, &block);    end
-    def post(*args, &block);   self.router.post(*args, &block);   end
-    def put(*args, &block);    self.router.put(*args, &block);    end
-    def patch(*args, &block);  self.router.patch(*args, &block);  end
-    def delete(*args, &block); self.router.delete(*args, &block); end
+      def initialize(values = nil)
+        # these are defaulted here because we want to use the Configuration
+        # instance `root`. If we define a proc above, we will be using the
+        # Configuration class `root`, which will not update these options as
+        # expected.
+        super((values || {}).merge({
+          :public_root => proc{ self.root.join('public') },
+          :views_root  => proc{ self.root.join('views') }
+        }))
+        @settings = {}
+        @init_procs, @error_procs, @template_helpers, @middlewares = [], [], [], []
+        @router = Deas::Router.new
+        @valid  = nil
+      end
+
+      def urls
+        self.router.urls
+      end
+
+      def routes
+        self.router.routes
+      end
+
+      def to_hash
+        super.merge({
+          :error_procs => self.error_procs,
+          :router      => self.router
+        })
+      end
+
+      def valid?
+        !!@valid
+      end
 
-    def route(*args, &block);    self.router.route(*args, &block);    end
-    def redirect(*args, &block); self.router.redirect(*args, &block); end
+      # for the config to be considered "valid", a few things need to happen.  The
+      # key here is that this only needs to be done _once_ for each config.
+
+      def validate!
+        return @valid if !@valid.nil?  # only need to run this once per config
+
+        # ensure all user and plugin configs/settings are applied
+        self.init_procs.each{ |p| p.call }
+        raise Deas::ServerRootError if self.root.nil?
+
+        # validate the routes
+        self.routes.each(&:validate!)
+
+        # append the show exceptions and logging middlewares last.  This ensures
+        # that the logging and exception showing happens just before the app gets
+        # the request and just after the app sends a response.
+        self.middlewares << [Deas::ShowExceptions] if self.show_exceptions
+        [*Deas::Logging.middleware(self.verbose_logging)].tap do |mw_args|
+          self.middlewares << mw_args
+        end
+
+        @valid = true  # if it made it this far, its valid!
+      end
+
+    end
 
   end