deas 0.29.0 → 0.30.0

data/test/unit/deas_runner_tests.rb

@@ -2,6 +2,7 @@ require 'assert'
 require 'deas/deas_runner'
 
 require 'deas/runner'
+require 'deas/template_source'
 require 'test/support/normalized_params_spy'
 require 'test/support/view_handlers'
 
@@ -94,4 +95,90 @@ class Deas::DeasRunner
 
   end
 
+  class RenderSetupTests < InitTests
+    setup do
+      @template_name = Factory.path
+      @locals = { Factory.string => Factory.string }
+    end
+
+  end
+
+  class RenderTests < RenderSetupTests
+    desc "render method"
+    setup do
+      @render_args = nil
+      Assert.stub(@runner.template_source, :render){ |*args| @render_args = args }
+    end
+
+    should "call to its template source render method" do
+      subject.render(@template_name, @locals)
+      exp = [@template_name, subject.handler, @locals]
+      assert_equal exp, @render_args
+
+      subject.render(@template_name)
+      exp = [@template_name, subject.handler, {}]
+      assert_equal exp, @render_args
+    end
+
+  end
+
+  class SourceRenderTests < RenderSetupTests
+    desc "source render method"
+    setup do
+      @source_render_args = nil
+      @source = Deas::TemplateSource.new(Factory.path)
+      Assert.stub(@source, :render){ |*args| @source_render_args = args }
+    end
+
+    should "call to the given source's render method" do
+      subject.source_render(@source, @template_name, @locals)
+      exp = [@template_name, subject.handler, @locals]
+      assert_equal exp, @source_render_args
+
+      subject.source_render(@source, @template_name)
+      exp = [@template_name, subject.handler, {}]
+      assert_equal exp, @source_render_args
+    end
+
+  end
+
+  class PartialTests < RenderSetupTests
+    desc "partial method"
+    setup do
+      @partial_args = nil
+      Assert.stub(@runner.template_source, :partial){ |*args| @partial_args = args }
+    end
+
+    should "call to its template source partial method" do
+      subject.partial(@template_name, @locals)
+      exp = [@template_name, @locals]
+      assert_equal exp, @partial_args
+
+      subject.partial(@template_name)
+      exp = [@template_name, {}]
+      assert_equal exp, @partial_args
+    end
+
+  end
+
+  class SourcePartialTests < RenderSetupTests
+    desc "source partial method"
+    setup do
+      @source_partial_args = nil
+      @source = Deas::TemplateSource.new(Factory.path)
+      Assert.stub(@source, :partial){ |*args| @source_partial_args = args }
+    end
+
+    should "call to the given source's partial method" do
+      subject.source_partial(@source, @template_name, @locals)
+      exp = [@template_name, @locals]
+      assert_equal exp, @source_partial_args
+
+      subject.source_partial(@source, @template_name)
+      exp = [@template_name, {}]
+      assert_equal exp, @source_partial_args
+    end
+
+  end
+
 end

data/test/unit/runner_tests.rb

@@ -27,7 +27,8 @@ class Deas::Runner
     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, :partial, :send_file
+    should have_imeths :render, :source_render, :partial, :source_partial
+    should have_imeths :send_file
 
     should "know its handler and handler class" do
       assert_equal EmptyViewHandler, subject.handler_class
@@ -51,7 +52,9 @@ class Deas::Runner
       assert_raises(NotImplementedError){ subject.status }
       assert_raises(NotImplementedError){ subject.headers }
       assert_raises(NotImplementedError){ subject.render }
+      assert_raises(NotImplementedError){ subject.source_render }
       assert_raises(NotImplementedError){ subject.partial }
+      assert_raises(NotImplementedError){ subject.source_partial }
       assert_raises(NotImplementedError){ subject.send_file }
     end
 

data/test/unit/server_configuration_tests.rb

@@ -4,7 +4,6 @@ require 'deas/server'
 require 'deas/exceptions'
 require 'deas/logger'
 require 'deas/router'
-require 'deas/template'
 require 'deas/template_source'
 require 'test/support/view_handlers'
 
@@ -30,7 +29,7 @@ class Deas::Server::Configuration
 
     should have_accessors :settings, :error_procs, :init_procs, :template_helpers
     should have_accessors :middlewares, :router
-    should have_imeths :valid?, :validate!, :urls, :routes, :template_scope
+    should have_imeths :valid?, :validate!, :urls, :routes
 
     should "default the env to 'development'" do
       assert_equal 'development', subject.env
@@ -67,14 +66,6 @@ class Deas::Server::Configuration
       assert_kind_of Deas::Router, subject.router
     end
 
-    should "build a template scope including its template helpers" do
-      config = Deas::Server::Configuration.new
-      config.template_helpers << (helper_module = Module.new)
-
-      assert_includes Deas::Template::Scope, config.template_scope.ancestors
-      assert_includes helper_module, config.template_scope.included_modules
-    end
-
     should "not be valid until validate! has been run" do
       assert_not subject.valid?
 

data/test/unit/sinatra_runner_tests.rb

@@ -2,7 +2,6 @@ require 'assert'
 require 'deas/sinatra_runner'
 
 require 'deas/deas_runner'
-require 'deas/template'
 require 'test/support/fake_sinatra_call'
 require 'test/support/view_handlers'
 
@@ -65,43 +64,6 @@ class Deas::SinatraRunner
       assert_equal [exp_headers], subject.headers(exp_headers)
     end
 
-    should "render the template with :view/:logger locals and the handler layouts" do
-      exp_handler = DeasRunnerViewHandler.new(subject)
-      exp_layouts = DeasRunnerViewHandler.layouts
-      exp_result = Deas::Template.new(@fake_sinatra_call, 'index', {
-        :locals => {
-          :view => exp_handler,
-          :logger => @runner.logger
-        },
-        :layout => exp_layouts
-      }).render
-      assert_equal exp_result, subject.render('index')
-
-      exp_result = Deas::Template.new(@fake_sinatra_call, 'index', {
-        :locals => {
-          :view => 'a-view',
-          :some => 'thing',
-          :logger => @runner.logger
-        },
-        :layout => false
-      }).render
-      assert_equal exp_result, subject.render('index', {
-        :layout => false,
-        :locals => {
-          :view => 'a-view',
-          :some => 'thing'
-        }
-      })
-    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 })
@@ -112,44 +74,4 @@ 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_source_tests.rb

@@ -26,7 +26,7 @@ class Deas::TemplateSource
     subject{ @source }
 
     should have_readers :path, :engines
-    should have_imeths :engine, :engine_for?
+    should have_imeths :engine, :engine_for?, :engine_for_template?
     should have_imeths :render, :partial
 
     should "know its path" do
@@ -50,30 +50,30 @@ class Deas::TemplateSource
     should "register with default options" do
       subject.engine 'test', @test_engine
       exp_opts = {
-        'source_path'          => subject.path,
-        'logger'               => @logger,
-        'deas_template_source' => subject
+        'source_path'             => subject.path,
+        'logger'                  => @logger,
+        'default_template_source' => subject
       }
       assert_equal exp_opts, subject.engines['test'].opts
 
       subject.engine 'test', @test_engine, 'an' => 'opt'
       exp_opts = {
-        'source_path'          => subject.path,
-        'logger'               => @logger,
-        'deas_template_source' => subject,
-        'an'                   => 'opt'
+        'source_path'             => subject.path,
+        'logger'                  => @logger,
+        'default_template_source' => subject,
+        'an'                      => 'opt'
       }
       assert_equal exp_opts, subject.engines['test'].opts
 
       subject.engine('test', @test_engine, {
-        'source_path'          => 'something',
-        'logger'               => 'another',
-        'deas_template_source' => 'tempsource'
+        'source_path'             => 'something',
+        'logger'                  => 'another',
+        'default_template_source' => 'tempsource'
       })
       exp_opts = {
-        'source_path'          => 'something',
-        'logger'               => 'another',
-        'deas_template_source' => 'tempsource'
+        'source_path'             => 'something',
+        'logger'                  => 'another',
+        'default_template_source' => 'tempsource'
       }
       assert_equal exp_opts, subject.engines['test'].opts
 
@@ -91,10 +91,14 @@ class Deas::TemplateSource
     end
 
     should "know if it has an engine registered for a given template name" do
-      assert_false subject.engine_for?('test_template')
+      assert_false subject.engine_for?(Factory.string)
+      assert_false subject.engine_for?('test')
+      assert_false subject.engine_for_template?(Factory.string)
+      assert_false subject.engine_for_template?('test_template')
 
       subject.engine 'test', @test_engine
-      assert_true subject.engine_for?('test_template')
+      assert_true subject.engine_for?('test')
+      assert_true subject.engine_for_template?('test_template')
     end
 
   end

data/test/unit/test_runner_tests.rb

@@ -3,6 +3,7 @@ require 'deas/test_runner'
 
 require 'rack/test'
 require 'deas/runner'
+require 'deas/template_source'
 require 'test/support/normalized_params_spy'
 require 'test/support/view_handlers'
 
@@ -133,31 +134,70 @@ class Deas::TestRunner
     end
 
     should "build render args if render is called" do
-      value = subject.render 'some/template'
-      assert_kind_of RenderArgs, value
-      [:template_name, :options, :block].each do |meth|
-        assert_respond_to meth, value
+      template_name = Factory.path
+      locals = { Factory.string => Factory.string }
+      args = subject.render template_name, locals
+
+      assert_kind_of RenderArgs, args
+      [:template_name, :locals].each do |meth|
+        assert_respond_to meth, args
+      end
+      assert_equal template_name, args.template_name
+      assert_equal locals,        args.locals
+    end
+
+    should "build source render args if source source render is called" do
+      source = Deas::TemplateSource.new(Factory.path)
+      template_name = Factory.path
+      locals = { Factory.string => Factory.string }
+      args = subject.source_render source, template_name, locals
+
+      assert_kind_of SourceRenderArgs, args
+      [:source, :template_name, :locals].each do |meth|
+        assert_respond_to meth, args
       end
-      assert_equal 'some/template', value.template_name
+      assert_equal source,        args.source
+      assert_equal template_name, args.template_name
+      assert_equal locals,        args.locals
     end
 
     should "build partial args if partial is called" do
-      value = subject.partial 'some/partial', :some => 'locals'
-      assert_kind_of PartialArgs, value
+      template_name = Factory.path
+      locals = { Factory.string => Factory.string }
+      args = subject.partial template_name, locals
+
+      assert_kind_of PartialArgs, args
       [:template_name, :locals].each do |meth|
-        assert_respond_to meth, value
+        assert_respond_to meth, args
       end
-      assert_equal 'some/partial', value.template_name
-      assert_equal({:some => 'locals'}, value.locals)
+      assert_equal template_name, args.template_name
+      assert_equal locals,        args.locals
+    end
+
+    should "build source partial args if source partial is called" do
+      source = Deas::TemplateSource.new(Factory.path)
+      template_name = Factory.path
+      locals = { Factory.string => Factory.string }
+      args = subject.source_partial source, template_name, locals
+
+      assert_kind_of SourcePartialArgs, args
+      [:source, :template_name, :locals].each do |meth|
+        assert_respond_to meth, args
+      end
+      assert_equal source,        args.source
+      assert_equal template_name, args.template_name
+      assert_equal locals,        args.locals
     end
 
     should "build send file args if send file is called" do
-      value = subject.send_file 'some/file/path'
-      assert_kind_of SendFileArgs, value
+      path = Factory.path
+      args = subject.send_file path
+
+      assert_kind_of SendFileArgs, args
       [:file_path, :options, :block].each do |meth|
-        assert_respond_to meth, value
+        assert_respond_to meth, args
       end
-      assert_equal 'some/file/path', value.file_path
+      assert_equal path, args.file_path
     end
 
   end

data/test/unit/view_handler_tests.rb

@@ -2,6 +2,7 @@ require 'assert'
 require 'deas/view_handler'
 
 require 'deas/test_helpers'
+require 'deas/template_source'
 require 'test/support/view_handlers'
 
 module Deas::ViewHandler
@@ -73,20 +74,34 @@ module Deas::ViewHandler
 
     should "render templates" do
       render_args = test_runner(RenderViewHandler).run
-      assert_equal "my_template",        render_args.template_name
-      assert_equal({ :some => :option }, render_args.options)
+      assert_equal "my_template",      render_args.template_name
+      assert_equal({:some => 'local'}, render_args.locals)
+    end
+
+    should "render templates on a given source" do
+      render_args = test_runner(SourceRenderViewHandler).run
+      assert_kind_of Deas::TemplateSource, render_args.source
+      assert_equal "my_template",      render_args.template_name
+      assert_equal({:some => 'local'}, render_args.locals)
     end
 
     should "render partial templates" do
       partial_args = test_runner(PartialViewHandler).run
-      assert_equal "my_partial",        partial_args.template_name
-      assert_equal({:some => 'locals'}, partial_args.locals)
+      assert_equal "my_partial",       partial_args.template_name
+      assert_equal({:some => 'local'}, partial_args.locals)
+    end
+
+    should "render partial templates on a given source" do
+      partial_args = test_runner(SourcePartialViewHandler).run
+      assert_kind_of Deas::TemplateSource, partial_args.source
+      assert_equal "my_partial",       partial_args.template_name
+      assert_equal({:some => 'local'}, partial_args.locals)
     end
 
     should "send files" do
       send_file_args = test_runner(SendFileViewHandler).run
-      assert_equal "my_file.txt",        send_file_args.file_path
-      assert_equal({ :some => :option }, send_file_args.options)
+      assert_equal "my_file.txt",      send_file_args.file_path
+      assert_equal({:some => :option}, send_file_args.options)
     end
 
   end