deas 0.28.0 → 0.29.0

data/lib/deas/route.rb

@@ -16,14 +16,14 @@ module Deas
     end
 
     def run(sinatra_call)
-      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,
+      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
       })
 

data/lib/deas/runner.rb

@@ -1,3 +1,8 @@
+# need to define class immediately b/c of circular requires:
+# - runner -> router -> route -> deas_runner -> runner
+module Deas; end
+class Deas::Runner; end
+
 require 'rack/utils'
 require 'deas/logger'
 require 'deas/router'

data/lib/deas/template_engine.rb

@@ -13,15 +13,15 @@ module Deas
       @logger = @opts['logger'] || Deas::NullLogger.new
     end
 
-    def render(template_name, view_handler, locals)
+    def render(template_name, view_handler, locals, &content)
       raise NotImplementedError
     end
 
-    def partial(template_name, locals)
+    def partial(template_name, locals, &content)
       raise NotImplementedError
     end
 
-    def capture_partial(template_name, locals, &content)
+    def compile(template_name, compiled_content)
       raise NotImplementedError
     end
 
@@ -29,7 +29,7 @@ module Deas
 
   class NullTemplateEngine < TemplateEngine
 
-    def render(template_name, view_handler, locals)
+    def render(template_name, view_handler, locals, &content)
       template_file = self.source_path.join(template_name).to_s
       unless File.exists?(template_file)
         raise ArgumentError, "template file `#{template_file}` does not exist"
@@ -37,12 +37,12 @@ module Deas
       File.read(template_file)
     end
 
-    def partial(template_name, locals)
+    def partial(template_name, locals, &content)
       render(template_name, nil, locals)
     end
 
-    def capture_partial(template_name, locals, &content)
-      render(template_name, nil, locals)
+    def compile(template_name, compiled_content)
+      compiled_content  # no-op, pass-thru - just return the given content
     end
 
   end

data/lib/deas/template_source.rb

@@ -14,8 +14,9 @@ module Deas
     def initialize(path, logger = nil)
       @path = path.to_s
       @default_opts = {
-        'source_path' => @path,
-        'logger'      => logger || Deas::NullLogger.new
+        'source_path'          => @path,
+        'logger'               => logger || Deas::NullLogger.new,
+        'deas_template_source' => self
       }
       @engines = Hash.new{ |h,k| Deas::NullTemplateEngine.new(@default_opts) }
     end
@@ -33,16 +34,16 @@ module Deas
       @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)
+    def render(template_name, view_handler, locals, &content)
+      [ view_handler.class.layouts,
+        template_name
+      ].flatten.reverse.inject(content) do |render_proc, name|
+        proc{ get_engine(name).render(name, view_handler, locals, &render_proc) }
+      end.call
     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)
+    def partial(template_name, locals, &content)
+      get_engine(template_name).partial(template_name, locals, &content)
     end
 
     private

data/lib/deas/test_runner.rb

@@ -1,16 +1,23 @@
 require 'rack/multipart'
 require 'deas/router'
 require 'deas/runner'
+require 'deas/view_handler'
 
 module Deas
 
+  InvalidServiceHandlerError = Class.new(StandardError)
+
   class TestRunner < Runner
 
     attr_reader :return_value
 
     def initialize(handler_class, args = nil)
-      args = (args || {}).dup
+      if !handler_class.include?(Deas::ViewHandler)
+        raise InvalidServiceHandlerError, "#{handler_class.inspect} is not a"\
+                                          " Deas::ServiceHandler"
+      end
 
+      args = (args || {}).dup
       super(handler_class, {
         :request  => args.delete(:request),
         :response => args.delete(:response),

data/lib/deas/version.rb

@@ -1,3 +1,3 @@
 module Deas
-  VERSION = "0.28.0"
+  VERSION = "0.29.0"
 end

data/test/support/view_handlers.rb

@@ -8,11 +8,13 @@ end
 class TestRunnerViewHandler
   include Deas::ViewHandler
 
+  attr_reader :before_called, :init_called
   attr_accessor :custom_value
 
-  def run!
-    'run has run'
-  end
+  before{ @before_called = true }
+
+  def init!; @init_called = true; end
+  def run!;  'run has run';       end
 
 end
 

data/test/unit/route_tests.rb

@@ -59,13 +59,13 @@ 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,
-        :session         => @fake_sinatra_call.session,
-        :params          => @fake_sinatra_call.params,
-        :logger          => @fake_sinatra_call.settings.logger,
-        :router          => @fake_sinatra_call.settings.router,
+        :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
@@ -98,8 +98,8 @@ class Deas::Route
     attr_reader :run_called
     attr_reader :handler_class, :args
     attr_reader :sinatra_call
-    attr_reader :request, :response, :params
-    attr_reader :logger, :router, :session
+    attr_reader :request, :response, :session, :params
+    attr_reader :logger, :router, :template_source
 
     def initialize
       @run_called = false
@@ -108,13 +108,13 @@ 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]
-      @session         = args[:session]
-      @params          = args[:params]
-      @logger          = args[:logger]
-      @router          = args[:router]
+      @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
 

data/test/unit/runner_tests.rb

@@ -38,17 +38,12 @@ class Deas::Runner
       assert_nil subject.request
       assert_nil subject.response
       assert_nil subject.session
-      assert_kind_of ::Hash, subject.params
+      assert_equal ::Hash.new, subject.params
       assert_kind_of Deas::NullLogger, subject.logger
       assert_kind_of Deas::Router, subject.router
       assert_kind_of Deas::NullTemplateSource, subject.template_source
     end
 
-    should "default its params" do
-      runner = @runner_class.new(TestRunnerViewHandler)
-      assert_equal ::Hash.new, runner.params
-    end
-
     should "not implement any actions" do
       assert_raises(NotImplementedError){ subject.halt }
       assert_raises(NotImplementedError){ subject.redirect }

data/test/unit/template_engine_tests.rb

@@ -20,7 +20,7 @@ class Deas::TemplateEngine
     subject{ @engine }
 
     should have_readers :source_path, :logger, :opts
-    should have_imeths :render, :partial, :capture_partial
+    should have_imeths :render, :partial, :compile
 
     should "default its source path" do
       assert_equal Pathname.new(nil.to_s), subject.source_path
@@ -35,7 +35,7 @@ class Deas::TemplateEngine
       assert_instance_of Deas::NullLogger, subject.logger
     end
 
-    should "allow custom source loggers" do
+    should "allow custom loggers" do
       logger = 'a-logger'
       engine = Deas::TemplateEngine.new('logger' => logger)
       assert_equal logger, engine.logger
@@ -63,9 +63,9 @@ class Deas::TemplateEngine
       end
     end
 
-    should "raise NotImplementedError on `capture_partial`" do
+    should "raise NotImplementedError on `compile`" do
       assert_raises NotImplementedError do
-        subject.capture_partial(@template_name, @locals, &@content)
+        subject.compile(@template_name, Factory.text)
       end
     end
 
@@ -97,12 +97,6 @@ class Deas::TemplateEngine
       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
@@ -111,9 +105,11 @@ class Deas::TemplateEngine
       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
+
+    should "return any given content with its `compile` method" do
+      exp = Factory.string
+      assert_equal exp, subject.compile(Factory.path, exp)
     end
 
   end

data/test/unit/template_source_tests.rb

@@ -1,6 +1,7 @@
 require 'assert'
 require 'deas/template_source'
 
+require 'deas/logger'
 require 'deas/template_engine'
 
 class Deas::TemplateSource
@@ -26,7 +27,7 @@ class Deas::TemplateSource
 
     should have_readers :path, :engines
     should have_imeths :engine, :engine_for?
-    should have_imeths :render, :partial, :capture_partial
+    should have_imeths :render, :partial
 
     should "know its path" do
       assert_equal @source_path.to_s, subject.path
@@ -49,26 +50,30 @@ class Deas::TemplateSource
     should "register with default options" do
       subject.engine 'test', @test_engine
       exp_opts = {
-        'source_path' => subject.path,
-        'logger'      => @logger
+        'source_path'          => subject.path,
+        'logger'               => @logger,
+        'deas_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,
-        'an' => 'opt'
+        'source_path'          => subject.path,
+        'logger'               => @logger,
+        'deas_template_source' => subject,
+        'an'                   => 'opt'
       }
       assert_equal exp_opts, subject.engines['test'].opts
 
       subject.engine('test', @test_engine, {
-        'source_path' => 'something',
-        'logger'      => 'another'
+        'source_path'          => 'something',
+        'logger'               => 'another',
+        'deas_template_source' => 'tempsource'
       })
       exp_opts = {
-        'source_path' => 'something',
-        'logger'      => 'another'
+        'source_path'          => 'something',
+        'logger'               => 'another',
+        'deas_template_source' => 'tempsource'
       }
       assert_equal exp_opts, subject.engines['test'].opts
 
@@ -99,7 +104,7 @@ class Deas::TemplateSource
       @source.engine('test', TestEngine)
       @source.engine('json', JsonEngine)
 
-      @v = TestServiceHandler
+      @v = TestViewHandler.new
       @l = {}
       @c = Proc.new{}
     end
@@ -110,15 +115,15 @@ class Deas::TemplateSource
     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
+      exp = "render-test-engine on test_template\n"
+      assert_equal exp, subject.render('test_template', @v, @l)
     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
+      exp = 'render-json-engine'
+      assert_equal exp, subject.render('template', @v, @l)
     end
 
     should "use the null template engine when an engine can't be found" do
@@ -129,47 +134,39 @@ class Deas::TemplateSource
 
   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
+  class RenderLayoutsTests < RenderOrPartialTests
+    desc "when rendering a template in layouts"
+    setup do
+      @v = LayoutViewHandler.new
     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
+    should "render view handlers with layouts" do
+      exp = "render-test-engine on test_layout1\n"\
+            "render-test-engine on test_layout2\n"\
+            "render-test-engine on test_template\n"
+      assert_equal exp, subject.render('test_template', @v, @l)
     end
 
   end
 
-  class CapturePartialTests < RenderOrPartialTests
-    desc "when capture partial rendering a template"
+  class PartialTests < RenderTests
+    desc "when 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
+    should "call `partial` on the configured engine" do
+      exp = "partial-test-engine\n"
+      assert_equal exp, subject.partial('test_template', @l)
     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
+      exp = 'partial-json-engine'
+      assert_equal exp, subject.partial('template', @l)
     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)
+        subject.partial(Factory.string, @l)
       end
     end
 
@@ -193,11 +190,12 @@ class Deas::TemplateSource
   end
 
   class TestEngine < Deas::TemplateEngine
-    def render(template_name, view_handler, locals)
-      'render-test-engine'
+    def render(template_name, view_handler, locals, &content)
+      "render-test-engine on #{template_name}\n" +
+      (content || proc{}).call.to_s
     end
-    def partial(template_name, locals)
-      'partial-test-engine'
+    def partial(template_name, locals, &content)
+      "partial-test-engine\n" + (content || proc{}).call.to_s
     end
     def capture_partial(template_name, locals, &content)
       'capture-partial-test-engine'
@@ -205,7 +203,7 @@ class Deas::TemplateSource
   end
 
   class JsonEngine < Deas::TemplateEngine
-    def render(template_name, view_handler, locals)
+    def render(template_name, view_handler, locals, &content)
       'render-json-engine'
     end
     def partial(template_name, locals)
@@ -216,6 +214,12 @@ class Deas::TemplateSource
     end
   end
 
-  TestServiceHandler = Class.new
+  TestViewHandler = Class.new do
+    def self.layouts; []; end
+  end
+
+  LayoutViewHandler = Class.new do
+    def self.layouts; ['test_layout1', 'test_layout2']; end
+  end
 
 end

data/test/unit/test_runner_tests.rb

@@ -11,6 +11,7 @@ class Deas::TestRunner
   class UnitTests < Assert::Context
     desc "Deas::TestRunner"
     setup do
+      @handler_class = TestRunnerViewHandler
       @runner_class = Deas::TestRunner
     end
     subject{ @runner_class }
@@ -26,25 +27,31 @@ class Deas::TestRunner
     setup do
       @params = { 'value' => '1' }
       @args = {
-        :request         => 'a-request',
-        :response        => 'a-response',
-        :session         => 'a-session',
-        :params          => @params,
-        :logger          => 'a-logger',
-        :router          => 'a-router',
+        :request  => 'a-request',
+        :response => 'a-response',
+        :session  => 'a-session',
+        :params   => @params,
+        :logger   => 'a-logger',
+        :router   => 'a-router',
         :template_source => 'a-source'
       }
 
       @norm_params_spy = Deas::Runner::NormalizedParamsSpy.new
       Assert.stub(NormalizedParams, :new){ |p| @norm_params_spy.new(p) }
 
-      @runner = @runner_class.new(TestRunnerViewHandler, @args)
+      @runner = @runner_class.new(@handler_class, @args)
     end
     subject{ @runner }
 
     should have_readers :return_value
     should have_imeths :run
 
+    should "raise an invalid error when not passed a view handler" do
+      assert_raises(Deas::InvalidServiceHandlerError) do
+        @runner_class.new(Class.new)
+      end
+    end
+
     should "super its standard args" do
       assert_equal 'a-request',  subject.request
       assert_equal 'a-response', subject.response
@@ -61,10 +68,18 @@ class Deas::TestRunner
     end
 
     should "write any non-standard args on the handler" do
-      runner = @runner_class.new(TestRunnerViewHandler, :custom_value => 42)
+      runner = @runner_class.new(@handler_class, :custom_value => 42)
       assert_equal 42, runner.handler.custom_value
     end
 
+    should "not have called its service handlers before callbacks" do
+      assert_not_true subject.handler.before_called
+    end
+
+    should "have called init on its service handler" do
+      assert_true subject.handler.init_called
+    end
+
     should "not set a return value on initialize" do
       assert_nil subject.return_value
     end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: deas
 version: !ruby/object:Gem::Version 
-  hash: 111
+  hash: 107
   prerelease: 
   segments: 
   - 0
-  - 28
+  - 29
   - 0
-  version: 0.28.0
+  version: 0.29.0
 platform: ruby
 authors: 
 - Kelly Redding
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2014-11-12 00:00:00 Z
+date: 2015-01-08 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   requirement: &id001 !ruby/object:Gem::Requirement 
@@ -164,6 +164,8 @@ files:
 - test/support/routes.rb
 - test/support/template.erb
 - test/support/template.json
+- test/support/test_layout1.test
+- test/support/test_layout2.test
 - test/support/test_template.test
 - test/support/view_handlers.rb
 - test/support/views/_info.erb
@@ -244,6 +246,8 @@ test_files:
 - test/support/routes.rb
 - test/support/template.erb
 - test/support/template.json
+- test/support/test_layout1.test
+- test/support/test_layout2.test
 - test/support/test_template.test
 - test/support/view_handlers.rb
 - test/support/views/_info.erb