deas 0.26.0 → 0.27.0

data/lib/deas/deas_runner.rb

@@ -0,0 +1,34 @@
+require 'deas/runner'
+
+module Deas
+
+  class DeasRunner < Runner
+
+    def initialize(handler_class, args = nil)
+      a = args || {}
+      runner_args = a.merge(:params => NormalizedParams.new(a[:params]).value)
+      super(handler_class, runner_args)
+    end
+
+    def run
+      run_callbacks self.handler_class.before_callbacks
+      self.handler.init
+      response_data = self.handler.run
+      run_callbacks self.handler_class.after_callbacks
+      response_data
+    end
+
+    private
+
+    def run_callbacks(callbacks)
+      callbacks.each{|proc| self.handler.instance_eval(&proc) }
+    end
+
+    class NormalizedParams < Deas::Runner::NormalizedParams
+      def file_type?(value)
+        value.kind_of?(::Tempfile)
+      end
+    end
+
+  end
+end

data/lib/deas/redirect_proxy.rb

@@ -2,6 +2,7 @@ require 'deas/view_handler'
 require 'deas/url'
 
 module Deas
+
   class RedirectProxy
 
     attr_reader :handler_class_name, :handler_class
@@ -39,5 +40,8 @@ module Deas
       @handler_class_name = @handler_class.name
     end
 
+    def validate!; end
+
   end
+
 end

data/lib/deas/route.rb

@@ -4,19 +4,29 @@ module Deas
 
   class Route
 
-    attr_reader :method, :path, :handler_proxy, :handler_class
+    attr_reader :method, :path, :route_proxy, :handler_class
 
-    def initialize(method, path, handler_proxy)
-      @method, @path, @handler_proxy = method, path, handler_proxy
+    def initialize(method, path, route_proxy)
+      @method, @path, @route_proxy = method, path, route_proxy
     end
 
     def validate!
-      @handler_class = @handler_proxy.handler_class
+      @route_proxy.validate!
+      @handler_class = @route_proxy.handler_class
     end
 
-    # TODO: unit test this??
     def run(sinatra_call)
-      runner = Deas::SinatraRunner.new(self.handler_class, sinatra_call)
+      args = {
+        :sinatra_call => sinatra_call,
+        :request      => sinatra_call.request,
+        :response     => sinatra_call.response,
+        :params       => sinatra_call.params,
+        :logger       => sinatra_call.settings.logger,
+        :router       => sinatra_call.settings.router,
+        :session      => sinatra_call.session
+      }
+      runner = Deas::SinatraRunner.new(self.handler_class, args)
+
       sinatra_call.request.env.tap do |env|
         env['deas.params'] = runner.params
         env['deas.handler_class_name'] = self.handler_class.name

data/lib/deas/route_proxy.rb

@@ -4,14 +4,14 @@ require 'deas/exceptions'
 module Deas
   class RouteProxy
 
-    attr_reader :handler_class_name
+    attr_reader :handler_class_name, :handler_class
 
     def initialize(handler_class_name)
       @handler_class_name = handler_class_name
     end
 
-    def handler_class
-      constantize(@handler_class_name).tap do |handler_class|
+    def validate!
+      @handler_class = constantize(@handler_class_name).tap do |handler_class|
         raise(NoHandlerClassError.new(@handler_class_name)) if !handler_class
       end
     end

data/lib/deas/runner.rb

@@ -1,4 +1,5 @@
 require 'rack/utils'
+require 'deas/router'
 
 module Deas
 
@@ -8,9 +9,17 @@ module Deas
     attr_reader :request, :response, :params
     attr_reader :logger, :router, :session
 
-    def initialize(handler_class)
+    def initialize(handler_class, args = nil)
       @handler_class = handler_class
       @handler = @handler_class.new(self)
+
+      a = args || {}
+      @request  = a[:request]
+      @response = a[:response]
+      @params   = a[:params] || {}
+      @logger   = a[:logger] || Deas::NullLogger.new
+      @router   = a[:router] || Deas::Router.new
+      @session  = a[:session]
     end
 
     def halt(*args);         raise NotImplementedError; end
@@ -19,7 +28,6 @@ module Deas
     def status(*args);       raise NotImplementedError; end
     def headers(*args);      raise NotImplementedError; end
     def render(*args);       raise NotImplementedError; end
-    def partial(*args);      raise NotImplementedError; end
     def send_file(*args);    raise NotImplementedError; end
 
     class NormalizedParams

data/lib/deas/sinatra_runner.rb

@@ -1,32 +1,13 @@
-require 'deas/runner'
+require 'deas/deas_runner'
 require 'deas/template'
 
 module Deas
 
-  class SinatraRunner < Runner
+  class SinatraRunner < DeasRunner
 
-    attr_reader :app_settings
-
-    def initialize(handler_class, sinatra_call)
-      @sinatra_call  = sinatra_call
-      @app_settings  = @sinatra_call.settings
-
-      @request  = @sinatra_call.request
-      @response = @sinatra_call.response
-      @params   = NormalizedParams.new(@sinatra_call.params).value
-      @logger   = @sinatra_call.settings.logger
-      @router   = @sinatra_call.settings.router
-      @session  = @sinatra_call.session
-
-      super(handler_class)
-    end
-
-    def run
-      run_callbacks @handler_class.before_callbacks
-      @handler.init
-      response_data = @handler.run
-      run_callbacks @handler_class.after_callbacks
-      response_data
+    def initialize(handler_class, args = nil)
+      @sinatra_call = (args || {})[:sinatra_call]
+      super(handler_class, args)
     end
 
     # Helpers
@@ -59,41 +40,30 @@ module Deas
       @sinatra_call.headers(*args)
     end
 
-    def render(template_name, options = nil, &block)
-      options ||= {}
+    def render(template_name, opts = nil, &block)
+      self.content_type(get_content_type(template_name)) if self.content_type.nil?
+
+      # TODO: move to DeasRunner, don't pass sinatra call to create template
+      # def render(template_name, *args, &block)
+      #   super(template_name, *args, &block)
+      options = opts || {}
       options[:locals] = {
-        :view => @handler,
-        :logger => @logger
+        :view => self.handler,
+        :logger => self.logger
       }.merge(options[:locals] || {})
-      options[:layout] ||= @handler_class.layouts
-
-      self.content_type(get_content_type(template_name)) if self.content_type.nil?
+      options[:layout] = self.handler_class.layouts if !options.key?(:layout)
       Deas::Template.new(@sinatra_call, template_name, options).render(&block)
     end
 
-    def partial(partial_name, locals = nil)
-      Deas::Template::Partial.new(@sinatra_call, partial_name, locals).render
-    end
-
     def send_file(*args, &block)
       @sinatra_call.send_file(*args, &block)
     end
 
     private
 
-    def run_callbacks(callbacks)
-      callbacks.each{|proc| @handler.instance_eval(&proc) }
-    end
-
     def get_content_type(template_name)
       File.extname(template_name)[1..-1] || 'html'
     end
 
-    class NormalizedParams < Deas::Runner::NormalizedParams
-      def file_type?(value)
-        value.kind_of?(::Tempfile)
-      end
-    end
-
   end
 end

data/lib/deas/template.rb

@@ -76,9 +76,9 @@ module Deas
 
       def initialize(sinatra_call, name, locals = nil)
         options = { :locals => (locals || {}) }
-        name = begin
-          basename = File.basename(name.to_s)
-          name.to_s.sub(/#{basename}\Z/, "_#{basename}")
+        name = name.to_s.tap do |n|
+          basename = File.basename(n)
+          n.sub!(/#{basename}\Z/, "_#{basename}") unless basename[0] == '_'[0]
         end
         super sinatra_call, name, options
       end

data/lib/deas/test_runner.rb

@@ -1,4 +1,3 @@
-require 'ostruct'
 require 'rack/multipart'
 require 'deas/router'
 require 'deas/runner'
@@ -7,27 +6,26 @@ module Deas
 
   class TestRunner < Runner
 
-    attr_reader :app_settings, :return_value
+    attr_reader :return_value
 
     def initialize(handler_class, args = nil)
       args = (args || {}).dup
-      @app_settings = OpenStruct.new(args.delete(:app_settings))
 
-      @request  = args.delete(:request)
-      @response = args.delete(:response)
-      @params   = NormalizedParams.new(args.delete(:params) || {}).value
-      @logger   = args.delete(:logger) || Deas::NullLogger.new
-      @router   = args.delete(:router) || Deas::Router.new
-      @session  = args.delete(:session)
-
-      super(handler_class)
-      args.each{|key, value| @handler.send("#{key}=", value) }
-
-      @return_value = catch(:halt){ @handler.init; nil }
+      super(handler_class, {
+        :request  => args.delete(:request),
+        :response => args.delete(:response),
+        :params   => NormalizedParams.new(args.delete(:params) || {}).value,
+        :logger   => args.delete(:logger),
+        :router   => args.delete(:router),
+        :session  => args.delete(:session)
+      })
+      args.each{|key, value| self.handler.send("#{key}=", value) }
+
+      @return_value = catch(:halt){ self.handler.init; nil }
     end
 
     def run
-      @return_value ||= catch(:halt){ @handler.run }
+      @return_value ||= catch(:halt){ self.handler.run }
     end
 
     # Helpers
@@ -74,11 +72,6 @@ module Deas
     end
     RenderArgs = Struct.new(:template_name, :options, :block)
 
-    def partial(partial_name, locals = nil)
-      PartialArgs.new(partial_name, locals)
-    end
-    PartialArgs = Struct.new(:partial_name, :locals)
-
     def send_file(file_path, options = nil, &block)
       SendFileArgs.new(file_path, options, block)
     end

data/lib/deas/version.rb

@@ -1,3 +1,3 @@
 module Deas
-  VERSION = "0.26.0"
+  VERSION = "0.27.0"
 end

data/lib/deas/view_handler.rb

@@ -54,10 +54,8 @@ module Deas
     def headers(*args);      @deas_runner.headers(*args);      end
 
     def render(*args, &block);    @deas_runner.render(*args, &block);    end
-    def partial(*args, &block);   @deas_runner.partial(*args, &block);   end
     def send_file(*args, &block); @deas_runner.send_file(*args, &block); end
 
-    def app_settings; @deas_runner.app_settings; end
     def logger;       @deas_runner.logger;       end
     def router;       @deas_runner.router;       end
     def request;      @deas_runner.request;      end

data/test/support/fake_sinatra_call.rb

@@ -1,18 +1,21 @@
-require 'deas'
 require 'ostruct'
+require 'deas'
+require 'deas/router'
 
 class FakeSinatraCall
 
   # Mimic's the context that is accessible in a Sinatra' route. Should provide
   # any methods needed to replace using an actual Sinatra app.
 
-  attr_accessor :request, :response, :params, :settings, :session, :logger
+  attr_accessor :request, :response, :params, :logger, :router, :session
+  attr_accessor :settings
 
   def initialize(settings={})
-    @request = FakeRequest.new('GET','/something', {}, OpenStruct.new)
+    @request  = FakeRequest.new('GET','/something', {}, OpenStruct.new)
     @response = FakeResponse.new
     @params   = @request.params
     @logger   = Deas::NullLogger.new
+    @router   = Deas::Router.new
     @session  = @request.session
 
     @settings = OpenStruct.new({
@@ -58,5 +61,16 @@ end
 
 class FakeRequest < Struct.new(:http_method, :path, :params, :session)
   alias :request_method :http_method
+
+  attr_reader :logging_msgs
+
+  def env
+    @env ||= {
+      'deas.logging' => Proc.new do |msg|
+        @logging_msgs ||= []
+        @logging_msgs.push(msg)
+      end
+    }
+  end
 end
 FakeResponse = Struct.new(:status, :headers, :body)

data/test/support/routes.rb

@@ -37,7 +37,6 @@ class DeasTestServer
   get  '/haml_with_layout',      'HamlWithLayoutHandler'
   get  '/with_haml_layout',      'WithHamlLayoutHandler'
   get  '/haml_with_haml_layout', 'HamlWithHamlLayoutHandler'
-  get  '/partial.html',          'PartialHandler'
 
   get '/handler/tests.json', 'HandlerTestsHandler'
 
@@ -195,13 +194,6 @@ class HamlWithHamlLayoutHandler
 
 end
 
-class PartialHandler
-  include Deas::ViewHandler
-
-  def run!; partial 'info', :info => 'some-info'; end
-
-end
-
 class RedirectHandler
   include Deas::ViewHandler
 
@@ -235,7 +227,6 @@ class HandlerTestsHandler
 
   def init!
     @data = {}
-    set_data('app_settings_a_setting'){ self.app_settings.a_setting }
     set_data('logger_class_name'){ self.logger.class.name }
     set_data('request_method'){ self.request.request_method.to_s }
     set_data('response_firstheaderval'){ self.response.headers.sort.first.to_s }

data/test/support/view_handlers.rb

@@ -1,6 +1,6 @@
 require 'deas/view_handler'
 
-class TestViewHandler
+class EmptyViewHandler
   include Deas::ViewHandler
 
 end
@@ -16,67 +16,36 @@ class TestRunnerViewHandler
 
 end
 
-class RenderViewHandler
+class DeasRunnerViewHandler
   include Deas::ViewHandler
 
-  def run!
-    render "my_template", :some => :option
-  end
-end
+  attr_reader :before_called, :after_called
+  attr_reader :init_bang_called, :run_bang_called
 
-class PartialViewHandler
-  include Deas::ViewHandler
+  layout 'web'
+
+  before{ @before_called = true }
+  after{  @after_called  = true }
+
+  def init!; @init_bang_called = true; end
+  def run!;  @run_bang_called  = true; end
 
-  def run!
-    partial "my_partial", :some => 'locals'
-  end
 end
 
-class SendFileViewHandler
+class RenderViewHandler
   include Deas::ViewHandler
 
   def run!
-    send_file "my_file.txt", :some => :option
+    render "my_template", :some => :option
   end
 end
 
-class FlagViewHandler
+class SendFileViewHandler
   include Deas::ViewHandler
-  before{ @before_hook_called = true }
-  after{  @after_hook_called  = true }
-  layout 'web'
-
-  attr_reader :before_init_called, :init_bang_called, :after_init_called
-  attr_reader :before_run_called, :run_bang_called, :after_run_called
-  attr_reader :before_hook_called, :after_hook_called, :second_before_init_called
-
-  before_init do
-    @before_init_called = true
-  end
-  before_init do
-    @second_before_init_called = true
-  end
-
-  def init!
-    @init_bang_called = true
-  end
-
-  after_init do
-    @after_init_called = true
-  end
-
-  before_run do
-    @before_run_called = true
-  end
 
   def run!
-    @run_bang_called = true
-  end
-
-  after_run do
-    @after_run_called = true
+    send_file "my_file.txt", :some => :option
   end
-
 end
 
 class HaltViewHandler