deas 0.27.0 → 0.28.0

data/test/unit/logging_tests.rb

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

data/test/unit/route_tests.rb

@@ -59,13 +59,14 @@ class Deas::Route
       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,
-        :params       => @fake_sinatra_call.params,
-        :logger       => @fake_sinatra_call.settings.logger,
-        :router       => @fake_sinatra_call.settings.router,
-        :session      => @fake_sinatra_call.session
+        :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
 
@@ -107,13 +108,14 @@ class Deas::Route
     def build(handler_class, args)
       @handler_class, @args = handler_class, args
 
-      @sinatra_call = args[:sinatra_call]
-      @request      = args[:request]
-      @response     = args[:response]
-      @params       = args[:params]
-      @logger       = args[:logger]
-      @router       = args[:router]
-      @session      = args[:session]
+      @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

data/test/unit/runner_tests.rb

@@ -1,6 +1,7 @@
 require 'assert'
 require 'deas/runner'
 
+require 'deas/logger'
 require 'deas/router'
 require 'test/support/view_handlers'
 
@@ -23,10 +24,10 @@ class Deas::Runner
     subject{ @runner }
 
     should have_readers :handler_class, :handler
-    should have_readers :request, :response, :params
-    should have_readers :logger, :router, :session
+    should have_readers :request, :response, :session
+    should have_readers :params, :logger, :router, :template_source
     should have_imeths :halt, :redirect, :content_type, :status, :headers
-    should have_imeths :render, :send_file
+    should have_imeths :render, :partial, :send_file
 
     should "know its handler and handler class" do
       assert_equal EmptyViewHandler, subject.handler_class
@@ -36,10 +37,11 @@ class Deas::Runner
     should "default its settings" do
       assert_nil subject.request
       assert_nil subject.response
+      assert_nil subject.session
       assert_kind_of ::Hash, subject.params
       assert_kind_of Deas::NullLogger, subject.logger
       assert_kind_of Deas::Router, subject.router
-      assert_nil subject.session
+      assert_kind_of Deas::NullTemplateSource, subject.template_source
     end
 
     should "default its params" do
@@ -54,6 +56,7 @@ class Deas::Runner
       assert_raises(NotImplementedError){ subject.status }
       assert_raises(NotImplementedError){ subject.headers }
       assert_raises(NotImplementedError){ subject.render }
+      assert_raises(NotImplementedError){ subject.partial }
       assert_raises(NotImplementedError){ subject.send_file }
     end
 

data/test/unit/server_configuration_tests.rb

@@ -1,10 +1,12 @@
 require 'assert'
 require 'deas/server'
 
-require 'test/support/view_handlers'
 require 'deas/exceptions'
-require 'deas/template'
+require 'deas/logger'
 require 'deas/router'
+require 'deas/template'
+require 'deas/template_source'
+require 'test/support/view_handlers'
 
 class Deas::Server::Configuration
 
@@ -24,7 +26,7 @@ class Deas::Server::Configuration
 
     # server handling options
 
-    should have_imeths :verbose_logging, :logger
+    should have_imeths :verbose_logging, :logger, :template_source
 
     should have_accessors :settings, :error_procs, :init_procs, :template_helpers
     should have_accessors :middlewares, :router
@@ -49,8 +51,9 @@ class Deas::Server::Configuration
     end
 
     should "default the handling options" do
-      assert_instance_of Deas::NullLogger, subject.logger
       assert_equal true, subject.verbose_logging
+      assert_instance_of Deas::NullLogger, subject.logger
+      assert_instance_of Deas::NullTemplateSource, subject.template_source
     end
 
     should "default its stored configuration" do

data/test/unit/server_tests.rb

@@ -3,6 +3,7 @@ require 'deas/server'
 
 require 'logger'
 require 'deas/router'
+require 'deas/template_source'
 
 module Deas::Server
 
@@ -22,7 +23,7 @@ module Deas::Server
 
     # DSL for server handling settings
     should have_imeths :init, :error, :template_helpers, :template_helper?
-    should have_imeths :use, :set, :verbose_logging, :logger
+    should have_imeths :use, :set, :verbose_logging, :logger, :template_source
     should have_imeths :get, :post, :put, :patch, :delete
     should have_imeths :redirect, :route, :url, :url_for
 
@@ -87,6 +88,10 @@ module Deas::Server
       subject.logger stdout_logger
       assert_equal stdout_logger, config.logger
 
+      a_source = Deas::TemplateSource.new(Factory.path)
+      subject.template_source a_source
+      assert_equal a_source, config.template_source
+
       subject.default_charset 'latin1'
       assert_equal 'latin1', config.default_charset
     end

data/test/unit/show_exceptions_tests.rb

@@ -1,7 +1,8 @@
 require 'assert'
-require 'rack/utils'
 require 'deas/show_exceptions'
 
+require 'rack/utils'
+
 class Deas::ShowExceptions
 
   class UnitTests < Assert::Context

data/test/unit/sinatra_app_tests.rb

@@ -1,11 +1,13 @@
 require 'assert'
+require 'deas/sinatra_app'
+
 require 'sinatra/base'
-require 'test/support/view_handlers'
+require 'deas/logger'
 require 'deas/route_proxy'
 require 'deas/route'
 require 'deas/router'
 require 'deas/server'
-require 'deas/sinatra_app'
+require 'test/support/view_handlers'
 
 module Deas::SinatraApp
 
@@ -42,17 +44,18 @@ module Deas::SinatraApp
 
     should "have it's configuration set based on the server configuration" do
       subject.settings.tap do |settings|
-        assert_equal 'staging',                  settings.environment
-        assert_equal 'path/to/somewhere',        settings.root.to_s
-        assert_equal 'path/to/somewhere/public', settings.public_folder.to_s
-        assert_equal 'path/to/somewhere/views',  settings.views.to_s
-        assert_equal true,                       settings.dump_errors
-        assert_equal false,                      settings.method_override
-        assert_equal false,                      settings.sessions
-        assert_equal true,                       settings.static
-        assert_equal true,                       settings.reload_templates
-        assert_instance_of Deas::NullLogger,     settings.logger
-        assert_instance_of Deas::Router,         settings.router
+        assert_equal 'staging',                      settings.environment
+        assert_equal 'path/to/somewhere',            settings.root.to_s
+        assert_equal 'path/to/somewhere/public',     settings.public_folder.to_s
+        assert_equal 'path/to/somewhere/views',      settings.views.to_s
+        assert_equal true,                           settings.dump_errors
+        assert_equal false,                          settings.method_override
+        assert_equal false,                          settings.sessions
+        assert_equal true,                           settings.static
+        assert_equal true,                           settings.reload_templates
+        assert_instance_of Deas::NullLogger,         settings.logger
+        assert_instance_of Deas::Router,             settings.router
+        assert_instance_of Deas::NullTemplateSource, settings.template_source
 
         # settings that are set but can't be changed
         assert_equal false, settings.logging

data/test/unit/sinatra_runner_tests.rb

@@ -94,6 +94,14 @@ class Deas::SinatraRunner
       })
     end
 
+    should "render partials with locals" do
+      exp_result = Deas::Template::Partial.new(@fake_sinatra_call, 'info', {
+        :some => 'locals'
+      }).render
+
+      assert_equal exp_result, subject.partial('info', :some => 'locals')
+    end
+
     should "call the sinatra_call's send_file to set the send files" do
       block_called = false
       args = subject.send_file('a/file', {:some => 'opts'}, &proc{ block_called = true })
@@ -104,4 +112,44 @@ class Deas::SinatraRunner
 
   end
 
+  class InitWithEngineTests < UnitTests
+    desc "when init with a template source and matching engine"
+    setup do
+      @fake_sinatra_call = FakeSinatraCall.new
+      @runner = @runner_class.new(DeasRunnerViewHandler, {
+        :sinatra_call => @fake_sinatra_call,
+        :template_source => FakeTemplateSource.new
+      })
+    end
+    subject{ @runner }
+
+    should "render templates using the source" do
+      exp_handler = DeasRunnerViewHandler.new(subject)
+      exp_locals = {
+        :view => exp_handler,
+        :logger => @runner.logger,
+        :some => 'locals'
+      }
+      exp = ['render', 'info', @runner.handler, exp_locals]
+      assert_equal exp, subject.render('info', :locals => {
+        :some => 'locals'
+      })
+    end
+
+    should "render partials using the source" do
+      exp = ['partial', 'info', { :some => 'locals' }]
+      assert_equal exp, subject.partial('info', { :some => 'locals' })
+    end
+
+  end
+
+  class FakeTemplateSource
+    def engine_for?(template_name)
+      true
+    end
+
+    def render(*args);  ['render',  *args]; end
+    def partial(*args); ['partial', *args]; end
+  end
+
 end

data/test/unit/template_engine_tests.rb

@@ -0,0 +1,121 @@
+require 'assert'
+require 'deas/template_engine'
+
+require 'pathname'
+require 'deas/logger'
+require 'test/support/factory'
+
+class Deas::TemplateEngine
+
+  class UnitTests < Assert::Context
+    desc "Deas::TemplateEngine"
+    setup do
+      @source_path = Factory.path
+      @template_name = Factory.path
+      @view_handler = 'a-view-handler'
+      @locals = {}
+      @content = Proc.new{}
+      @engine = Deas::TemplateEngine.new('some' => 'opts')
+    end
+    subject{ @engine }
+
+    should have_readers :source_path, :logger, :opts
+    should have_imeths :render, :partial, :capture_partial
+
+    should "default its source path" do
+      assert_equal Pathname.new(nil.to_s), subject.source_path
+    end
+
+    should "allow custom source paths" do
+      engine = Deas::TemplateEngine.new('source_path' => @source_path)
+      assert_equal Pathname.new(@source_path.to_s), engine.source_path
+    end
+
+    should "default its logger" do
+      assert_instance_of Deas::NullLogger, subject.logger
+    end
+
+    should "allow custom source loggers" do
+      logger = 'a-logger'
+      engine = Deas::TemplateEngine.new('logger' => logger)
+      assert_equal logger, engine.logger
+    end
+
+    should "default the opts if none given" do
+      exp_opts = {}
+      assert_equal exp_opts, Deas::TemplateEngine.new.opts
+    end
+
+    should "allow custom opts" do
+      exp_opts = {'some' => 'opts'}
+      assert_equal exp_opts, subject.opts
+    end
+
+    should "raise NotImplementedError on `render`" do
+      assert_raises NotImplementedError do
+        subject.render(@template_name, @view_handler, @locals)
+      end
+    end
+
+    should "raise NotImplementedError on `partial`" do
+      assert_raises NotImplementedError do
+        subject.partial(@template_name, @locals)
+      end
+    end
+
+    should "raise NotImplementedError on `capture_partial`" do
+      assert_raises NotImplementedError do
+        subject.capture_partial(@template_name, @locals, &@content)
+      end
+    end
+
+  end
+
+  class NullTemplateEngineTests < Assert::Context
+    desc "Deas::NullTemplateEngine"
+    setup do
+      @v = 'a-view-handler'
+      @l = {}
+      @c = Proc.new{}
+      @engine = Deas::NullTemplateEngine.new('source_path' => ROOT.to_s)
+    end
+    subject{ @engine }
+
+    should "be a TemplateEngine" do
+      assert_kind_of Deas::TemplateEngine, subject
+    end
+
+    should "read and return the given path in its source path on `render`" do
+      exists_file = 'test/support/template.json'
+      exp = File.read(subject.source_path.join(exists_file).to_s)
+      assert_equal exp, subject.render(exists_file, @v, @l)
+    end
+
+    should "call `render` to implement its `partial` method" do
+      exists_file = 'test/support/template.json'
+      exp = subject.render(exists_file, nil, @l)
+      assert_equal exp, subject.partial(exists_file, @l)
+    end
+
+    should "call `render` to implement its `capture_partial` method" do
+      exists_file = 'test/support/template.json'
+      exp = subject.render(exists_file, nil, @l)
+      assert_equal exp, subject.capture_partial(exists_file, @l, &@c)
+    end
+
+    should "complain if given a path that does not exist in its source path" do
+      no_exists_file = '/does/not/exists'
+      assert_raises ArgumentError do
+        subject.render(no_exists_file, @v, @l)
+      end
+      assert_raises ArgumentError do
+        subject.partial(no_exists_file, @l)
+      end
+      assert_raises ArgumentError do
+        subject.capture_partial(no_exists_file, @l, &@c)
+      end
+    end
+
+  end
+
+end

data/test/unit/template_source_tests.rb

@@ -0,0 +1,221 @@
+require 'assert'
+require 'deas/template_source'
+
+require 'deas/template_engine'
+
+class Deas::TemplateSource
+
+  class UnitTests < Assert::Context
+    desc "Deas::TemplateSource"
+    subject{ Deas::TemplateSource }
+
+    should "disallow certain engine extensions" do
+      exp = [ 'rb' ]
+      assert_equal exp, subject::DISALLOWED_ENGINE_EXTS
+    end
+
+  end
+
+  class InitTests < Assert::Context
+    setup do
+      @source_path = ROOT.join('test/support').to_s
+      @logger = 'a-logger'
+      @source = Deas::TemplateSource.new(@source_path, @logger)
+    end
+    subject{ @source }
+
+    should have_readers :path, :engines
+    should have_imeths :engine, :engine_for?
+    should have_imeths :render, :partial, :capture_partial
+
+    should "know its path" do
+      assert_equal @source_path.to_s, subject.path
+    end
+
+  end
+
+  class EngineRegistrationTests < InitTests
+    desc "when registering an engine"
+    setup do
+      @test_engine = TestEngine
+    end
+
+    should "allow registering new engines" do
+      assert_kind_of Deas::NullTemplateEngine, subject.engines['test']
+      subject.engine 'test', @test_engine
+      assert_kind_of @test_engine, subject.engines['test']
+    end
+
+    should "register with default options" do
+      subject.engine 'test', @test_engine
+      exp_opts = {
+        'source_path' => subject.path,
+        'logger'      => @logger
+      }
+      assert_equal exp_opts, subject.engines['test'].opts
+
+      subject.engine 'test', @test_engine, 'an' => 'opt'
+      exp_opts = {
+        'source_path' => subject.path,
+        'logger'      => @logger,
+        'an' => 'opt'
+      }
+      assert_equal exp_opts, subject.engines['test'].opts
+
+      subject.engine('test', @test_engine, {
+        'source_path' => 'something',
+        'logger'      => 'another'
+      })
+      exp_opts = {
+        'source_path' => 'something',
+        'logger'      => 'another'
+      }
+      assert_equal exp_opts, subject.engines['test'].opts
+
+      source = Deas::TemplateSource.new(@source_path)
+      source.engine('test', @test_engine)
+      assert_instance_of Deas::NullLogger, source.engines['test'].opts['logger']
+    end
+
+    should "complain if registering a disallowed temp" do
+      assert_kind_of Deas::NullTemplateEngine, subject.engines['rb']
+      assert_raises DisallowedEngineExtError do
+        subject.engine 'rb', @test_engine
+      end
+      assert_kind_of Deas::NullTemplateEngine, subject.engines['rb']
+    end
+
+    should "know if it has an engine registered for a given template name" do
+      assert_false subject.engine_for?('test_template')
+
+      subject.engine 'test', @test_engine
+      assert_true subject.engine_for?('test_template')
+    end
+
+  end
+
+  class RenderOrPartialTests < InitTests
+    setup do
+      @source.engine('test', TestEngine)
+      @source.engine('json', JsonEngine)
+
+      @v = TestServiceHandler
+      @l = {}
+      @c = Proc.new{}
+    end
+
+  end
+
+  class RenderTests < RenderOrPartialTests
+    desc "when rendering a template"
+
+    should "call `render` on the configured engine" do
+      result = subject.render('test_template', @v, @l)
+      assert_equal 'render-test-engine', result
+    end
+
+    should "only try rendering template files its has engines for" do
+      # there should be 2 files called "template" in `test/support` with diff
+      # extensions
+      result = subject.render('template', @v, @l)
+      assert_equal 'render-json-engine', result
+    end
+
+    should "use the null template engine when an engine can't be found" do
+      assert_raises(ArgumentError) do
+        subject.render(Factory.string, @v, @l)
+      end
+    end
+
+  end
+
+  class PartialTests < RenderTests
+    desc "when partial rendering a template"
+
+    should "call `partial` on the configured engine" do
+      result = subject.partial('test_template', @l)
+      assert_equal 'partial-test-engine', result
+    end
+
+    should "only try rendering template files its has engines for" do
+      # there should be 2 files called "template" in `test/support` with diff
+      # extensions
+      result = subject.partial('template', @l)
+      assert_equal 'partial-json-engine', result
+    end
+
+    should "use the null template engine when an engine can't be found" do
+      assert_raises(ArgumentError) do
+        subject.partial(Factory.string, @l)
+      end
+    end
+
+  end
+
+  class CapturePartialTests < RenderOrPartialTests
+    desc "when capture partial rendering a template"
+
+    should "call `capture_partial` on the configured engine" do
+      result = subject.capture_partial('test_template', @l, &@c)
+      assert_equal 'capture-partial-test-engine', result
+    end
+
+    should "only try rendering template files its has engines for" do
+      # there should be 2 files called "template" in `test/support` with diff
+      # extensions
+      result = subject.capture_partial('template', @l, &@c)
+      assert_equal 'capture-partial-json-engine', result
+    end
+
+    should "use the null template engine when an engine can't be found" do
+      assert_raises(ArgumentError) do
+        subject.capture_partial(Factory.string, @l, &@c)
+      end
+    end
+
+  end
+
+  class NullTemplateSourceTests < Assert::Context
+    desc "Deas::NullTemplateSource"
+    setup do
+      @source = Deas::NullTemplateSource.new
+    end
+    subject{ @source }
+
+    should "be a template source" do
+      assert_kind_of Deas::TemplateSource, subject
+    end
+
+    should "have an empty path string" do
+      assert_equal '', subject.path
+    end
+
+  end
+
+  class TestEngine < Deas::TemplateEngine
+    def render(template_name, view_handler, locals)
+      'render-test-engine'
+    end
+    def partial(template_name, locals)
+      'partial-test-engine'
+    end
+    def capture_partial(template_name, locals, &content)
+      'capture-partial-test-engine'
+    end
+  end
+
+  class JsonEngine < Deas::TemplateEngine
+    def render(template_name, view_handler, locals)
+      'render-json-engine'
+    end
+    def partial(template_name, locals)
+      'partial-json-engine'
+    end
+    def capture_partial(template_name, locals, &content)
+      'capture-partial-json-engine'
+    end
+  end
+
+  TestServiceHandler = Class.new
+
+end

data/test/unit/template_tests.rb

@@ -1,7 +1,8 @@
 require 'assert'
-require 'test/support/fake_sinatra_call'
 require 'deas/template'
 
+require 'test/support/fake_sinatra_call'
+
 class Deas::Template
 
   class UnitTests < Assert::Context
@@ -100,7 +101,7 @@ class Deas::Template
     end
 
     should "call the sinatra_call's erb method with #partial" do
-      render_args = subject.partial('part', {
+      render_args = subject.partial('_part', {
         :something => true
       }, &Proc.new{ '#partial called this proc' })
 
@@ -130,7 +131,7 @@ class Deas::Template
   class PartialTests < UnitTests
     desc "Partial"
     setup do
-      @partial = Deas::Template::Partial.new(@fake_sinatra_call, 'users/index/listing', {
+      @partial = Deas::Template::Partial.new(@fake_sinatra_call, 'users/index/_listing', {
         :user => 'Joe Test'
       })
     end
@@ -140,15 +141,6 @@ class Deas::Template
       assert_kind_of Deas::Template, subject
     end
 
-    should "add an underscore to it's template's basename" do
-      assert_equal :"users/index/_listing", subject.name
-    end
-
-    should "not add an underscore to it's template's basename if one already exists" do
-      partial = Deas::Template::Partial.new(@fake_sinatra_call, 'users/index/_listing')
-      assert_equal :"users/index/_listing", partial.name
-    end
-
     should "set it's locals option" do
       assert_equal({ :user => 'Joe Test' }, subject.options[:locals])
     end