deas 0.37.1 → 0.38.0

data/lib/deas/exceptions.rb

@@ -18,4 +18,6 @@ module Deas
 
   HandlerProxyNotFound = Class.new(Error)
 
+  NotFound = Class.new(Error)
+
 end

data/lib/deas/logging.rb

@@ -38,7 +38,7 @@ module Deas
       benchmark = Benchmark.measure do
         status, headers, body = @app.call(env)
       end
-      log_error(env['sinatra.error'])
+      log_error(env['deas.error'])
       env['deas.time_taken'] = RoundedTime.new(benchmark.real)
 
       [status, headers, body]
@@ -49,9 +49,9 @@ module Deas
     end
 
     def log_error(exception)
-      return if !exception || exception.kind_of?(Sinatra::NotFound)
+      return if !exception
       log "#{exception.class}: #{exception.message}\n" \
-          "#{exception.backtrace.join("\n")}"
+          "#{(exception.backtrace || []).join("\n")}"
     end
 
   end

data/lib/deas/respond_with_proxy.rb

@@ -0,0 +1,42 @@
+require 'deas/handler_proxy'
+require 'deas/url'
+require 'deas/view_handler'
+
+module Deas
+
+  class RespondWithProxy < HandlerProxy
+
+    attr_reader :handler_class_name, :handler_class
+
+    def initialize(halt_args)
+      @handler_class = Class.new do
+        include Deas::ViewHandler
+
+        def self.halt_args; @halt_args; end
+        def self.halt_args=(value)
+          @halt_args = value
+        end
+
+        def self.name; 'Deas::RespondWithHandler'; end
+
+        attr_reader :halt_args
+
+        def init!
+          @halt_args = self.class.halt_args
+        end
+
+        def run!
+          halt *self.halt_args
+        end
+
+      end
+
+      @handler_class.halt_args = halt_args
+      @handler_class_name = @handler_class.name
+    end
+
+    def validate!; end
+
+  end
+
+end

data/lib/deas/router.rb

@@ -8,12 +8,12 @@ module Deas
 
     DEFAULT_REQUEST_TYPE_NAME = 'default'
 
-    attr_reader :request_types, :urls, :routes
+    attr_reader :request_types, :urls, :routes, :definitions
     attr_reader :escape_query_value_proc
 
     def initialize(&block)
       @request_types = []
-      @urls, @routes = {}, []
+      @urls, @routes, @definitions = {}, [], []
       default_request_type_name(DEFAULT_REQUEST_TYPE_NAME)
       escape_query_value{ |v| Rack::Utils.escape(v) }
       self.instance_eval(&block) if !block.nil?
@@ -77,42 +77,90 @@ module Deas
     def delete(path, *args); self.route(:delete, path, *args); end
 
     def route(http_method, from_path, *args)
+      self.definitions.push([:route, [http_method, from_path, *args], nil])
+      true
+    end
+
+    def redirect(from_path, to_path = nil, &block)
+      self.definitions.push([:redirect, [from_path, to_path], block])
+      true
+    end
+
+    def not_found(from_path, body = nil)
+      respond_with_args = [404, {}, body || 'Not Found']
+      self.definitions.push([:respond_with, [from_path, respond_with_args], nil])
+    end
+
+    def apply_definitions!
+      self.definitions.each do |(type, args, block)|
+        self.send("apply_#{type}", *args, &block)
+      end
+      self.definitions.clear
+      true
+    end
+
+    def validate!
+      self.apply_definitions!
+      self.routes.each(&:validate!)
+      true
+    end
+
+    private
+
+    def apply_route(http_method, from_path, *args)
       handler_names        = args.last.kind_of?(::Hash) ? args.pop : {}
       default_handler_name = args.last
       if !handler_names.key?(self.default_request_type_name) && default_handler_name
         handler_names[self.default_request_type_name] = default_handler_name
       end
 
+      from_url = self.urls[from_path]
+      if from_path.kind_of?(::Symbol) && from_url.nil?
+        raise ArgumentError, "no url named `#{from_path.inspect}`"
+      end
+      from_url_path = from_url.path if from_url
+
       require 'deas/route_proxy'
       proxies = handler_names.inject({}) do |proxies, (req_type_name, handler_name)|
         proxies[req_type_name] = Deas::RouteProxy.new(handler_name, self.view_handler_ns)
         proxies
       end
 
-      from_url = self.urls[from_path]
-      from_url_path = from_url.path if from_url
-
       add_route(http_method, prepend_base_url(from_url_path || from_path), proxies)
     end
 
-    def redirect(from_path, to_path = nil, &block)
+    def apply_redirect(from_path, to_path = nil, &block)
       to_url = self.urls[to_path]
       if to_path.kind_of?(::Symbol) && to_url.nil?
         raise ArgumentError, "no url named `#{to_path.inspect}`"
       end
+      from_url = self.urls[from_path]
+      if from_path.kind_of?(::Symbol) && from_url.nil?
+        raise ArgumentError, "no url named `#{from_path.inspect}`"
+      end
+      from_url_path = from_url.path if from_url
 
       require 'deas/redirect_proxy'
       proxy = Deas::RedirectProxy.new(self, to_url || to_path, &block)
       proxies = { self.default_request_type_name => proxy }
 
+      add_route(:get, prepend_base_url(from_url_path || from_path), proxies)
+    end
+
+    def apply_respond_with(from_path, respond_with_args)
       from_url = self.urls[from_path]
+      if from_path.kind_of?(::Symbol) && from_url.nil?
+        raise ArgumentError, "no url named `#{from_path.inspect}`"
+      end
       from_url_path = from_url.path if from_url
 
+      require 'deas/respond_with_proxy'
+      proxy = Deas::RespondWithProxy.new(respond_with_args)
+      proxies = { self.default_request_type_name => proxy }
+
       add_route(:get, prepend_base_url(from_url_path || from_path), proxies)
     end
 
-    private
-
     def add_url(name, path, options)
       options[:escape_query_value] ||= self.escape_query_value_proc
       self.urls[name] = Deas::Url.new(name, path, {

data/lib/deas/server.rb

@@ -224,8 +224,8 @@ module Deas
         self.init_procs.each{ |p| p.call }
         raise Deas::ServerRootError if self.root.nil?
 
-        # validate the routes
-        self.routes.each(&:validate!)
+        # validate the router
+        self.router.validate!
 
         # append the show exceptions and logging middlewares last.  This ensures
         # that the logging and exception showing happens just before the app gets

data/lib/deas/show_exceptions.rb

@@ -23,7 +23,7 @@ module Deas
     # The real Rack call interface.
     def call!(env)
       status, headers, body = @app.call(env)
-      if error = env['sinatra.error']
+      if error = env['deas.error']
         error_body = Body.new(error)
 
         headers['Content-Length'] = error_body.size.to_s
@@ -37,7 +37,7 @@ module Deas
       attr_reader :content, :size, :mime_type
 
       def initialize(e)
-        @content   = "#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"
+        @content   = "#{e.class}: #{e.message}\n#{(e.backtrace || []).join("\n")}"
         @size      = Rack::Utils.bytesize(@content)
         @mime_type = "text/plain"
       end

data/lib/deas/sinatra_app.rb

@@ -1,5 +1,6 @@
 require 'sinatra/base'
 require 'deas/error_handler'
+require 'deas/exceptions'
 require 'deas/server_data'
 
 module Deas
@@ -55,28 +56,40 @@ module Deas
         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'], {
-            :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'],
-          })
+          if env['sinatra.error']
+            env['deas.error'] = if env['sinatra.error'].instance_of?(::Sinatra::NotFound)
+              Deas::NotFound.new(env['PATH_INFO']).tap do |e|
+                e.set_backtrace(env['sinatra.error'].backtrace)
+              end
+            else
+              env['sinatra.error']
+            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
-          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'],
-          })
+          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'],
+            })
+          end
         end
 
       end

data/lib/deas/version.rb

@@ -1,3 +1,3 @@
 module Deas
-  VERSION = "0.37.1"
+  VERSION = "0.38.0"
 end

data/test/support/factory.rb

@@ -13,6 +13,7 @@ module Factory
     message ||= Factory.text
     exception = nil
     begin; raise(klass, message); rescue klass => exception; end
+    exception.set_backtrace(nil) if Factory.boolean
     exception
   end
 

data/test/support/routes.rb

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

data/test/system/rack_tests.rb

@@ -155,7 +155,7 @@ module Deas
 
       assert_equal 404, last_response.status
       assert_equal "text/plain", last_response.headers['Content-Type']
-      assert_match "Sinatra::NotFound: Sinatra::NotFound", last_response.body
+      assert_match "Deas::NotFound: /not_defined", last_response.body
     end
 
     should "return a text/plain body when an exception occurs" do

data/test/unit/exceptions_tests.rb

@@ -41,6 +41,11 @@ module Deas
       assert_kind_of Deas::Error, Deas::HandlerProxyNotFound.new
     end
 
+    should "provide a generic not found exception" do
+      assert Deas::NotFound
+      assert_kind_of Deas::Error, Deas::NotFound.new
+    end
+
   end
 
 end

data/test/unit/logging_tests.rb

@@ -85,18 +85,15 @@ module Deas::Logging
       assert_equal exp, @env['deas.time_taken']
     end
 
-    should "log a sinatra.error env key if it exists" do
-      @env.delete('sinatra.error')
+    should "log a deas.error env key if it exists" do
+      @env.delete('deas.error')
       subject.call(@env)
       assert_empty @logger.info_logged
 
-      @env['sinatra.error'] = Factory.exception(Sinatra::NotFound)
+      @env['deas.error'] = error = Factory.exception
       subject.call(@env)
-      assert_empty @logger.info_logged
-
-      @env['sinatra.error'] = error = Factory.exception
-      subject.call(@env)
-      exp = "[Deas] #{error.class}: #{error.message}\n#{error.backtrace.join("\n")}"
+      exp = "[Deas] #{error.class}: #{error.message}\n" \
+            "#{(error.backtrace || []).join("\n")}"
       assert_includes exp, @logger.info_logged
     end
 

data/test/unit/respond_with_proxy_tests.rb

@@ -0,0 +1,87 @@
+require 'assert'
+require 'deas/respond_with_proxy'
+
+require 'deas/handler_proxy'
+require 'deas/test_helpers'
+require 'deas/url'
+require 'deas/view_handler'
+
+class Deas::RespondWithProxy
+
+  class UnitTests < Assert::Context
+    desc "Deas::RespondWithProxy"
+    setup do
+      @status  = Factory.integer
+      @headers = { Factory.string => Factory.string }
+      @body    = Factory.string
+      @proxy    = Deas::RespondWithProxy.new([@status, @headers, @body])
+    end
+    subject{ @proxy }
+
+    should "be a HandlerProxy" do
+      assert_kind_of Deas::HandlerProxy, subject
+    end
+
+  end
+
+  class HandlerClassTests < UnitTests
+    include Deas::TestHelpers
+
+    desc "handler class"
+    setup do
+      @handler_class = @proxy.handler_class
+    end
+    subject{ @handler_class }
+
+    should have_accessor :halt_args
+    should have_imeth :name
+
+    should "be a view handler" do
+      subject.included_modules.tap do |modules|
+        assert_includes Deas::ViewHandler, modules
+      end
+    end
+
+    should "store the args to halt with" do
+      assert_equal [@status, @headers, @body], subject.halt_args
+    end
+
+    should "know its name" do
+      assert_equal 'Deas::RespondWithHandler', subject.name
+    end
+
+  end
+
+  class HandlerTests < HandlerClassTests
+    desc "handler instance"
+    setup do
+      @handler = test_handler(@handler_class)
+    end
+    subject{ @handler }
+
+    should have_reader :halt_args
+
+    should "know its halt args" do
+      assert_equal [@status, @headers, @body], subject.halt_args
+    end
+
+  end
+
+  class RunTests < HandlerClassTests
+    desc "when run"
+    setup do
+      @runner   = test_runner(@handler_class)
+      @handler  = @runner.handler
+      @response = @runner.run
+    end
+    subject{ @response }
+
+    should "halt and respond with the halt args" do
+      assert_equal @status,  subject.status
+      assert_equal @headers, subject.headers
+      assert_equal @body,    subject.body
+    end
+
+  end
+
+end

data/test/unit/router_tests.rb

@@ -31,7 +31,7 @@ class Deas::Router
     end
     subject{ @router }
 
-    should have_readers :request_types, :urls, :routes
+    should have_readers :request_types, :urls, :routes, :definitions
     should have_readers :escape_query_value_proc
 
     should have_imeths :view_handler_ns, :escape_query_value
@@ -40,7 +40,8 @@ class Deas::Router
     should have_imeths :default_request_type_name, :add_request_type
     should have_imeths :request_type_name
     should have_imeths :get, :post, :put, :patch, :delete
-    should have_imeths :route, :redirect
+    should have_imeths :route, :redirect, :not_found
+    should have_imeths :apply_definitions!, :validate!
 
     should "default its settings" do
       router = @router_class.new
@@ -49,6 +50,7 @@ class Deas::Router
       assert_empty router.request_types
       assert_empty router.urls
       assert_empty router.routes
+      assert_empty router.definitions
 
       exp = @router_class::DEFAULT_REQUEST_TYPE_NAME
       assert_equal exp, router.default_request_type_name
@@ -58,6 +60,15 @@ class Deas::Router
       assert_equal exp, router.escape_query_value_proc.call(value)
     end
 
+    should "instance eval any given block" do
+      ns = Factory.string
+      router = Deas::Router.new do
+        view_handler_ns ns
+      end
+
+      assert_equal ns, router.view_handler_ns
+    end
+
     should "set a view handler namespace" do
       subject.view_handler_ns(exp = Factory.string)
       assert_equal exp, subject.view_handler_ns
@@ -71,6 +82,100 @@ class Deas::Router
       assert_raises(ArgumentError){ subject.escape_query_value }
     end
 
+    should "add get, post, put, patch and delete route definitions" do
+      path = Factory.path
+      args = [Factory.string]
+
+      [:get, :post, :put, :patch, :delete].each do |meth|
+        subject.send(meth, path, *args)
+        d = DefinitionSpy.new(*subject.definitions.last)
+        assert_equal :route,              d.type
+        assert_equal [meth, path, *args], d.args
+        assert_equal nil,                 d.block
+      end
+    end
+
+    should "add redirect definitions" do
+      from_path = Factory.path
+      to_path   = Factory.path
+      block     = proc{}
+
+      subject.redirect(from_path, to_path, &block)
+      d = DefinitionSpy.new(*subject.definitions.last)
+      assert_equal :redirect,            d.type
+      assert_equal [from_path, to_path], d.args
+      assert_equal block,                d.block
+
+      subject.redirect(from_path, to_path)
+      d = DefinitionSpy.new(*subject.definitions.last)
+      assert_equal :redirect,            d.type
+      assert_equal [from_path, to_path], d.args
+      assert_equal nil,                  d.block
+
+      subject.redirect(from_path)
+      d = DefinitionSpy.new(*subject.definitions.last)
+      assert_equal :redirect,        d.type
+      assert_equal [from_path, nil], d.args
+      assert_equal nil,              d.block
+    end
+
+    should "add not found definitions" do
+      from_path = Factory.path
+      body      = Factory.string
+
+      subject.not_found(from_path, body)
+
+      args = [404, {}, body]
+      d = DefinitionSpy.new(*subject.definitions.last)
+      assert_equal :respond_with,     d.type
+      assert_equal [from_path, args], d.args
+      assert_equal nil,               d.block
+    end
+
+    should "add a route for every definition when applying defintions" do
+      subject.set_base_url(nil)
+
+      path1 = Factory.path
+      path2 = Factory.path
+      subject.get(path1)
+      subject.redirect(path1, path2)
+      subject.not_found(path1)
+
+      assert_not_empty subject.definitions
+      assert_empty     subject.routes
+
+      subject.apply_definitions!
+      assert_equal 3, subject.routes.size
+      assert_empty subject.definitions
+
+      get = subject.routes[0]
+      assert_equal path1, get.path
+
+      redir = subject.routes[1]
+      assert_equal path1, redir.path
+
+      nf = subject.routes[2]
+      assert_equal path1, nf.path
+    end
+
+    should "apply definitions and validate each route when validating" do
+      subject.get('/something', 'EmptyViewHandler')
+      subject.apply_definitions!
+      route = subject.routes.last
+      proxy = route.handler_proxies[subject.default_request_type_name]
+
+      apply_def_called = false
+      Assert.stub(subject, :apply_definitions!){ apply_def_called = true }
+
+      assert_false apply_def_called
+      assert_nil proxy.handler_class
+
+      subject.validate!
+
+      assert_true apply_def_called
+      assert_equal EmptyViewHandler, proxy.handler_class
+    end
+
     should "set a base url" do
       subject.base_url(exp = Factory.url)
       assert_equal exp, subject.base_url
@@ -97,7 +202,8 @@ class Deas::Router
       url = Factory.url
       subject.base_url url
       path = Factory.path
-      route = subject.get(path, Object)
+      subject.get(path); subject.apply_definitions!
+      route = subject.routes.last
 
       exp_path = subject.prepend_base_url(path)
       assert_equal exp_path, route.path
@@ -108,7 +214,8 @@ class Deas::Router
       subject.base_url url
       path1 = Factory.path
       path2 = Factory.path
-      redirect = subject.redirect(path1, path2)
+      subject.redirect(path1, path2); subject.apply_definitions!
+      redirect = subject.routes.last
 
       exp = subject.prepend_base_url(path1)
       assert_equal exp, redirect.path
@@ -119,6 +226,17 @@ class Deas::Router
       assert_equal exp, handler.redirect_path
     end
 
+    should "prepend the base url when adding not founds" do
+      url = Factory.url
+      subject.base_url url
+      path = Factory.path
+      subject.not_found(path); subject.apply_definitions!
+      route = subject.routes.last
+
+      exp_path = subject.prepend_base_url(path)
+      assert_equal exp_path, route.path
+    end
+
     should "set a default request type name" do
       subject.default_request_type_name(exp = Factory.string)
       assert_equal exp, subject.default_request_type_name
@@ -150,28 +268,6 @@ class Deas::Router
       assert_equal exp, subject.request_type_name(Factory.string)
     end
 
-    should "add get, post, put, patch and delete routes" do
-      Assert.stub(subject, :route){ |*args| RouteSpy.new(*args) }
-      path = Factory.path
-      args = [Factory.string]
-
-      [:get, :post, :put, :patch, :delete].each do |meth|
-        route = subject.send(meth, path, *args)
-        assert_equal meth, route.method
-        assert_equal path, route.path
-        assert_equal args, route.args
-      end
-    end
-
-    should "instance eval any given block" do
-      ns = Factory.string
-      router = Deas::Router.new do
-        view_handler_ns ns
-      end
-
-      assert_equal ns, router.view_handler_ns
-    end
-
   end
 
   class RouteTests < InitTests
@@ -186,7 +282,7 @@ class Deas::Router
     should "add a Route with the given method and path" do
       assert_empty subject.routes
 
-      subject.route(@method, @path1)
+      subject.route(@method, @path1); subject.apply_definitions!
       assert_not_empty subject.routes
 
       route = subject.routes.last
@@ -201,7 +297,7 @@ class Deas::Router
     end
 
     should "proxy any handler class given for the default request type" do
-      subject.route(@method, @path1, @handler_class_name1)
+      subject.route(@method, @path1, @handler_class_name1); subject.apply_definitions!
       route = subject.routes.last
       proxy = route.handler_proxies[subject.default_request_type_name]
       assert_kind_of Deas::RouteProxy, proxy
@@ -209,7 +305,7 @@ class Deas::Router
 
       subject.route(@method, @path1, @handler_class_name1, {
         subject.default_request_type_name => @handler_class_name2
-      })
+      }); subject.apply_definitions!
       route = subject.routes.last
       proxy = route.handler_proxies[subject.default_request_type_name]
       assert_kind_of Deas::RouteProxy, proxy
@@ -221,7 +317,7 @@ class Deas::Router
       subject.route(@method, @path1, {
         '1' => @handler_class_name1,
         '2' => @handler_class_name2,
-      })
+      }); subject.apply_definitions!
       route = subject.routes.last
 
       proxy = route.handler_proxies['1']
@@ -234,7 +330,7 @@ class Deas::Router
     end
 
     should "add redirect routes" do
-      subject.redirect(@path1, @path2)
+      subject.redirect(@path1, @path2); subject.apply_definitions!
 
       route = subject.routes.last
       assert_instance_of Deas::Route, route
@@ -250,6 +346,30 @@ class Deas::Router
       assert_equal exp, handler.redirect_path
     end
 
+    should "add not found routes" do
+      subject.not_found(@path1); subject.apply_definitions!
+
+      route = subject.routes.last
+      assert_instance_of Deas::Route, route
+      assert_equal :get, route.method
+      assert_equal subject.prepend_base_url(@path1), route.path
+
+      proxy = route.handler_proxies[subject.default_request_type_name]
+      assert_kind_of Deas::RespondWithProxy, proxy
+      assert_equal 'Deas::RespondWithHandler', proxy.handler_class_name
+
+      handler = test_handler(proxy.handler_class)
+      assert_equal [404, {}, 'Not Found'], handler.halt_args
+
+      body = Factory.string
+      subject.not_found(@path1, body); subject.apply_definitions!
+
+      route   = subject.routes.last
+      proxy   = route.handler_proxies[subject.default_request_type_name]
+      handler = test_handler(proxy.handler_class)
+      assert_equal [404, {}, body], handler.halt_args
+    end
+
   end
 
   class NamedUrlTests < InitTests
@@ -300,14 +420,37 @@ class Deas::Router
       end
     end
 
-    should "complain if redirecting to a named url that hasn't been defined" do
+    should "complain if routing a named url that hasn't been defined" do
+      assert_raises ArgumentError do
+        subject.route(:get, :not_defined_url, 'GetInfo')
+        subject.apply_definitions!
+      end
+    end
+
+    should "route using a url name instead of a path" do
+      subject.route(:get, :get_info, 'GetInfo'); subject.apply_definitions!
+
+      url   = subject.urls[:get_info]
+      route = subject.routes.last
+
+      exp = subject.prepend_base_url(url.path)
+      assert_equal exp, route.path
+    end
+
+    should "complain if redirecting to/from a named url that hasn't been defined" do
       assert_raises ArgumentError do
         subject.redirect('/somewhere', :not_defined_url)
+        subject.apply_definitions!
+      end
+      assert_raises ArgumentError do
+        subject.redirect(:not_defined_url, '/somewhere')
+        subject.apply_definitions!
       end
     end
 
     should "redirect using a url name instead of a path" do
-      subject.redirect(:get_info, '/somewhere')
+      subject.redirect(:get_info, '/somewhere'); subject.apply_definitions!
+
       url   = subject.urls[:get_info]
       route = subject.routes.last
 
@@ -315,8 +458,16 @@ class Deas::Router
       assert_equal exp, route.path
     end
 
-    should "route using a url name instead of a path" do
-      subject.route(:get, :get_info, 'GetInfo')
+    should "complain if adding a not found with a named url that hasn't been defined" do
+      assert_raises ArgumentError do
+        subject.not_found(:not_defined_url)
+        subject.apply_definitions!
+      end
+    end
+
+    should "add a not found using a url name instead of a path" do
+      subject.not_found(:get_info); subject.apply_definitions!
+
       url   = subject.urls[:get_info]
       route = subject.routes.last
 
@@ -390,9 +541,5 @@ class Deas::Router
 
   end
 
-  class RouteSpy < Struct.new(:method, :path, :args)
-    def initialize(method, path, *args)
-      super(method, path, args)
-    end
-  end
+  DefinitionSpy = Struct.new(:type, :args, :block)
 end

data/test/unit/server_tests.rb

@@ -207,8 +207,9 @@ module Deas::Server
       @initialized = false
       @other_initialized = false
       @router = Deas::Router.new
-      @route = @router.get('/something', 'EmptyViewHandler')
-      @proxy = @route.handler_proxies[@router.default_request_type_name]
+
+      @router_validate_called = false
+      Assert.stub(@router, :validate!){ @router_validate_called = true }
 
       @configuration = Configuration.new.tap do |c|
         c.env              = 'staging'
@@ -236,11 +237,11 @@ module Deas::Server
       assert_equal true, @other_initialized
     end
 
-    should "call validate! on all routes" do
-      assert_nil @proxy.handler_class
+    should "call validate! on the router" do
+      assert_false @router_validate_called
 
       subject.validate!
-      assert_equal EmptyViewHandler, @proxy.handler_class
+      assert_true @router_validate_called
     end
 
     should "add the Logging and ShowExceptions middleware to the end" do

data/test/unit/show_exceptions_tests.rb

@@ -18,7 +18,7 @@ class Deas::ShowExceptions
     desc "when init"
     setup do
       @app = Factory.sinatra_call
-      @env = { 'sinatra.error' => Factory.exception }
+      @env = { 'deas.error' => Factory.exception }
       @middleware = @middleware_class.new(@app)
     end
     subject{ @middleware }
@@ -27,7 +27,7 @@ class Deas::ShowExceptions
 
     should "return a response for the exception when called" do
       status, headers, body = subject.call(@env)
-      error_body = Body.new(@env['sinatra.error'])
+      error_body = Body.new(@env['deas.error'])
 
       assert_equal @app.response.status, status
       assert_equal error_body.size.to_s, headers['Content-Length']
@@ -36,7 +36,7 @@ class Deas::ShowExceptions
     end
 
     should "return the apps response if there isn't an exception" do
-      @env.delete('sinatra.error')
+      @env.delete('deas.error')
       status, headers, body = subject.call(@env)
 
       assert_equal @app.response.status,  status
@@ -58,7 +58,7 @@ class Deas::ShowExceptions
 
     should "know its attributes" do
       exp_content = "#{@exception.class}: #{@exception.message}\n" \
-                "#{@exception.backtrace.join("\n")}"
+                    "#{(@exception.backtrace || []).join("\n")}"
       assert_equal exp_content, subject.content
       assert_equal Rack::Utils.bytesize(exp_content), subject.size
       assert_equal "text/plain", subject.mime_type

data/test/unit/sinatra_app_tests.rb

@@ -16,8 +16,8 @@ module Deas::SinatraApp
     desc "Deas::SinatraApp"
     setup do
       @router = Deas::Router.new
-      @route = @router.get('/something', 'EmptyViewHandler')
-      @proxy = @route.handler_proxies[@router.default_request_type_name]
+      @router.get('/something', 'EmptyViewHandler')
+      @router.validate!
 
       @configuration = Deas::Server::Configuration.new.tap do |c|
         c.env              = 'staging'
@@ -74,10 +74,10 @@ module Deas::SinatraApp
     end
 
     should "define Sinatra routes for every route in the configuration" do
-      get_routes = subject.routes[@route.method.to_s.upcase] || []
-      sinatra_route = get_routes.detect{ |route| route[0].match(@route.path) }
+      router_route   = @router.routes.last
+      sinatra_routes = subject.routes[router_route.method.to_s.upcase] || []
 
-      assert_not_nil sinatra_route
+      assert_not_nil sinatra_routes.detect{ |r| r[0].match(router_route.path) }
     end
 
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: deas
 version: !ruby/object:Gem::Version 
-  hash: 137
+  hash: 135
   prerelease: 
   segments: 
   - 0
-  - 37
-  - 1
-  version: 0.37.1
+  - 38
+  - 0
+  version: 0.38.0
 platform: ruby
 authors: 
 - Kelly Redding
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2015-10-07 00:00:00 Z
+date: 2015-10-21 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   requirement: &id001 !ruby/object:Gem::Requirement 
@@ -126,6 +126,7 @@ files:
 - lib/deas/logging.rb
 - lib/deas/rack_request_fix.rb
 - lib/deas/redirect_proxy.rb
+- lib/deas/respond_with_proxy.rb
 - lib/deas/route.rb
 - lib/deas/route_proxy.rb
 - lib/deas/router.rb
@@ -161,6 +162,7 @@ files:
 - test/unit/handler_proxy_tests.rb
 - test/unit/logging_tests.rb
 - test/unit/redirect_proxy_tests.rb
+- test/unit/respond_with_proxy_tests.rb
 - test/unit/route_proxy_tests.rb
 - test/unit/route_tests.rb
 - test/unit/router_tests.rb
@@ -206,7 +208,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 1.8.29
 signing_key: 
 specification_version: 3
 summary: Handler-based web framework powered by Sinatra
@@ -229,6 +231,7 @@ test_files:
 - test/unit/handler_proxy_tests.rb
 - test/unit/logging_tests.rb
 - test/unit/redirect_proxy_tests.rb
+- test/unit/respond_with_proxy_tests.rb
 - test/unit/route_proxy_tests.rb
 - test/unit/route_tests.rb
 - test/unit/router_tests.rb