deas 0.27.0 → 0.28.0

data/lib/deas/logger.rb

@@ -0,0 +1,10 @@
+module Deas
+
+  class NullLogger
+    require 'logger'
+    ::Logger::Severity.constants.each do |name|
+      define_method(name.downcase){|*args| } # no-op
+    end
+  end
+
+end

data/lib/deas/redirect_proxy.rb

@@ -1,5 +1,5 @@
-require 'deas/view_handler'
 require 'deas/url'
+require 'deas/view_handler'
 
 module Deas
 

data/lib/deas/route.rb

@@ -16,16 +16,16 @@ module Deas
     end
 
     def run(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)
+      runner = Deas::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

data/lib/deas/route_proxy.rb

@@ -1,5 +1,5 @@
-require 'deas/view_handler'
 require 'deas/exceptions'
+require 'deas/view_handler'
 
 module Deas
   class RouteProxy

data/lib/deas/router.rb

@@ -1,6 +1,6 @@
 require 'deas/redirect_proxy'
-require 'deas/route_proxy'
 require 'deas/route'
+require 'deas/route_proxy'
 require 'deas/url'
 
 module Deas

data/lib/deas/runner.rb

@@ -1,25 +1,28 @@
 require 'rack/utils'
+require 'deas/logger'
 require 'deas/router'
+require 'deas/template_source'
 
 module Deas
 
   class Runner
 
     attr_reader :handler_class, :handler
-    attr_reader :request, :response, :params
-    attr_reader :logger, :router, :session
+    attr_reader :request, :response, :session
+    attr_reader :params, :logger, :router, :template_source
 
     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]
+      @request         = a[:request]
+      @response        = a[:response]
+      @session         = a[:session]
+      @params          = a[:params] || {}
+      @logger          = a[:logger] || Deas::NullLogger.new
+      @router          = a[:router] || Deas::Router.new
+      @template_source = a[:template_source] || Deas::NullTemplateSource.new
     end
 
     def halt(*args);         raise NotImplementedError; end
@@ -28,6 +31,7 @@ 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/server.rb

@@ -2,11 +2,13 @@ require 'pathname'
 require 'ns-options'
 require 'ns-options/boolean'
 require 'deas/exceptions'
-require 'deas/template'
+require 'deas/logger'
 require 'deas/logging'
-require 'deas/show_exceptions'
 require 'deas/router'
+require 'deas/show_exceptions'
 require 'deas/sinatra_app'
+require 'deas/template'
+require 'deas/template_source'
 
 module Deas; end
 module Deas::Server
@@ -34,6 +36,7 @@ module Deas::Server
 
     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
@@ -198,6 +201,10 @@ module Deas::Server
       self.configuration.default_charset *args
     end
 
+    def template_source(*args)
+      self.configuration.template_source *args
+    end
+
     # router handling
 
     def router(value = nil)

data/lib/deas/sinatra_app.rb

@@ -35,6 +35,7 @@ module Deas
         set :deas_default_charset, server_config.default_charset
         set :logger,               server_config.logger
         set :router,               server_config.router
+        set :template_source,      server_config.template_source
 
         server_config.settings.each{ |set_args| set *set_args }
         server_config.middlewares.each{ |use_args| use *use_args }

data/lib/deas/sinatra_runner.rb

@@ -40,19 +40,29 @@ module Deas
       @sinatra_call.headers(*args)
     end
 
-    def render(template_name, opts = nil, &block)
+    def render(template_name, opts = nil)
       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 => self.handler,
         :logger => self.logger
       }.merge(options[:locals] || {})
       options[:layout] = self.handler_class.layouts if !options.key?(:layout)
-      Deas::Template.new(@sinatra_call, template_name, options).render(&block)
+
+      if self.template_source.engine_for?(template_name)
+        self.template_source.render(template_name, self.handler, options[:locals])
+      else
+        Deas::Template.new(@sinatra_call, template_name, options).render
+      end
+    end
+
+    def partial(template_name, locals = nil)
+      if self.template_source.engine_for?(template_name)
+        self.template_source.partial(template_name, locals || {})
+      else
+        Deas::Template::Partial.new(@sinatra_call, template_name, locals).render
+      end
     end
 
     def send_file(*args, &block)

data/lib/deas/template.rb

@@ -76,10 +76,6 @@ module Deas
 
       def initialize(sinatra_call, name, locals = nil)
         options = { :locals => (locals || {}) }
-        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/template_engine.rb

@@ -0,0 +1,50 @@
+require 'pathname'
+require 'deas/logger'
+
+module Deas
+
+  class TemplateEngine
+
+    attr_reader :source_path, :logger, :opts
+
+    def initialize(opts = nil)
+      @opts = opts || {}
+      @source_path = Pathname.new(@opts['source_path'].to_s)
+      @logger = @opts['logger'] || Deas::NullLogger.new
+    end
+
+    def render(template_name, view_handler, locals)
+      raise NotImplementedError
+    end
+
+    def partial(template_name, locals)
+      raise NotImplementedError
+    end
+
+    def capture_partial(template_name, locals, &content)
+      raise NotImplementedError
+    end
+
+  end
+
+  class NullTemplateEngine < TemplateEngine
+
+    def render(template_name, view_handler, locals)
+      template_file = self.source_path.join(template_name).to_s
+      unless File.exists?(template_file)
+        raise ArgumentError, "template file `#{template_file}` does not exist"
+      end
+      File.read(template_file)
+    end
+
+    def partial(template_name, locals)
+      render(template_name, nil, locals)
+    end
+
+    def capture_partial(template_name, locals, &content)
+      render(template_name, nil, locals)
+    end
+
+  end
+
+end

data/lib/deas/template_source.rb

@@ -0,0 +1,74 @@
+require 'deas/logger'
+require 'deas/template_engine'
+
+module Deas
+
+  class TemplateSource
+
+    DISALLOWED_ENGINE_EXTS = [ 'rb' ]
+
+    DisallowedEngineExtError = Class.new(ArgumentError)
+
+    attr_reader :path, :engines
+
+    def initialize(path, logger = nil)
+      @path = path.to_s
+      @default_opts = {
+        'source_path' => @path,
+        'logger'      => logger || Deas::NullLogger.new
+      }
+      @engines = Hash.new{ |h,k| Deas::NullTemplateEngine.new(@default_opts) }
+    end
+
+    def engine(input_ext, engine_class, registered_opts = nil)
+      if DISALLOWED_ENGINE_EXTS.include?(input_ext)
+        raise DisallowedEngineExtError, "`#{input_ext}` is disallowed as an"\
+                                        " engine extension."
+      end
+      engine_opts = @default_opts.merge(registered_opts || {})
+      @engines[input_ext.to_s] = engine_class.new(engine_opts)
+    end
+
+    def engine_for?(template_name)
+      @engines.keys.include?(get_template_ext(template_name))
+    end
+
+    def render(template_name, view_handler, locals)
+      get_engine(template_name).render(template_name, view_handler, locals)
+    end
+
+    def partial(template_name, locals)
+      get_engine(template_name).partial(template_name, locals)
+    end
+
+    def capture_partial(template_name, locals, &content)
+      get_engine(template_name).capture_partial(template_name, locals, &content)
+    end
+
+    private
+
+    def get_engine(template_name)
+      @engines[get_template_ext(template_name)]
+    end
+
+    def get_template_ext(template_name)
+      files = Dir.glob("#{File.join(@path, template_name.to_s)}.*")
+      files = files.reject{ |p| !@engines.keys.include?(parse_ext(p)) }
+      parse_ext(files.first.to_s || '')
+    end
+
+    def parse_ext(template_name)
+      File.extname(template_name)[1..-1]
+    end
+
+  end
+
+  class NullTemplateSource < TemplateSource
+
+    def initialize
+      super('')
+    end
+
+  end
+
+end

data/lib/deas/test_runner.rb

@@ -14,10 +14,11 @@ module Deas
       super(handler_class, {
         :request  => args.delete(:request),
         :response => args.delete(:response),
+        :session  => args.delete(:session),
         :params   => NormalizedParams.new(args.delete(:params) || {}).value,
         :logger   => args.delete(:logger),
         :router   => args.delete(:router),
-        :session  => args.delete(:session)
+        :template_source => args.delete(:template_source)
       })
       args.each{|key, value| self.handler.send("#{key}=", value) }
 
@@ -72,6 +73,11 @@ module Deas
     end
     RenderArgs = Struct.new(:template_name, :options, :block)
 
+    def partial(template_name, locals = nil)
+      PartialArgs.new(template_name, locals)
+    end
+    PartialArgs = Struct.new(:template_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.27.0"
+  VERSION = "0.28.0"
 end

data/lib/deas/view_handler.rb

@@ -7,66 +7,72 @@ module Deas
     def self.included(klass)
       klass.class_eval do
         extend ClassMethods
+        include InstanceMethods
       end
     end
 
-    def initialize(runner)
-      @deas_runner = runner
-    end
+    module InstanceMethods
 
-    def init
-      self.run_callback 'before_init'
-      self.init!
-      self.run_callback 'after_init'
-    end
+      def initialize(runner)
+        @deas_runner = runner
+      end
 
-    def init!
-    end
+      def init
+        run_callback 'before_init'
+        self.init!
+        run_callback 'after_init'
+      end
 
-    def run
-      self.run_callback 'before_run'
-      data = self.run!
-      self.run_callback 'after_run'
-      data
-    end
+      def init!
+      end
 
-    def run!
-      raise NotImplementedError
-    end
+      def run
+        run_callback 'before_run'
+        data = self.run!
+        run_callback 'after_run'
+        data
+      end
 
-    def inspect
-      reference = '0x0%x' % (self.object_id << 1)
-      "#<#{self.class}:#{reference} @request=#{self.request.inspect}>"
-    end
+      def run!
+        raise NotImplementedError
+      end
 
-    def ==(other_handler)
-      self.class == other_handler.class
-    end
+      def inspect
+        reference = '0x0%x' % (self.object_id << 1)
+        "#<#{self.class}:#{reference} @request=#{request.inspect}>"
+      end
+
+      def ==(other_handler)
+        self.class == other_handler.class
+      end
 
-    protected
+      private
 
-    # Helpers
+      # Helpers
 
-    def halt(*args);         @deas_runner.halt(*args);         end
-    def redirect(*args);     @deas_runner.redirect(*args);     end
-    def content_type(*args); @deas_runner.content_type(*args); end
-    def status(*args);       @deas_runner.status(*args);       end
-    def headers(*args);      @deas_runner.headers(*args);      end
+      def halt(*args);         @deas_runner.halt(*args);         end
+      def redirect(*args);     @deas_runner.redirect(*args);     end
+      def content_type(*args); @deas_runner.content_type(*args); end
+      def status(*args);       @deas_runner.status(*args);       end
+      def headers(*args);      @deas_runner.headers(*args);      end
 
-    def render(*args, &block);    @deas_runner.render(*args, &block);    end
-    def send_file(*args, &block); @deas_runner.send_file(*args, &block); 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 logger;       @deas_runner.logger;       end
-    def router;       @deas_runner.router;       end
-    def request;      @deas_runner.request;      end
-    def response;     @deas_runner.response;     end
-    def params;       @deas_runner.params;       end
-    def session;      @deas_runner.session;      end
+      def logger;   @deas_runner.logger;   end
+      def router;   @deas_runner.router;   end
+      def request;  @deas_runner.request;  end
+      def response; @deas_runner.response; end
+      def params;   @deas_runner.params;   end
+      def session;  @deas_runner.session;  end
 
-    def run_callback(callback)
-      (self.class.send("#{callback}_callbacks") || []).each do |callback|
-        self.instance_eval(&callback)
+      def run_callback(callback)
+        (self.class.send("#{callback}_callbacks") || []).each do |callback|
+          self.instance_eval(&callback)
+        end
       end
+
     end
 
     module ClassMethods

data/lib/deas.rb

@@ -9,14 +9,4 @@ require 'deas/view_handler'
 # TODO - remove with future version of Rack (> v1.5.2)
 require 'deas/rack_request_fix'
 
-module Deas
-
-  class NullLogger
-    require 'logger'
-
-    ::Logger::Severity.constants.each do |name|
-      define_method(name.downcase){|*args| } # no-op
-    end
-  end
-
-end
+module Deas; end

data/test/support/fake_sinatra_call.rb

@@ -1,6 +1,7 @@
 require 'ostruct'
-require 'deas'
+require 'deas/logger'
 require 'deas/router'
+require 'deas/template_source'
 
 class FakeSinatraCall
 
@@ -10,19 +11,21 @@ class FakeSinatraCall
   attr_accessor :request, :response, :params, :logger, :router, :session
   attr_accessor :settings
 
-  def initialize(settings={})
-    @request  = FakeRequest.new('GET','/something', {}, OpenStruct.new)
-    @response = FakeResponse.new
-    @params   = @request.params
-    @logger   = Deas::NullLogger.new
-    @router   = Deas::Router.new
-    @session  = @request.session
+  def initialize(settings = {})
+    @request         = FakeRequest.new('GET','/something', {}, OpenStruct.new)
+    @response        = FakeResponse.new
+    @session         = @request.session
+    @params          = @request.params
+    @logger          = Deas::NullLogger.new
+    @router          = Deas::Router.new
+    @template_source = Deas::NullTemplateSource.new
 
     @settings = OpenStruct.new({
       :deas_template_scope => Deas::Template::Scope,
       :deas_default_charset => 'utf-8',
-      :router => Deas::Router.new,
-      :logger => @logger
+      :logger => @logger,
+      :router => @router,
+      :template_source => @template_source
     }.merge(settings))
   end
 

data/test/support/routes.rb

@@ -33,10 +33,10 @@ class DeasTestServer
   get  '/session',  'UseSessionHandler'
 
   get  '/with_layout',           'WithLayoutHandler'
-  get  '/alt_with_layout',       'AlternateWithLayoutHandler'
   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'
 
@@ -149,21 +149,6 @@ class WithLayoutHandler
 
 end
 
-class AlternateWithLayoutHandler
-  include Deas::ViewHandler
-
-  def run!
-    render 'layout1' do
-      render 'layout2' do
-        render 'layout3' do
-          render 'with_layout'
-        end
-      end
-    end
-  end
-
-end
-
 class HamlWithLayoutHandler
   include Deas::ViewHandler
   layouts 'layout1'
@@ -194,6 +179,13 @@ class HamlWithHamlLayoutHandler
 
 end
 
+class PartialHandler
+  include Deas::ViewHandler
+
+  def run!; partial '_info', :info => 'some-info'; end
+
+end
+
 class RedirectHandler
   include Deas::ViewHandler
 
@@ -227,11 +219,11 @@ class HandlerTestsHandler
 
   def init!
     @data = {}
-    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 }
-    set_data('params_a_param'){ self.params['a-param'] }
-    set_data('session_inspect'){ self.session.inspect }
+    set_data('logger_class_name'){ logger.class.name }
+    set_data('request_method'){ request.request_method.to_s }
+    set_data('response_firstheaderval'){ response.headers.sort.first.to_s }
+    set_data('params_a_param'){ params['a-param'] }
+    set_data('session_inspect'){ session.inspect }
   end
 
   def set_data(a, &block)

data/test/support/template.erb

@@ -0,0 +1 @@
+ERB Template Message: <%= view.message %>

data/test/support/template.json

@@ -0,0 +1 @@
+This is a json template for use in template engine tests.

data/test/support/view_handlers.rb

@@ -40,6 +40,14 @@ class RenderViewHandler
   end
 end
 
+class PartialViewHandler
+  include Deas::ViewHandler
+
+  def run!
+    partial "my_partial", :some => 'locals'
+  end
+end
+
 class SendFileViewHandler
   include Deas::ViewHandler
 

data/test/support/views/show.erb

@@ -1,2 +1,2 @@
 show page: <%= view.message %>
-<%= partial "info", :info => 'Show Info' %>
+<%= partial "_info", :info => 'Show Info' %>

data/test/system/rack_tests.rb

@@ -72,11 +72,6 @@ module Deas
       expected_body = "Layout 1\nLayout 2\nLayout 3\nWith Layouts View: WithLayoutHandler\n"
       assert_equal 200,           last_response.status
       assert_equal expected_body, last_response.body
-
-      get '/alt_with_layout'
-      expected_body = "Layout 1\nLayout 2\nLayout 3\nWith Layouts View: AlternateWithLayoutHandler\n"
-      assert_equal 200,           last_response.status
-      assert_equal expected_body, last_response.body
     end
 
     should "render mixed (erb and other) templates using layouts" do
@@ -96,6 +91,13 @@ module Deas
       assert_equal expected_body, last_response.body
     end
 
+    should "render partial templates" do
+      get '/partial.html'
+      expected_body = "Stuff: some-info\n"
+      assert_equal 200,           last_response.status
+      assert_equal expected_body, last_response.body
+    end
+
     should "return a 302 redirecting to the expected locations" do
       get '/redirect'
       expected_location = 'http://google.com'

data/test/unit/error_handler_tests.rb

@@ -1,7 +1,8 @@
 require 'assert'
-require 'test/support/fake_sinatra_call'
 require 'deas/error_handler'
 
+require 'test/support/fake_sinatra_call'
+
 class Deas::ErrorHandler
 
   class UnitTests < Assert::Context