deas 0.42.0 → 0.43.0

data/lib/deas/server_data.rb

@@ -9,7 +9,7 @@ module Deas
 
     attr_reader :error_procs, :template_source, :logger, :router
 
-    def initialize(args = nil)
+    def initialize(args)
       args ||= {}
       @error_procs     = args[:error_procs] || []
       @template_source = args[:template_source]
@@ -17,6 +17,17 @@ module Deas
       @router          = args[:router]
     end
 
+    def ==(other_server_data)
+      if other_server_data.kind_of?(ServerData)
+        self.error_procs     == other_server_data.error_procs     &&
+        self.template_source == other_server_data.template_source &&
+        self.logger          == other_server_data.logger          &&
+        self.router          == other_server_data.router
+      else
+        super
+      end
+    end
+
   end
 
 end

data/lib/deas/sinatra_app.rb

@@ -1,12 +1,27 @@
 require 'sinatra/base'
 require 'deas/error_handler'
 require 'deas/exceptions'
+require 'deas/request_data'
 require 'deas/server_data'
 
 module Deas
 
   module SinatraApp
 
+    DEFAULT_ERROR_RESPONSE_STATUS = 500.freeze
+
+    # these are standard error classes that we rescue, handle and don't reraise
+    # in the rack app, this keeps the app from shutting down unexpectedly;
+    # `LoadError`, `NotImplementedError` and `Timeout::Error` are common non
+    # `StandardError` exceptions that should be treated like a `StandardError`
+    # so we don't want one of these to shutdown the app
+    STANDARD_ERROR_CLASSES = [
+      StandardError,
+      LoadError,
+      NotImplementedError,
+      Timeout::Error
+    ].freeze
+
     def self.new(server_config)
       # This is generic server initialization stuff.  Eventually do this in the
       # server's initialization logic more like Sanford does.
@@ -19,17 +34,11 @@ module Deas
       })
 
       Sinatra.new do
-        # built-in settings
-        set :environment,      server_config.env
-        set :root,             server_config.root
-        set :views,            server_config.views_root
-        set :public_folder,    server_config.public_root
-        set :default_encoding, server_config.default_encoding
-        set :dump_errors,      server_config.dump_errors
-        set :method_override,  server_config.method_override
-        set :reload_templates, server_config.reload_templates
-        set :sessions,         server_config.sessions
-        set :static,           server_config.static_files
+        # unifying settings - these are used by Deas so extensions can have a
+        # common way to identify these low-level settings.  Deas does not use
+        # them directly
+        set :environment, server_config.env
+        set :root,        server_config.root
 
         # TODO: sucks to have to do this but b/c of Rack there is no better way
         # to make the server data available to middleware.  We should remove this
@@ -38,32 +47,61 @@ module Deas
         # Not sure right now, just jotting down notes.
         set :deas_server_data, server_data
 
+        # static settings - Deas doesn't care about these anymore so just
+        # use some intelligent defaults
+        set :views,            server_config.root
+        set :public_folder,    server_config.root
+        set :default_encoding, 'utf-8'
+        set :method_override,  false
+        set :reload_templates, false
+        set :static,           false
+        set :sessions,         false
+
+        # Turn this off b/c Deas won't auto provide it.  We may add an extension
+        # gem or something??
+        disable :protection
+
         # 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
 
-        # turn off logging b/c Deas handles its own logging logic
+        # turn off logging, dump_errors b/c Deas handles its own logging logic
+        set :dump_errors,      false
         set :logging,          false
 
-        # 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:
-        # ["application/javascript", "application/xml", "application/xhtml+xml", /^text\//]
-        settings.add_charset << "application/json"
-
-        server_config.settings.each{ |set_args| set *set_args }
         server_config.middlewares.each{ |use_args| use *use_args }
 
         # routes
         server_config.routes.each do |route|
-          # 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) }
+          send(route.method, route.path) do
+            begin
+              route.run(
+                server_data,
+                RequestData.new({
+                  :request    => request,
+                  :response   => response,
+                  :params     => params,
+                  :route_path => route.path
+                })
+              )
+            rescue *STANDARD_ERROR_CLASSES => err
+              request.env['deas.error'] = err
+              response.status = DEFAULT_ERROR_RESPONSE_STATUS
+              ErrorHandler.run(request.env['deas.error'], {
+                :server_data   => server_data,
+                :request       => request,
+                :response      => response,
+                :handler_class => request.env['deas.handler_class'],
+                :handler       => request.env['deas.handler'],
+                :params        => request.env['deas.params'],
+                :splat         => request.env['deas.splat'],
+                :route_path    => request.env['deas.route_path']
+              })
+            end
+          end
         end
 
-        # error handling
-
         not_found do
           # `self` is the sinatra call in this context
           if env['sinatra.error']
@@ -76,25 +114,13 @@ module Deas
             end
             ErrorHandler.run(env['deas.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
-        error do
-          # `self` is the sinatra call in this context
-          if env['sinatra.error']
-            env['deas.error'] = env['sinatra.error']
-            ErrorHandler.run(env['deas.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'],
+              :request       => request,
+              :response      => response,
+              :handler_class => request.env['deas.handler_class'],
+              :handler       => request.env['deas.handler'],
+              :params        => request.env['deas.params'],
+              :splat         => request.env['deas.splat'],
+              :route_path    => request.env['deas.route_path']
             })
           end
         end

data/lib/deas/test_runner.rb

@@ -27,15 +27,16 @@ module Deas
         :router          => a.delete(:router),
         :template_source => a.delete(:template_source),
         :request         => a.delete(:request),
-        :session         => a.delete(:session),
         :params          => NormalizedParams.new(a.delete(:params) || {}).value,
-        :splat           => a.delete(:splat)
+        :route_path      => a.delete(:route_path)
       })
+      @splat = a.delete(:splat)
       a.each{|key, value| self.handler.send("#{key}=", value) }
 
       catch(:halt){ self.handler.deas_init }
     end
 
+    def splat;   @splat;  end
     def halted?; @halted; end
 
     def run

data/lib/deas/url.rb

@@ -38,16 +38,20 @@ module Deas
     end
 
     def set_named(path, params)
-      params.inject(path) do |path_string, (name, value)|
-        if path_string.include?(":#{name}")
-          if (v = value.to_s).empty?
-            raise EmptyNamedValueError , "an empty value (`#{value.inspect}`) " \
-                                         "was given for the `#{name}` url param"
+      # Process longer param names first. This ensures that shorter names that
+      # compose longer names won't be set as a part of the longer name.
+      params.keys.sort{ |a, b| b.to_s.size <=> a.to_s.size }.inject(path) do |p, name|
+        if p.include?(":#{name}")
+          if (v = params[name].to_s).empty?
+            raise EmptyNamedValueError , "an empty value, " \
+                                         "`#{params[name].inspect}`, " \
+                                         "was given for the " \
+                                         "`#{name.inspect}` url param"
           end
           params.delete(name)
-          path_string.gsub(":#{name}", v)
+          p.gsub(":#{name}", v)
         else
-          path_string
+          p
         end
       end
     end

data/lib/deas/version.rb

@@ -1,3 +1,3 @@
 module Deas
-  VERSION = "0.42.0"
+  VERSION = "0.43.0"
 end

data/lib/deas/view_handler.rb

@@ -65,7 +65,6 @@ module Deas
 
       # request
       def request; @deas_runner.request; end
-      def session; @deas_runner.session; end
       def params;  @deas_runner.params;  end
       def splat;   @deas_runner.splat;   end
 
@@ -131,7 +130,6 @@ module Deas
       def test_runner(handler_class, args = nil)
         args ||= {}
         args[:request] ||= Rack::Request.new({})
-        args[:session] ||= args[:request].session
         TestRunner.new(handler_class, args)
       end
 

data/test/support/factory.rb

@@ -1,9 +1,11 @@
 require 'assert/factory'
 require 'deas/logger'
+require 'deas/request_data'
 require 'deas/router'
 require 'deas/server_data'
 require 'deas/template_source'
 require 'test/support/fake_request'
+require 'test/support/fake_response'
 require 'test/support/fake_sinatra_call'
 
 module Factory
@@ -30,6 +32,20 @@ module Factory
     FakeRequest.new(args)
   end
 
+  def self.response(args = nil)
+    FakeResponse.new(args)
+  end
+
+  def self.request_data(args = nil)
+    args ||= {}
+    Deas::RequestData.new({
+      :request    => args[:request]    || Factory.request,
+      :response   => args[:response]   || Factory.response,
+      :params     => args[:params]     || { Factory.string => Factory.string },
+      :route_path => args[:route_path] || Factory.string
+    })
+  end
+
   def self.sinatra_call(settings = nil)
     FakeSinatraCall.new(settings)
   end

data/test/support/fake_request.rb

@@ -1,6 +1,7 @@
 require 'ostruct'
 
 class FakeRequest < Struct.new(:http_method, :path, :params, :session, :env)
+
   alias :request_method :http_method
 
   attr_reader :logging_msgs

data/test/support/fake_response.rb

@@ -0,0 +1,12 @@
+class FakeResponse < Struct.new(:status, :headers, :body)
+
+  def initialize(args = nil)
+    args ||= {}
+    super(*[
+      args[:status]  || Factory.integer,
+      args[:headers] || Rack::Utils::HeaderHash.new,
+      args[:body]    || [Factory.text]
+    ])
+  end
+
+end

data/test/support/fake_sinatra_call.rb

@@ -1,4 +1,5 @@
 require 'test/support/fake_request'
+require 'test/support/fake_response'
 
 class FakeSinatraCall
 
@@ -68,14 +69,3 @@ class FakeSinatraCall
   SendFileArgs = Struct.new(:file_path, :options, :block_call_result)
 
 end
-
-class FakeResponse < Struct.new(:status, :headers, :body)
-  def initialize(args = nil)
-    args ||= {}
-    super(*[
-      args[:status]  || Factory.integer,
-      args[:headers] || {},
-      args[:body]    || [Factory.text]
-    ])
-  end
-end

data/test/support/routes.rb

@@ -8,13 +8,11 @@ class DeasTestServer
   logger TEST_LOGGER
   verbose_logging Factory.boolean
 
-  set :a_setting, 'something'
-
   error do |exception, context|
     case exception
     when Deas::NotFound
       [404, "Couldn't be found"]
-    when Exception
+    when *Deas::SinatraApp::STANDARD_ERROR_CLASSES
       [500, "Oops, something went wrong"]
     end
   end
@@ -46,6 +44,10 @@ class DeasTestServer
     redirect('/:prefix/redirect'){ "/#{params['prefix']}/somewhere" }
   end
 
+  use Rack::Session::Cookie, :key          => 'my.session',
+                             :expire_after => Factory.integer,
+                             :secret       => Factory.string
+
 end
 
 class DeasDevServer
@@ -153,7 +155,7 @@ class ErrorHandler
   include Deas::ViewHandler
 
   def run!
-    raise 'test'
+    raise Deas::SinatraApp::STANDARD_ERROR_CLASSES.sample, 'sinatra app standard error'
   end
 
 end
@@ -171,7 +173,7 @@ class SetSessionHandler
   include Deas::ViewHandler
 
   def run!
-    session[:secret] = 'session_secret'
+    request.session[:secret] = 'session_secret'
     redirect '/session'
   end
 
@@ -181,7 +183,7 @@ class UseSessionHandler
   include Deas::ViewHandler
 
   def run!
-    body session[:secret]
+    body request.session[:secret]
   end
 
 end
@@ -194,7 +196,6 @@ class HandlerTestsHandler
     set_data('logger_class_name'){ logger.class.name }
     set_data('request_method'){ request.request_method.to_s }
     set_data('params_a_param'){ params['a-param'] }
-    set_data('session_inspect'){ session.inspect }
   end
 
   def set_data(a, &block)

data/test/system/deas_tests.rb

@@ -111,14 +111,7 @@ module Deas
   end
 
   class SessionTests < RackTests
-    desc "with sessions enabled"
-    setup do
-      @orig_sessions = @app.settings.sessions
-      @app.set :sessions, true
-    end
-    teardown do
-      @app.set :sessions, @orig_sessions
-    end
+    desc "using sessions"
 
     should "return a 200 response and the session value" do
       post '/session'
@@ -141,8 +134,7 @@ module Deas
       exp = {
         'logger_class_name' => 'Logger',
         'request_method'    => 'GET',
-        'params_a_param'    => 'something',
-        'session_inspect'   => '{}'
+        'params_a_param'    => 'something'
       }
       assert_equal exp.inspect, @data_inspect
     end
@@ -168,7 +160,7 @@ module Deas
 
       assert_equal 500, last_response.status
       assert_equal "text/plain", last_response.headers['Content-Type']
-      assert_match "RuntimeError: test", last_response.body
+      assert_match "sinatra app standard error", last_response.body
     end
 
   end

data/test/unit/error_handler_tests.rb

@@ -12,9 +12,11 @@ class Deas::ErrorHandler
       @server_data      = Factory.server_data(:error_procs => @error_proc_spies)
       @request          = Factory.string
       @response         = Factory.string
-      @handler_class    = Factory.string
+      @handler_class    = Deas::ErrorHandler
       @handler          = Factory.string
       @params           = Factory.string
+      @splat            = Factory.string
+      @route_path       = Factory.string
 
       @context_hash = {
         :server_data   => @server_data,
@@ -23,9 +25,9 @@ class Deas::ErrorHandler
         :handler_class => @handler_class,
         :handler       => @handler,
         :params        => @params,
+        :splat         => @splat,
+        :route_path    => @route_path
       }
-
-      @handler_class = Deas::ErrorHandler
     end
     subject{ @handler_class }
 
@@ -113,7 +115,8 @@ class Deas::ErrorHandler
     subject{ @context }
 
     should have_readers :server_data
-    should have_readers :request, :response, :handler_class, :handler, :params
+    should have_readers :request, :response, :handler_class, :handler
+    should have_readers :params, :splat, :route_path
 
     should "know its attributes" do
       assert_equal @context_hash[:server_data],   subject.server_data
@@ -122,13 +125,24 @@ class Deas::ErrorHandler
       assert_equal @context_hash[:handler_class], subject.handler_class
       assert_equal @context_hash[:handler],       subject.handler
       assert_equal @context_hash[:params],        subject.params
+      assert_equal @context_hash[:splat],         subject.splat
+      assert_equal @context_hash[:route_path],    subject.route_path
     end
 
     should "know if it equals another context" do
       exp = Context.new(@context_hash)
       assert_equal exp, subject
 
-      exp = Context.new({})
+      exp = Context.new({
+        :server_data   => Factory.server_data,
+        :request       => Factory.string,
+        :response      => Factory.string,
+        :handler_class => Factory.string,
+        :handler       => Factory.string,
+        :params        => Factory.string,
+        :splat         => Factory.string,
+        :route_path    => Factory.string
+      })
       assert_not_equal exp, subject
     end