pakada-render 0.2.1 → 0.3.0

data/config.ru

@@ -5,17 +5,12 @@ require "awesome_print"
 class ::MyModule
   include Pakada::Module
   @path = Pathname.new(".")
-  @dependencies << Pakada::Dispatch
+  @dependencies << Pakada::Dispatch << Pakada::Render
   
   def routes
     route :test, "/", &controller(:foo).action(:bar)
   end
 end
 
-Pakada.instance(:default) {|ins|
-  ins.urls = ["/"]
-  ins.modules = MyModule, Pakada::Render
-}
-
 Pakada.boot
 run Pakada

data/lib/pakada/render.rb

@@ -15,22 +15,50 @@ class Pakada::Render
   attr_reader :load_path, :template_map
   
   def initialize
-    Pakada.safety(RenderingContext).send :include, Hooked
+    Pakada.safety(Pakada::Render::RenderingContext).send :include, Hooked
   end
   
   def hooks
     if Pakada[:dispatch]
-      Pakada[:dispatch].after :request, method(:render_layout)
-      Pakada.safety(Pakada::Dispatch::Controller).tap {|c|
-        c.around(:included) {|inner, klass|
-          inner.call klass
-          klass.send :include, Pakada.safety(Pakada::Render::Controller)
-          klass.after :new, method(:render_controller)
-        }
-      }
+      Pakada[:dispatch].after :create_controller, method(:make_renderable)
+      Pakada[:dispatch].around :request, method(:render_layout)
+    end
+  end
+  
+  def make_renderable(cls)
+    cls.send :include, Pakada.safety(Pakada::Render::Controller)
+    unless cls.options.key? :render
+      cls.options[:render] = true
+    end
+    unless cls.options.key? :layout
+      cls.options[:layout] = true
+    end
+    cls.instance_after :process, method(:render_controller)
+  end
+  
+  def render_controller(controller)
+    unless controller.options[:layout]
+      controller.request.env["pakada.render.layout"] = false
+    end
+    
+    if controller.options[:render]
+      controller.response.write controller.render
     end
   end
   
+  def render_layout(request, env)
+    key = "pakada.render.layout"
+    request.call(env).tap {|response|
+      env[key] = true unless env.key? key
+      if env[key]
+        response[1].delete "Content-Length"
+        content = []
+        response[2].each {|chunk| content << chunk }
+        response[2] = [render!(:layout, :content => content)]
+      end
+    }
+  end
+  
   def boot
     Pakada.modules.each_value {|mod|
       mod.extend Pakada.safety(Pakada::Render::Rendering)
@@ -62,16 +90,4 @@ class Pakada::Render
       map
     }
   end
-  
-  def render_controller(controller)
-    controller.response.write controller.render if controller.render?
-  end
-  
-  def render_layout(response)
-    content = []
-    response[2].each {|chunk| content << chunk }
-    response[2] = [render!(:layout, :content => content)]
-    
-    response[1].delete "Content-Length"
-  end
 end

data/lib/pakada/render/controller.rb

@@ -1,45 +1,17 @@
 class Pakada::Render
   module Controller
-    def self.included(klass)
-      klass.extend Pakada.safety(self::ClassMethods)
-      klass.instance_variable_set :@rendering_rules, :render => [], :dont_render => []
-    end
-    
     def render(template = nil, additional_locals = {})
       if Hash === template
         template, additional_locals = nil, template
       end
-      template ||= options.values_at(:module, :controller, :action).join("/")
+      
+      template ||= options.values_at(:module, :controller, :action).compact.join("/")
 
       locals = instance_variables.inject({}) {|locals, key|
-        locals[key.to_sym] = instance_variable_get(key)
-        locals
+        locals[key.to_sym] = instance_variable_get(key); locals
       }.merge(additional_locals)
-      Pakada[options[:module]].render template.to_sym, locals
-    end
-    
-    def render?
-      action = options[:action]
-      render, dont_render = *self.class.rendering_rules.values_at(:render, :dont_render)
-      
-      !dont_render.include?(action) && (
-        !dont_render.include?(:*) || render.include?(action))
-    end
-    
-    module ClassMethods
-      attr_reader :rendering_rules
-      
-      def dont_render(action = nil, *more_actions)
-        if action
-          rendering_rules[:dont_render].push action, *more_actions
-        else
-          rendering_rules[:dont_render] = [:*]
-        end
-      end
       
-      def render(action, *more_actions)
-        rendering_rules[:render].push action, *more_actions
-      end
+      Pakada[options[:module]].render template.to_sym, locals
     end
   end
 end

data/lib/pakada/render/version.rb

@@ -1,5 +1,5 @@
 class Pakada
   class Render
-    VERSION = "0.2.1"
+    VERSION = "0.3.0"
   end
 end

data/spec/controller_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe Pakada::Render::Controller do
   let(:controller) {
-    Pakada.safety(Pakada::Dispatch::Controller).create {
+    Pakada[:dispatch].create_controller {
       include Pakada.safety(Pakada::Render::Controller)
       action(:bar) {}
     }
@@ -22,27 +22,6 @@ describe Pakada::Render::Controller do
     Pakada.modules[:foo_module] = foo_module
   }
   
-  context ".included(klass)" do
-    let(:klass) { stub "includer class" }
-    
-    it "extends klass with ClassMethods" do
-      class_methods = Pakada.safety(Pakada::Render::Controller::ClassMethods)
-      klass.should_receive(:extend).with class_methods
-      
-      Pakada.safety(Pakada::Render::Controller).included klass
-    end
-    
-    it "defaults #rendering_rules to empty Arrays" do
-      Pakada.safety(Pakada::Render::Controller).included klass
-      
-      klass.rendering_rules[:render].should be_an(Array)
-      klass.rendering_rules[:render].should be_empty
-      
-      klass.rendering_rules[:dont_render].should be_an(Array)
-      klass.rendering_rules[:dont_render].should be_empty
-    end
-  end
-  
   context "#render(template, additional_locals)" do
     let(:renderer) { stub "renderer" }
     
@@ -89,58 +68,4 @@ describe Pakada::Render::Controller do
       obj.render
     end
   end
-  
-  context "#render?" do
-    it "returns true by default" do
-      obj.render?.should be_true
-    end
-    
-    it "returns false if dont_render rules include action" do
-      controller.dont_render :bar
-      
-      obj.render?.should be_false
-    end
-    
-    it "returns false if dont_render rules include wildcard" do
-      controller.dont_render
-      
-      obj.render?.should be_false
-    end
-    
-    it "prioritizes render rules" do
-      controller.dont_render
-      controller.render :bar
-      
-      obj.render?.should be_true
-    end
-  end
-  
-  context ".render(action, *more_actions)" do
-    it "adds each action to the render ruleset" do
-      controller.tap {|c|
-        c.render :foo, :bar, :baz
-        c.rendering_rules[:render].should include(:foo)
-        c.rendering_rules[:render].should include(:bar)
-        c.rendering_rules[:render].should include(:baz)
-      }
-    end
-  end
-  
-  context ".dont_render(action, *more_actions)" do
-    it "adds each action to the dont_render ruleset" do
-      controller.tap {|c|
-        c.dont_render :foo, :bar, :baz
-        c.rendering_rules[:dont_render].should include(:foo)
-        c.rendering_rules[:dont_render].should include(:bar)
-        c.rendering_rules[:dont_render].should include(:baz)
-      }
-    end
-  end
-  
-  context ".dont_render" do
-    it "adds a wildcard to the dont_render ruleset" do
-      controller.dont_render
-      controller.rendering_rules[:dont_render].should include(:*)
-    end
-  end
 end

data/spec/render_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 require "fileutils"
 
 describe Pakada::Render do
-  let(:render) { Pakada::Render.new }
+  let(:render) { Pakada[:render] }
   
   context "#initialize" do
     it "makes RenderingContext hookable" do
@@ -12,7 +12,7 @@ describe Pakada::Render do
   end
   
   context "#hooks" do
-    let(:dispatch) { stub "dispatch module" }
+    let(:dispatch) { stub "dispatch module", :around => nil }
     
     before {
       Pakada.modules[:dispatch] = dispatch
@@ -20,36 +20,17 @@ describe Pakada::Render do
     }
     
     it "hooks Pakada::Dispatch#request with #render_layout" do
-      dispatch.should_receive(:after) {|method, block|
+      dispatch.should_receive(:around) {|method, block|
         method.should equal(:request)
         block.should == render.method(:render_layout)
       }
       render.hooks
     end
     
-    let(:klass) { stub "controller class", :include => nil }
-    
-    it "hooks Pakada::Dispatch::Controller.included to include Controller" do
-      Pakada.safety(Pakada::Dispatch::Controller).should_receive(:around) {|method, &block|
-        method.should equal(:included)
-        klass.should_receive(:send).with :include, Pakada.safety(Pakada::Render::Controller)
-        klass.should_receive(:after) {|method, block|
-          method.should equal(:new)
-          block.should == render.method(:render_controller)
-        }
-        block.call stub(:call => nil), klass
-      }
-      render.hooks
-    end
-    
-    it "hooks Pakada::Dispatch::Controller.included to hook controller#new with #render_controller" do
-      Pakada.safety(Pakada::Dispatch::Controller).should_receive(:around) {|method, &block|
-        method.should equal(:included)
-        klass.should_receive(:after) {|method, block|
-          method.should equal(:new)
-          block.should == render.method(:render_controller)
-        }
-        block.call stub(:call => nil), klass
+    it "hooks Pakada::Dispatch#create_controller with #make_renderable" do
+      dispatch.should_receive(:after) {|method, block|
+        method.should equal(:create_controller)
+        block.should == render.method(:make_renderable)
       }
       render.hooks
     end
@@ -158,46 +139,115 @@ describe Pakada::Render do
     end
   end
   
-  context "#render_controller" do
-    let(:controller) { stub "controller", :response => stub("response") }
-    let(:result) { stub "result" }
+  context "#make_renderable(controller_class)" do
+    let(:controller_class) { Pakada[:dispatch].create_controller {} }
+    
+    it "extends the controller class with Pakada::Render::Controller" do
+      render.make_renderable controller_class
+      
+      controller = Pakada.safety(Pakada::Render::Controller)
+      controller_class.included_modules.should include(controller)
+    end
     
-    before { controller.stub :render => result }
+    it "sets the :render option to true" do
+      render.make_renderable controller_class
+      controller_class.options[:render].should be_true
+    end
+    
+    it "doesn't set :render if already set" do
+      controller_class.options[:render] = false
+      render.make_renderable controller_class
+      controller_class.options[:render].should be_false
+    end
+    
+    it "sets the :layout option to true" do
+      render.make_renderable controller_class
+      controller_class.options[:layout].should be_true
+    end
+    
+    it "doesn't set :layout if already set" do
+      controller_class.options[:layout] = false
+      render.make_renderable controller_class
+      controller_class.options[:layout].should be_false
+    end
+    
+    it "hooks controller_class#process with #render_controller" do
+      controller_class.should_receive(:instance_after) {|method, block|
+        method.should equal(:process)
+        block.should == render.method(:render_controller)
+      }
+      render.make_renderable controller_class
+    end
+  end
+  
+  context "#render_controller(controller)" do
+    let(:env) { {} }
+    let(:controller) { Pakada[:dispatch].create_controller {}.new env }
     
-    it "renders the controller's template" do
-      controller.stub :render? => true
-      controller.response.should_receive(:write).with result
+    it "sets env[pakada.render.layout] to false if :layout option is false" do
+      controller.options[:layout] = false
+      render.render_controller controller
+      controller.request.env["pakada.render.layout"].should be_false
       
+      controller.request.env["pakada.render.layout"] = true
+      controller.options[:layout] = true
       render.render_controller controller
+      controller.request.env["pakada.render.layout"].should be_true
     end
     
-    it "doesn't render if it's not supposed to" do
-      controller.stub :render? => false
-      controller.response.should_not_receive :write
+    let(:rendered_controller) { stub "rendered controller" }
+    
+    it "renders the controller into the response body" do
+      controller.should_receive(:render) { rendered_controller }
+      controller.response.should_receive(:write).with rendered_controller
       
+      controller.options[:render] = true
+      render.render_controller controller
+    end
+    
+    it "doesn't render the controller if :render is false" do
+      render.should_not_receive :render
+      controller.options[:render] = false
       render.render_controller controller
     end
   end
   
-  context "#render_layout" do
-    let(:response) {
-      [200, {"Content-Length" => "123"}, [content]]
-    }
-    let(:content) { stub "content" }
+  context "#render_layout(request, env)" do
+    let(:env) { {} }
+    let(:request) { proc {|env| response } }
+    let(:response) { [200, {"Content-Length" => "123"}, []] }
+    
+    before { render.boot }
     
-    before { render.stub :render! }
+    it "defaults env[pakada.render.layout] to true" do
+      render.render_layout request, env
+      env["pakada.render.layout"].should be_true
+    end
+    
+    it "doesn't render if env[pakada.render.layout] is false" do
+      render.should_not_receive :render
+      env["pakada.render.layout"] = false
+      render.render_layout request, env
+    end
+    
+    it "deletes the Content-Length header" do
+      render.render_layout request, env
+      response[1].key?("Content-Length").should be_false
+    end
     
-    it "render's a layout around the content" do
+    let(:content) { stub "content" }
+    let(:renderer) { stub "renderer" }
+    
+    it "renders the layout passing the response body as :content local" do
       render.should_receive(:render!) {|template, locals|
         template.should equal(:layout)
         locals[:content].should == [content]
+        renderer
       }
-      render.render_layout response
-    end
-    
-    it "removes the Content-Length header" do
-      render.render_layout response
-      response[1]["Content-Length"].should be_nil
+      response[2] = [content]
+      
+      render.render_layout request, env
+      response[2].should == [renderer]
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pakada-render
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-03 00:00:00.000000000Z
+date: 2011-09-11 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pakada
-  requirement: &72368450 !ruby/object:Gem::Requirement
+  requirement: &74264980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *72368450
+  version_requirements: *74264980
 - !ruby/object:Gem::Dependency
   name: tilt
-  requirement: &72368050 !ruby/object:Gem::Requirement
+  requirement: &74264710 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *72368050
+  version_requirements: *74264710
 - !ruby/object:Gem::Dependency
   name: hike
-  requirement: &72367660 !ruby/object:Gem::Requirement
+  requirement: &74264400 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *72367660
+  version_requirements: *74264400
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &72367330 !ruby/object:Gem::Requirement
+  requirement: &74263580 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *72367330
+  version_requirements: *74263580
 - !ruby/object:Gem::Dependency
   name: fakefs
-  requirement: &72366750 !ruby/object:Gem::Requirement
+  requirement: &74263070 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,7 +65,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *72366750
+  version_requirements: *74263070
 description: 
 email:
 - lars.gierth@gmail.com