pancake 0.1.10 → 0.1.12

data/lib/pancake/stack/router.rb

@@ -2,11 +2,19 @@ module Pancake
   class Stack
     class Router < Pancake::Router; end
     inheritable_inner_classes :Router
-
-    class_inheritable_accessor :_router
+    cattr_writer :_router
 
     @_router = self::Router.new
 
+    def self._router
+      @_router ||= begin
+        r = self::Router.new
+        unless self == Pancake::Stack
+          r.router = superclass._router.router.dup
+        end
+        r
+      end
+    end
     # Resets the router to use the stacks namespaced router.
     # This allows a router to mixin a module, and have that module
     # mixed in to child stacks/routers.  Effectively, this will reset the scope of inheritance so that a stack type can have particular route helpers

data/lib/pancake/stack/stack.rb

@@ -43,7 +43,7 @@ module Pancake
       Pancake.configuration.stacks[@app_name] = self
 
       # setup the configuration for this stack
-      Pancake.configuration.configs[@app_name] = opts[:config] if opts [:config]
+      Pancake.configuration.configs[@app_name] = opts[:config] if opts[:config]
       self.configuration(@app_name)
       yield self.configuration(@app_name) if block_given?
 
@@ -62,5 +62,38 @@ module Pancake
       app = new(nil, opts, &block)
       Pancake.configuration.configs[app.app_name].router
     end # stackup
+
+    # Creates a bootloader hook(s) of the given name. That are inheritable
+    # This will create hooks for use in a bootloader (but will not create the bootloader itself!)
+    #
+    # @example
+    #   MyStack.create_bootloader_hook(:before_stuff, :after_stuff)
+    #
+    #   MyStack.before_stuff do
+    #     # stuff to do before stuff
+    #   end
+    #
+    #   MyStack.after_stuff do
+    #     # stuff to do after stuff
+    #   enc
+    #
+    #   MyStack.before_stuff.each{|blk| blk.call}
+    #
+    # @api public
+    def self.create_bootloader_hook(*hooks)
+      hooks.each do |hook|
+        class_inheritable_reader "_#{hook}"
+        instance_variable_set("@_#{hook}", [])
+
+        class_eval <<-RUBY
+          def self.#{hook}(&blk)
+            _#{hook} << blk if blk
+            _#{hook}
+          end
+        RUBY
+      end
+    end
+
+    create_bootloader_hook :before_build_stack, :before_mount_applications, :after_initialize_application, :after_build_stack
   end # Stack
 end # Pancake

data/lib/pancake/stacks/short/bootloaders.rb

@@ -1,4 +1,4 @@
-Pancake::Stacks::Short::BootLoader.add(:paths) do
+Pancake::Stacks::Short::BootLoader.add(:paths, :before => :load_mounted_inits  ) do
   def run!
     stack_class.push_paths :public, "public"
 
@@ -6,7 +6,7 @@ Pancake::Stacks::Short::BootLoader.add(:paths) do
   end
 end
 
-Pancake::Stacks::Short::BootLoader.add(:default_middlewares, :before => :build_stack) do
+Pancake::Stacks::Short::BootLoader.add(:default_middlewares, :before => :load_mounted_inits) do
   def run!
     stack_class.stack(:static_files).use(Pancake::Middlewares::Static, stack_class)
   end

data/lib/pancake/stacks/short/controller.rb

@@ -63,7 +63,16 @@ module Pancake
 
           # set the response header
           headers["Content-Type"] = ct
-          Rack::Response.new(self.send(params["action"]), status, headers).finish
+
+          result = self.send(params['action'])
+          case result
+          when Array
+            result
+          when Rack::Response
+            result.finish
+          else
+            Rack::Response.new(self.send(params["action"]), status, headers).finish
+          end
 
         rescue Errors::HttpError => e
           if logger
@@ -72,8 +81,12 @@ module Pancake
           end
           handle_request_exception(e)
         rescue Exception => e
-          server_error = Errors::Server.new
-          server_error.exceptions << e
+          if Pancake.handle_errors?
+            server_error = Errors::Server.new
+            server_error.exceptions << e
+          else
+            server_error = e
+          end
           handle_request_exception(server_error)
         end
 
@@ -90,7 +103,7 @@ module Pancake
         end
 
         def handle_request_exception(error)
-          raise error unless Pancake.handle_errors?
+          raise(error.class, error.message, error.backtrace) unless Pancake.handle_errors?
           self.status = error.code
           result = instance_exec error, &self.class.handle_exception
           Rack::Response.new(result, status, headers).finish

data/lib/pancake/test/matchers.rb

@@ -0,0 +1,39 @@
+module Pancake
+  module Test
+    module Matchers
+      class MountMatcher
+        def initialize(expected_app, path)
+          @expected_app, @path = expected_app, path
+        end
+
+        def matches?(target)
+          @target = target
+          @ma = @target::Router.mounted_applications.detect{|m| m.mounted_app == @expected_app}
+          if @ma
+            @ma.mounted_app == @expected_app && @ma.mount_path == @path
+          else
+            false
+          end
+        end
+
+        def failure_message_for_should
+          if @ma
+            "Expected #{@target} to mount #{@expected_app} at #{@path.inspect} but was mounted at #{@ma.mount_path.inspect}"
+          else
+            "Expected #{@target} to mount #{@expected_app} but it was not mounted"
+          end
+        end
+
+        def failure_message_for_should_not
+          if @ma
+            "Expected #{@target} to not implement #{@expected_app} at #{@path} but it was mounted there"
+          end
+        end
+      end # MountMatcher
+
+      def mount(expected, path)
+        MountMatcher.new(expected, path)
+      end
+    end # Matchers
+  end # Test
+end # Pancake

data/lib/pancake.rb

@@ -35,6 +35,11 @@ module Pancake
     autoload :Static,       "pancake/middlewares/static"
     autoload :Logger,     "pancake/middlewares/logger"
   end
+
+  module Test
+    autoload :Matchers,    "pancake/test/matchers"
+  end
+
 end
 
 require 'pancake/paths'

data/spec/pancake/bootloaders_spec.rb

@@ -1,42 +1,42 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
 describe "Pancake::Stack::BootLoader" do
-  
+
   before(:each) do
     $captures = []
-    
+
     class ::FooStack < Pancake::Stack
       roots << File.join(Pancake.get_root(__FILE__), "..", "fixtures", "foo_stack")
     end
   end
-  
+
   after(:each) do
     clear_constants(:FooStack)
   end
-  
+
   it "should not add the bootloader without it having a run! method" do
     lambda do
       FooStack::BootLoader.add(:foo){|s,c| :here }
     end.should raise_error
   end
-  
+
   it "should allow me to add an application specific BootLoader" do
-    FooStack::BootLoader.add(:my_initializer){ def run!; :foo; end}  
+    FooStack::BootLoader.add(:my_initializer){ def run!; :foo; end}
     FooStack::BootLoader[:my_initializer].call({}).should == :foo
   end
-  
+
   it "should provide a bootloader instance" do
     FooStack::BootLoader.add(:my_initializer){ def run!; :foo; end}
     FooStack::BootLoader[:my_initializer].should inherit_from(Pancake::BootLoaderMixin::Base)
   end
-  
+
   it "should allow me to add multiple boot loaders" do
     FooStack::BootLoader.add(:foo){ def run!; :foo; end}
     FooStack::BootLoader.add(:bar){ def run!; :bar; end}
     FooStack::BootLoader[:foo].call({}).should == :foo
     FooStack::BootLoader[:bar].call({}).should == :bar
   end
-  
+
   it "should allow me to add a bootloader before another" do
     $captures.should be_empty
     FooStack::BootLoader.add(:foo){ def run!; $captures << :foo; end}
@@ -45,7 +45,7 @@ describe "Pancake::Stack::BootLoader" do
     FooStack.new
     $captures.should == [:foo, :baz, :bar]
   end
-  
+
   it "should allow me to add a bootloader after another" do
     $captures.should be_empty
     FooStack::BootLoader.add(:foo){ def run!; $captures << :foo; end}
@@ -54,7 +54,7 @@ describe "Pancake::Stack::BootLoader" do
     FooStack.new
     $captures.should == [:foo, :baz, :bar]
   end
-  
+
   it "should provide an arbitrarily complex setup" do
     $captures.should be_empty
     FooStack::BootLoader.add(:foo                       ){ def run!; $captures << :foo; end}
@@ -63,47 +63,48 @@ describe "Pancake::Stack::BootLoader" do
     FooStack::BootLoader.add(:paz,    :before => :baz   ){ def run!; $captures << :paz; end}
     FooStack::BootLoader.add(:fred,   :before => :bar   ){ def run!; $captures << :fred; end}
     FooStack::BootLoader.add(:barney, :after  => :fred  ){ def run!; $captures << :barney; end}
-    
+
     FooStack.new
     $captures.should == [:foo, :paz, :baz, :fred, :barney, :bar]
   end
-  
+
   describe "types" do
-  
+
     it "should run bootloaders marked as :init" do
       FooStack::BootLoader.add(:bar, :level => :init ){ def run!; $captures << [:bar, :init   ]; end}
       FooStack::BootLoader.add(:baz, :level => :init ){ def run!; $captures << [:baz, :init   ]; end}
       FooStack::BootLoader.add(:paz, :level => :init, :before => :baz){ def run!; $captures << [:paz, :init]; end}
-      
+
       FooStack::BootLoader.run!(:only => {:level => :init})
       $captures.should == [[:bar, :init], [:paz, :init], [:baz, :init]]
     end
-    
+
     it "should run init or then default level bootloaders individually" do
       FooStack::BootLoader.add(:foo                  ){ def run!; $captures << [:foo, :default]; end}
-      FooStack::BootLoader.add(:grh                  ){ def run!; $captures << [:grh, :default]; end} 
+      FooStack::BootLoader.add(:grh                  ){ def run!; $captures << [:grh, :default]; end}
       FooStack::BootLoader.add(:bar, :level => :init ){ def run!; $captures << [:bar, :init   ]; end}
-      FooStack::BootLoader.add(:ptf, :before => :grh ){ def run!; $captures << [:ptf, :default]; end} 
+      FooStack::BootLoader.add(:ptf, :before => :grh ){ def run!; $captures << [:ptf, :default]; end}
       FooStack::BootLoader.add(:baz, :level => :init ){ def run!; $captures << [:baz, :init   ]; end}
       FooStack::BootLoader.add(:paz, :level => :init, :before => :baz){ def run!; $captures << [:paz, :init]; end}
-      
+
       FooStack.new
       $captures.should == [[:bar, :init], [:paz, :init], [:baz, :init], [:foo, :default], [:ptf, :default], [:grh, :default]]
     end
-    
-    it "should inherit from the default boot loaders" do
-      ::Pancake::Stack::BootLoader.add(:default_boot_loader_test){def run!; end}
-      class ::Bario < Pancake::Stack; end
-      Bario::BootLoader.map{|n,bl| n}.should include(:default_boot_loader_test)
-    end
-    
+
+#    it "should inherit from the default boot loaders" do
+#      ::Pancake::Stack::BootLoader.add(:default_boot_loader_test){def run!; end}
+#      class ::Bario < Pancake::Stack; end
+#      Bario::BootLoader.map{|n,bl| n}.should include(:default_boot_loader_test)
+#      ::Pancake::Stack::BootLoader.
+#    end
+
     it "should let me pass options to the bootloaders and pass them on" do
       FooStack::BootLoader.add(:foo){ def run!; config[:result] << :foo; end}
       FooStack::BootLoader.add(:bar){ def run!; config[:result] << :bar; end}
-      
+
       opts = { :result => [] }
       FooStack.new(nil, opts)
       opts[:result].should == [:foo, :bar]
     end
   end
-end
+end

data/spec/pancake/defaults/configuration_spec.rb

@@ -43,7 +43,7 @@ describe "Pancake configuration defaults" do
 
     it "should set the log stream to a file path when told to log to file" do
       Pancake.configuration.log_to_file = true
-      result = Pancake.configuration.log_stream
+      result = Pancake.configuration.log_path
       result.should match(/\log\/pancake_#{Pancake.env}\.log$/)
     end
 

data/spec/pancake/fixtures/render_templates/view_context/_basic.haml

@@ -0,0 +1,3 @@
+.item
+  In Partial Basic
+  - $captures << self

data/spec/pancake/fixtures/render_templates/view_context/_basic.html.haml

@@ -0,0 +1,4 @@
+.item
+  In Partial Basic
+
+- $captures << self

data/spec/pancake/fixtures/render_templates/view_context/_foo_as_name.haml

@@ -0,0 +1 @@
+= "foo == #{foo}"

data/spec/pancake/fixtures/render_templates/view_context/_local_as_name.haml

@@ -0,0 +1 @@
+= "local_as_name == #{local_as_name}"

data/spec/pancake/fixtures/render_templates/view_context/_with_locals.haml

@@ -0,0 +1,2 @@
+= "foo == #{foo}"
+= "bar == #{bar}"

data/spec/pancake/fixtures/render_templates/view_context/collection_with_partial_name.haml

@@ -0,0 +1 @@
+= partial :local_as_name, :with => collection

data/spec/pancake/fixtures/render_templates/view_context/contains_partial.haml

@@ -0,0 +1,5 @@
+- $captures << self
+
+%p
+  In Contains Partial
+  = partial :basic

data/spec/pancake/middleware_spec.rb

@@ -85,15 +85,15 @@ describe "Pancake::Middleware" do
       BazApp.use FooMiddle
       Pancake.use GeneralMiddleware
 
-      FooApp.with_router do |r|
-        r.mount(BarApp.stackup, "/bar")
-        r.mount(BazApp.stackup, "/baz")
+      FooApp.router do |r|
+        r.mount(BarApp, "/bar")
+        r.mount(BazApp, "/baz")
       end
 
       @app = Pancake.start(:root => @root){ FooApp.stackup }
-      get "/baz"
+      result = get "/baz"
       $current_env["p.s.c"].should == [GeneralMiddleware, FooMiddle]
-      get "/bar"
+      reult = get "/bar"
       $current_env["p.s.c"].should == [GeneralMiddleware, BarMiddle]
     end
   end

data/spec/pancake/mixins/render/view_context_spec.rb

@@ -249,6 +249,66 @@ describe Pancake::Mixins::Render::ViewContext do
       result.should include("nested new bar content")
     end
   end
+
+  describe "partials" do
+    before do
+      @foo = FooBar.new({})
+      @collection = %w(one two three four)
+      $captures = []
+    end
+
+    it "should use the _partial_template_name_for method to find a partial" do
+      @foo.should_receive(:_partial_template_name_for).with(:basic, {}).and_return("_basic")
+      result = @foo.partial(:basic)
+    end
+
+    it "should render a partial with the partial call" do
+      result = @foo.partial(:basic)
+      result.should include("In Partial Basic")
+    end
+
+    it "should render from within a template" do
+      result = @foo.render(:contains_partial)
+      result.should include("In Partial Basic")
+    end
+
+    it "should use a different view context instance for the partial" do
+      result = @foo.render(:contains_partial)
+      $captures.should have(2).items
+      $captures.first.should_not == $captures.last
+    end
+
+    it "should allow me to specify locals for use in the partial" do
+      result = @foo.partial(:with_locals, :foo => "this is foo", :bar => "and this is bar")
+      result.should include("foo == this is foo")
+      result.should include("bar == and this is bar")
+    end
+
+    it "should render a partial with an object as the local name" do
+      result = @foo.partial(:local_as_name, :with => "value of local as name")
+      result.should include("local_as_name == value of local as name")
+    end
+
+    it "should render a partial with many objects with the obj as a local with the partial name" do
+      result = @foo.partial(:local_as_name, :with => @collection)
+      @collection.each do |val|
+        result.should include("local_as_name == #{val}")
+      end
+    end
+
+    it "should render a partial with an object with a specified name" do
+      result = @foo.partial(:foo_as_name, :with => "jimmy", :as => :foo)
+      result.should include("foo == jimmy")
+    end
+
+    it "should render a partial with many objects as a local with a specified name" do
+      result = @foo.partial(:foo_as_name, :with => @collection, :as => :foo)
+      @collection.each do |val|
+        result.should include("foo == #{val}")
+      end
+    end
+
+  end
 end
 
 

data/spec/pancake/stack/router_spec.rb

@@ -65,13 +65,6 @@ describe "stack router" do
         last_response.status.should == 404
     end
 
-    it "should make sure that the application is a rack application" do
-      lambda do
-        FooApp.router.mount(:not_an_app, "/foo")
-      end.should raise_error(Pancake::Router::RackApplicationExpected)
-    end
-
-
     it "should not match a single segment route when only / is defined" do
       FooApp.router.add("/", :_defaults => {:root => :var}) do |e|
         Rack::Response.new("In the Root").finish
@@ -80,6 +73,36 @@ describe "stack router" do
       result = get "/not_a_route"
       result.status.should == 404
     end
+
+    describe "mounting stacks" do
+      before do
+        @stack_app = lambda{|e| Rack::Response.new("stacked up").finish}
+      end
+
+      it "should not imediately stackup the passed in resource" do
+        stack = mock("stack")
+        stack.should_not_receive(:stackup)
+        FooApp.router.mount(stack, "/stackup")
+      end
+
+      it "should stackup a class if it responds to stackup" do
+        stack = mock("stack")
+        stack.should_receive(:stackup).and_return(@stack_app)
+        FooApp.router.mount(stack, "/stackup")
+
+        @app = FooApp.stackup
+        result = get "/stackup"
+        result.body.should include("stacked up")
+      end
+
+      it "should activate the class with the activate option" do
+
+      end
+
+      it "should pass the given args to the class to create it" do
+
+      end
+    end
   end
 
   describe "generating routes" do
@@ -116,6 +139,9 @@ describe "stack router" do
       Pancake.url(FooApp, :unique_var => "unique_var").should == "/some/unique_var"
     end
 
+    it "should generate a base url of '/' for the top level router" do
+      FooApp.router.base_url.should == "/"
+    end
 
     describe "mounted route generation" do
       before do
@@ -125,7 +151,9 @@ describe "stack router" do
           r.add("/simple").name(:simple)
           r.add("/some/:var", :_defaults => {:var => "foo"}).name(:foo)
         end
-        FooApp.router.mount(BarApp.stackup, "/bar")
+        FooApp.router.mount(BarApp, "/bar")
+        FooApp.router.mount_applications!
+        FooApp.stackup
       end
 
       it "should allow me to generate a simple nested named route" do
@@ -133,10 +161,19 @@ describe "stack router" do
       end
 
       it "should allow me to generate a simple nested named route for a named app" do
-        FooApp.router.mount(BarApp.stackup(:app_name => :bar_app), "/different")
+        FooApp.router.mount(BarApp, "/different", :_args => [{:app_name => :bar_app}])
+        FooApp.router.mount_applications!
         Pancake.url(:bar_app, :simple).should == "/different/simple"
         Pancake.url(BarApp,   :simple).should == "/bar/simple"
       end
+
+      it "should generate the base url for a mounted application" do
+        BarApp.configuration.router.base_url.should == "/bar"
+      end
+
+      it "should generate a base url for a named application" do
+        Pancake.base_url_for(BarApp)
+      end
     end
 
   end
@@ -149,6 +186,7 @@ describe "stack router" do
           INNER_APP
         end
       end
+      FooApp.router.mount(INNER_APP, "/some_mount")
 
       @app = FooApp.stackup
       get "/bar"
@@ -195,6 +233,7 @@ describe "stack router" do
     end
 
     class ::BarApp < FooApp; end
+    FooApp.router.mount_applications!
 
     Pancake.url(BarApp, :simple).should == "/simple"
     Pancake.url(BarApp, :stuff => "this_stuff").should == "/foo/this_stuff"
@@ -215,10 +254,10 @@ describe "stack router" do
     BarApp::Router.should inherit_from(FooApp::Router)
   end
 
-  it "should grab a new copy of the router rather than instantiate an inherited one" do
+  it "should inherit the router class as an inner class" do
     class ::BarApp < FooApp; end
-    FooApp.router.class.should == Pancake::Stack::Router
-    BarApp.router.class.should == Pancake::Stack::Router
+    FooApp.router.class.should == FooApp::Router
+    BarApp.router.class.should == BarApp::Router
   end
 
   it "should reset the router to the namespaced router" do
@@ -259,7 +298,7 @@ describe "stack router" do
       end
 
       FooApp.router do |r|
-        r.mount(BarApp.stackup, "/bar")
+        r.mount(BarApp, "/bar")
         r.add(  "/foo"   ).name(:foo)
         r.add(  "/simple").name(:simple)
       end

data/spec/pancake/stacks/short/controller_spec.rb

@@ -17,6 +17,18 @@ describe Pancake::Stacks::Short::Controller do
         publish
         def index;  "index";   end
 
+        publish
+        def a_rack_response
+          r = Rack::Response.new
+          r.redirect("/foo")
+          r
+        end
+
+        publish
+        def an_array_response
+          [200, {"Content-Type" => "text/plain"}, ["Custom Array Response"]]
+        end
+
         protected
         def a_protected_method; "protected"; end
 
@@ -80,6 +92,19 @@ describe Pancake::Stacks::Short::Controller do
       end.should raise_error
     end
 
+    it "should let me return an array as a rack response" do
+      @controller.params["action"] = "an_array_response"
+      result = @controller.do_dispatch!
+      result.should == [200, {"Content-Type" => "text/plain"}, ["Custom Array Response"]]
+    end
+
+    it "should allow me to return a Rack::Response" do
+      @controller.params["action"] = "a_rack_response"
+      result = @controller.do_dispatch!
+      result[0].should == 302
+      result[1]["Location"].should == "/foo"
+    end
+
     describe "helper in methods" do
       before do
         module PancakeTestHelper
@@ -123,6 +148,10 @@ describe Pancake::Stacks::Short::Controller do
           v[:my_data] = "some data"
           render :vault
         end
+
+        get "/redirect" do
+          redirect "/some_other_place"
+        end
       end
     end
 
@@ -156,6 +185,12 @@ describe Pancake::Stacks::Short::Controller do
       result.body.should include("some data")
       result.body.should include("In Vault")
     end
+
+    it "should redirect" do
+      result = get "/redirect"
+      result.status.should == 302
+      result.headers["Location"].should == "/some_other_place"
+    end
   end
 
   describe "accept type negotiations" do

data/spec/pancake/stacks/short/router_spec.rb

@@ -95,7 +95,8 @@ describe Pancake::Stacks::Short, "routes" do
 
     it "should generate it's url when it's nested" do
       class ::FooApp < Pancake::Stack; end
-      FooApp.router.mount(RoutedShortStack.stackup, "/short/stack")
+      FooApp.router.mount(RoutedShortStack, "/short/stack")
+      FooApp.router.mount_applications!
       Pancake.url(RoutedShortStack, :foo).should == "/short/stack/foo"
       Pancake.url(RoutedShortStack, :baz, :var => "var", :date => "today").should == "/short/stack/baz/var/today"
     end
@@ -127,7 +128,8 @@ describe Pancake::Stacks::Short, "routes" do
 
     it "should match the nested route without affecting the parent" do
       class ::BarApp < Pancake::Stack; end
-      BarApp.router.mount(FooApp.stackup, "/mount/point")
+      BarApp.router.mount(FooApp, "/mount/point")
+      BarApp.router.mount_applications!
 
       Pancake.url(FooApp, :foo).should == "/mount/point/foo"
       Pancake.url(RoutedShortStack, :foo).should == "/foo"