deas 0.31.0 → 0.32.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2e01bef9b6af4303f73139d7163cffe10e365422
+  data.tar.gz: 72a8a94d809478d18b0977d6f08db810a4801547
+SHA512:
+  metadata.gz: d911b586a2a5550d68b1213da0928c9660bded2411454543f838d5aa882652412d7bc3717c526fd9b53349c5250ce37c66c0feffb5105e8c65ea7382bb0ebf9a
+  data.tar.gz: 29061f4db02882144065819d5f86c720cf9859eb100972f88c070ce23c90257b65bf8f52a0cc6c973f3c94b2a6c7746656aa20613916d2be4a2049526ce321da

data/Gemfile

@@ -2,6 +2,6 @@ source "https://rubygems.org"
 
 gemspec
 
-gem 'rake'
+gem 'rake', "~> 10.4.0"
 gem 'pry', "~> 0.9.0"
 gem 'rack-test'

data/lib/deas/exceptions.rb

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

data/lib/deas/handler_proxy.rb

@@ -0,0 +1,41 @@
+require 'deas/exceptions'
+require 'deas/sinatra_runner'
+
+module Deas
+
+  class HandlerProxy
+
+    attr_reader :handler_class_name, :handler_class
+
+    def initialize(handler_class_name)
+      @handler_class_name = handler_class_name
+    end
+
+    def validate!
+      raise NotImplementedError
+    end
+
+    def run(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.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}"
+      end
+      runner.run
+    end
+
+  end
+
+end

data/lib/deas/redirect_proxy.rb

@@ -1,9 +1,10 @@
+require 'deas/handler_proxy'
 require 'deas/url'
 require 'deas/view_handler'
 
 module Deas
 
-  class RedirectProxy
+  class RedirectProxy < HandlerProxy
 
     attr_reader :handler_class_name, :handler_class
 

data/lib/deas/route.rb

@@ -1,39 +1,29 @@
-require 'deas/sinatra_runner'
+require 'deas/exceptions'
 
 module Deas
 
   class Route
 
-    attr_reader :method, :path, :route_proxy, :handler_class
+    attr_reader :method, :path, :handler_proxies
 
-    def initialize(method, path, route_proxy)
-      @method, @path, @route_proxy = method, path, route_proxy
+    def initialize(method, path, handler_proxies)
+      @method, @path, @handler_proxies = method, path, handler_proxies
     end
 
     def validate!
-      @route_proxy.validate!
-      @handler_class = @route_proxy.handler_class
+      @handler_proxies.each do |request_type_name, proxy|
+        proxy.validate!
+      end
     end
 
     def run(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.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}"
+      type = sinatra_call.settings.router.request_type_name(sinatra_call.request)
+      proxy = begin
+        @handler_proxies[type]
+      rescue HandlerProxyNotFound
+        sinatra_call.halt(404)
       end
-      runner.run
+      proxy.run(sinatra_call)
     end
 
   end

data/lib/deas/route_proxy.rb

@@ -1,18 +1,22 @@
 require 'deas/exceptions'
-require 'deas/view_handler'
+require 'deas/handler_proxy'
 
 module Deas
-  class RouteProxy
 
-    attr_reader :handler_class_name, :handler_class
+  class RouteProxy < HandlerProxy
 
-    def initialize(handler_class_name)
-      @handler_class_name = handler_class_name
+    def initialize(handler_class_name, view_handler_ns = nil)
+      raise(NoHandlerClassError.new(handler_class_name)) if handler_class_name.nil?
+
+      if view_handler_ns && !(handler_class_name =~ /^::/)
+        handler_class_name = "#{view_handler_ns}::#{handler_class_name}"
+      end
+      super(handler_class_name)
     end
 
     def validate!
-      @handler_class = constantize(@handler_class_name).tap do |handler_class|
-        raise(NoHandlerClassError.new(@handler_class_name)) if !handler_class
+      @handler_class = constantize(self.handler_class_name).tap do |handler_class|
+        raise(NoHandlerClassError.new(self.handler_class_name)) if !handler_class
       end
     end
 
@@ -27,4 +31,5 @@ module Deas
     end
 
   end
+
 end

data/lib/deas/router.rb

@@ -1,15 +1,21 @@
+require 'deas/exceptions'
 require 'deas/redirect_proxy'
 require 'deas/route'
 require 'deas/route_proxy'
 require 'deas/url'
 
 module Deas
+
   class Router
 
-    attr_accessor :urls, :routes
+    DEFAULT_REQUEST_TYPE_NAME = 'default'
+
+    attr_reader :request_types, :urls, :routes
 
     def initialize(&block)
+      @request_types = []
       @urls, @routes = {}, []
+      default_request_type_name(DEFAULT_REQUEST_TYPE_NAME)
       self.instance_eval(&block) if !block.nil?
     end
 
@@ -41,21 +47,42 @@ module Deas
       prepend_base_url(url.path_for(*args))
     end
 
-    def get(path, handler_name);    self.route(:get,    path, handler_name); end
-    def post(path, handler_name);   self.route(:post,   path, handler_name); end
-    def put(path, handler_name);    self.route(:put,    path, handler_name); end
-    def patch(path, handler_name);  self.route(:patch,  path, handler_name); end
-    def delete(path, handler_name); self.route(:delete, path, handler_name); end
+    def default_request_type_name(value = nil)
+      @default_request_type = RequestType.new(value) if !value.nil?
+      @default_request_type.name
+    end
+
+    def add_request_type(name, &proc)
+      @request_types << RequestType.new(name, proc)
+    end
+
+    # ideally someday the request should just *know* its request type
+    def request_type_name(request)
+      (self.request_types.detect{ |rt| rt.proc.call(request) } || @default_request_type).name
+    end
 
-    def route(http_method, from_path, handler_class_name)
-      if self.view_handler_ns && !(handler_class_name =~ /^::/)
-        handler_class_name = "#{self.view_handler_ns}::#{handler_class_name}"
+    def get(path, *args);    self.route(:get,    path, *args); end
+    def post(path, *args);   self.route(:post,   path, *args); end
+    def put(path, *args);    self.route(:put,    path, *args); end
+    def patch(path, *args);  self.route(:patch,  path, *args); end
+    def delete(path, *args); self.route(:delete, path, *args); end
+
+    def 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
+
+      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
-      proxy = Deas::RouteProxy.new(handler_class_name)
 
       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), proxy)
+
+      add_route(http_method, prepend_base_url(from_url_path || from_path), proxies)
     end
 
     def redirect(from_path, to_path = nil, &block)
@@ -63,11 +90,14 @@ module Deas
       if to_path.kind_of?(::Symbol) && to_url.nil?
         raise ArgumentError, "no url named `#{to_path.inspect}`"
       end
+
       proxy = Deas::RedirectProxy.new(to_url || to_path, &block)
+      proxies = { self.default_request_type_name => proxy }
 
       from_url = self.urls[from_path]
       from_url_path = from_url.path if from_url
-      add_route(:get, from_url_path || from_path, proxy)
+
+      add_route(:get, prepend_base_url(from_url_path || from_path), proxies)
     end
 
     private
@@ -76,10 +106,36 @@ module Deas
       self.urls[name] = Deas::Url.new(name, path)
     end
 
-    def add_route(http_method, path, proxy)
-      Deas::Route.new(http_method, path, proxy).tap{ |r| self.routes.push(r) }
+    def add_route(http_method, path, proxies)
+      proxies = HandlerProxies.new(proxies, self.default_request_type_name)
+      Deas::Route.new(http_method, path, proxies).tap{ |r| self.routes.push(r) }
     end
 
+    class HandlerProxies
+
+      attr_reader :default_type
+
+      def initialize(proxies, default_name)
+        @proxies = proxies
+        @default_type = default_name
+      end
+
+      def [](type)
+        @proxies[type] || @proxies[@default_type] || raise(HandlerProxyNotFound)
+      end
+
+      def each(&block)
+        @proxies.each(&block)
+      end
+
+      def empty?
+        @proxies.empty?
+      end
+
+    end
+
+    RequestType = Struct.new(:name, :proc)
+
   end
 
 end

data/lib/deas/server.rb

@@ -211,6 +211,10 @@ module Deas::Server
     def url(*args, &block);     self.router.url(*args, &block);     end
     def url_for(*args, &block); self.router.url_for(*args, &block); 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 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

data/lib/deas/version.rb

@@ -1,3 +1,3 @@
 module Deas
-  VERSION = "0.31.0"
+  VERSION = "0.32.0"
 end

data/test/support/routes.rb

@@ -19,6 +19,10 @@ class DeasTestServer
     end
   end
 
+  default_request_type_name 'desktop'
+  add_request_type('regular'){ |r| r.path_info =~ /regular/ }
+  add_request_type('mobile'){ |r| r.path_info =~ /mobile/ }
+
   get  '/show',              'ShowHandler'
   get  '/show.html',         'ShowHtmlHandler'
   get  '/show.json',         'ShowJsonHandler'
@@ -26,6 +30,9 @@ class DeasTestServer
   get  '/show-text',         'ShowTextHandler'
   get  '/show-headers-text', 'ShowHeadersTextHandler'
 
+  get '/req-type-show/:type', 'regular' => 'ShowHandler',
+                              'mobile'  => 'ShowMobileHandler'
+
   get  '/halt',     'HaltHandler'
   get  '/error',    'ErrorHandler'
   get  '/redirect', 'RedirectHandler'
@@ -71,6 +78,21 @@ class ShowHandler
 
 end
 
+class ShowMobileHandler
+  include Deas::ViewHandler
+
+  attr_reader :message
+
+  def init!
+    @message = "[MOBILE] #{params['message']}"
+  end
+
+  def run!
+    @message
+  end
+
+end
+
 class ShowHtmlHandler
   include Deas::ViewHandler
 

data/test/system/rack_tests.rb

@@ -1,7 +1,8 @@
 require 'assert'
-require 'assert-rack-test'
 require 'deas'
 
+require 'assert-rack-test'
+
 module Deas
 
   class RackTestsContext < Assert::Context
@@ -20,8 +21,7 @@ module Deas
       get '/show', 'message' => 'this is a test'
 
       assert_equal 200, last_response.status
-      exp = "this is a test"
-      assert_equal exp, last_response.body
+      assert_equal "this is a test", last_response.body
     end
 
     should "set the content type appropriately" do
@@ -44,6 +44,19 @@ module Deas
       assert_equal 'text/plain', last_response.headers['Content-Type']
     end
 
+    should "render different handlers for the same meth/path based on the type" do
+      get '/req-type-show/regular', 'message' => 'this is a test request'
+      assert_equal 200, last_response.status
+      assert_equal "this is a test request", last_response.body
+
+      get '/req-type-show/mobile', 'message' => 'this is a test request'
+      assert_equal 200, last_response.status
+      assert_equal "[MOBILE] this is a test request", last_response.body
+
+      get '/req-type-show/other', 'message' => 'this is a test request'
+      assert_equal 404, last_response.status
+    end
+
     should "allow halting with a custom response" do
       get '/halt', 'with' => 234
 
@@ -115,7 +128,6 @@ module Deas
     desc "handler"
     setup do
       get 'handler/tests?a-param=something'
-
       @data_inspect = last_response.body
     end
 

data/test/unit/exceptions_tests.rb

@@ -11,7 +11,7 @@ module Deas
       assert_kind_of RuntimeError, Deas::Error.new
     end
 
-    should "provide a no handler class exception that subclasses `Error`" do
+    should "provide a no handler class exception" do
       assert Deas::NoHandlerClassError
 
       handler_class_name = 'AHandlerClass'
@@ -23,12 +23,12 @@ module Deas
       assert_equal exp_msg, e.message
     end
 
-    should "provide a server exception that subclasses `Error`" do
+    should "provide a server exception" do
       assert Deas::ServerError
       assert_kind_of Deas::Error, Deas::ServerError.new
     end
 
-    should "provide a server root exception that subclasses `ServerError`" do
+    should "provide a server root exception" do
       assert Deas::ServerRootError
 
       e = Deas::ServerRootError.new
@@ -36,6 +36,11 @@ module Deas
       assert_equal "server `root` not set but required", e.message
     end
 
+    should "provide a handler proxy not found exception" do
+      assert Deas::HandlerProxyNotFound
+      assert_kind_of Deas::Error, Deas::HandlerProxyNotFound.new
+    end
+
   end
 
 end

data/test/unit/handler_proxy_tests.rb

@@ -0,0 +1,115 @@
+require 'assert'
+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
+
+  class UnitTests < Assert::Context
+    desc "Deas::HandlerProxy"
+    setup do
+      @proxy = Deas::HandlerProxy.new('EmptyViewHandler')
+    end
+    subject{ @proxy }
+
+    should have_readers :handler_class_name, :handler_class
+    should have_imeths :validate!, :run
+
+    should "know its handler class name" do
+      assert_equal 'EmptyViewHandler', subject.handler_class_name
+    end
+
+    should "not implement its validate! method" do
+      assert_raises(NotImplementedError){ subject.validate! }
+    end
+
+  end
+
+  class RunTests < UnitTests
+    desc "when run"
+    setup do
+      @runner_spy = SinatraRunnerSpy.new
+      Assert.stub(Deas::SinatraRunner, :new) do |*args|
+        @runner_spy.build(*args)
+        @runner_spy
+      end
+
+      Assert.stub(@proxy, :handler_class){ EmptyViewHandler }
+
+      @fake_sinatra_call = FakeSinatraCall.new
+      @proxy.run(@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
+      }
+      assert_equal exp_args, @runner_spy.args
+
+      assert_true @runner_spy.run_called
+    end
+
+    should "add the runner params to the request env" do
+      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
+      exp_msgs = [
+        "  Handler: #{subject.handler_class}",
+        "  Params:  #{@runner_spy.params.inspect}"
+      ]
+      assert_equal exp_msgs, @fake_sinatra_call.request.logging_msgs
+    end
+
+  end
+
+  class SinatraRunnerSpy
+
+    attr_reader :run_called
+    attr_reader :handler_class, :args
+    attr_reader :sinatra_call
+    attr_reader :request, :response, :session, :params
+    attr_reader :logger, :router, :template_source
+
+    def initialize
+      @run_called = false
+    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]
+      @template_source = args[:template_source]
+    end
+
+    def run
+      @run_called = true
+    end
+
+  end
+
+end