pancake 0.2.0 → 0.3.0

data/spec/helpers/matchers.rb

@@ -1,25 +0,0 @@
-module Pancake
-  module Matchers
-    
-    class InheritFrom
-      def initialize(expected)
-        @expected = expected
-      end
-      
-      def matches?(target)
-        @target = target
-        @target.ancestors.include?(@expected)
-      end
-      
-      def failure_message
-        "expected #{@target} to inherit from #{@expected} but did not"
-      end
-    end
-    
-    def inherit_from(expected)
-      InheritFrom.new(expected)
-    end
-    
-    
-  end # Matchers
-end # Pancake

data/spec/pancake/bootloaders_spec.rb

@@ -1,119 +0,0 @@
-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[: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 remove a bootloader from another bootloader" do
-    FooStack::BootLoader.add(:foo){ def run!; $captures << :foo; end}
-    FooStack::BootLoader.add(:bar){ def run!; FooStack::BootLoader.delete(:removed); end }
-    FooStack::BootLoader.add(:removed){ def run!; $captures << :removed; end}
-    FooStack.new
-
-    $captures.should == [:foo]
-  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}
-    FooStack::BootLoader.add(:bar){ def run!; $captures << :bar; end}
-    FooStack::BootLoader.add(:baz, :before => :bar){ def run!; $captures << :baz; end}
-    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}
-    FooStack::BootLoader.add(:bar){ def run!; $captures << :bar; end}
-    FooStack::BootLoader.add(:baz, :after => :foo){ def run!; $captures << :baz; end}
-    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}
-    FooStack::BootLoader.add(:bar                       ){ def run!; $captures << :bar; end}
-    FooStack::BootLoader.add(:baz,    :after  => :foo   ){ def run!; $captures << :baz; end}
-    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(:bar, :level => :init ){ def run!; $captures << [:bar, :init   ]; 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)
-#      ::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

data/spec/pancake/stack/app_spec.rb

@@ -1,28 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe "Pancake::Stack.new_app_instance" do
-  
-  before(:each) do
-    class ::FooStack < Pancake::Stack
-      
-    end
-  end
-  
-  after(:each) do
-    clear_constants(:FooStack)
-  end
-  
-  it "should provide a new instance of the applciation" do
-    FooStack.new_app_instance.should == Pancake::MISSING_APP
-  end
-  
-  it "should allow me to overwrite the new_app_instance for this stack" do
-    class ::BarStack < Pancake::Stack
-      def self.new_app_instance
-        ::Pancake::OK_APP
-      end
-    end
-    
-    BarStack.new_app_instance.should == ::Pancake::OK_APP
-  end
-end

data/spec/pancake/stack/bootloader_spec.rb

@@ -1,41 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe "Stack BootLoaders" do
-  
-  before(:each) do
-    clear_constants(:FooStack, :BarStack)
-  end
-  
-  it "should inherit the standard bootloaders from Pancake::Stack" do
-    class ::FooStack < Pancake::Stack; end
-    FooStack::BootLoader.should inherit_from(Pancake::Stack::BootLoader)
-  end
-  
-  it "should get all the bootloaders from pancake stack" do
-    class ::FooStack < Pancake::Stack; end
-    FooStack::BootLoader.map{|n,bl|n}.should == Pancake::Stack::BootLoader.map{|n,bl|n}
-  end
-  
-  it "should let FooStack define it's own bootloaders" do
-    class ::FooStack < Pancake::Stack; end
-    FooStack::BootLoader.add(:foo_stack_bootloader){ def run!; end }
-    FooStack::BootLoader.map{|n,b|n}.should include(:foo_stack_bootloader)
-    Pancake::Stack::BootLoader.map{|n,b|n}.should_not include(:foo_stack_bootloader)
-  end
-  
-  it "should not pollute other bootloaders" do
-    class ::FooStack < Pancake::Stack; end
-    FooStack::BootLoader.add(:foo_stack_bootloader){ def run!; end }
-    class ::BarStack < Pancake::Stack; end
-    FooStack::BootLoader.map{|n,b|n}.should_not == BarStack::BootLoader.map{|n,b|n}
-    BarStack::BootLoader.map{|n,b|n}.should_not include(:foo_stack_bootloader)
-  end
-  
-  it "should inherit custom bootloaders" do
-    class ::FooStack < Pancake::Stack; end
-    FooStack::BootLoader.add(:foo_stack_bootloader){ def run!; end }
-    class ::BarStack < FooStack; end
-    BarStack::BootLoader.map{|n,b|n}.should include(:foo_stack_bootloader)
-  end
-
-end

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

@@ -1,442 +0,0 @@
-require File.join(File.expand_path(File.dirname(__FILE__)),'..', '..', '..', 'spec_helper')
-
-describe Pancake::Stacks::Short::Controller do
-
-  before do
-    class ::ShortFoo < Pancake::Stacks::Short
-      add_root(__FILE__)
-      add_root(File.expand_path(File.dirname(__FILE__)), "..", "fixtures", "stacks", "short", "foobar")
-      class Controller
-
-        def do_dispatch!
-          dispatch!
-        end
-
-        publish
-        def show;   "show";    end
-
-        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
-
-        private
-        def a_private_method; "private"; end
-      end
-    end
-  end
-
-  after do
-    clear_constants "ShortFoo", :ShortBar
-  end
-
-  def app
-    ShortFoo.stackup
-  end
-
-  it "should have a Controller" do
-    Pancake::Stacks::Short.constants.map(&:to_s).should include("Controller")
-  end
-
-  it "should inherit the subclass controller from the parent controller" do
-    ShortFoo::Controller.should inherit_from(Pancake::Stacks::Short::Controller)
-  end
-
-  describe "dispatching an action" do
-    before do
-      @controller = ShortFoo::Controller.new(env_for)
-    end
-
-    it "should call the 'show' action" do
-      @controller.params["action"] = "show"
-      result = @controller.do_dispatch!
-      result[0].should == 200
-      result[2].body.join.should  == "show"
-    end
-
-    it "should raise a Pancake::Response::NotFound exception when an action is now found" do
-      @controller.params["action"] = :does_not_exist
-      result = @controller.do_dispatch!
-      result[0].should == 404
-    end
-
-    it "should not dispatch to a protected method" do
-      @controller.params["action"] = "a_protected_method"
-      result = @controller.do_dispatch!
-      result[0].should == 404
-    end
-
-    it "should not dispatch to a private method" do
-      @controller.params["action"] = "a_private_method"
-      result = @controller.do_dispatch!
-      result[0].should == 404
-    end
-
-    it "should raise an exception if pancake has told it not to handle errors" do
-      Pancake.should_receive(:handle_errors?).and_return(false)
-      @controller.params["action"] = "a_private_method"
-      lambda do
-        @controller.do_dispatch!
-      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
-          def some_helper_method
-            "foo"
-          end
-        end
-
-        class ShortFoo
-          class Controller
-            include PancakeTestHelper
-          end
-        end
-      end
-      after do
-        clear_constants "PancakeTestHelper"
-      end
-
-      it "should not call a helper method" do
-        @controller.params["action"] = "some_helper_method"
-        result = @controller.do_dispatch!
-        result[0].should == 404
-      end
-
-    end
-  end
-
-  describe "request helper methods" do
-    before do
-      class ::RequestFoo < Pancake::Stacks::Short
-        add_root(__FILE__, "..", "..", "fixtures", "stacks", "short", "foobar")
-        get "/foobar", :_name => :foobar do
-          url(:foobar)
-        end
-
-        get "/template", :_name => :template do
-          render :template
-        end
-
-        get "/vault" do
-          v[:my_data] = "some data"
-          render :vault
-        end
-
-        get "/redirect" do
-          redirect "/some_other_place"
-        end
-      end
-    end
-
-    after do
-      clear_constants :RequestFoo
-    end
-
-    def app
-      RequestFoo.stackup
-    end
-
-    it "should include the request helper methods" do
-      (Pancake::Mixins::RequestHelper > ShortFoo::Controller).should be_true
-    end
-
-    it "should provide access to the request methods in the controller" do
-      result = get "/foobar"
-      result.body.should == "/foobar"
-    end
-
-    it "should provide access to the helper methods in the views" do
-      result = get "/template"
-      result.status.should == 200
-      result.body.should include("/foobar")
-      result.body.should include("In Template")
-    end
-
-    it "should allow me to get information between the view and the controller" do
-      result = get "/vault"
-      result.status.should == 200
-      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
-    before do
-      class ::ShortBar < Pancake::Stacks::Short
-        roots << Pancake.get_root(__FILE__)
-        # makes the dispatch method public
-        def do_dispatch!
-          dispatch!
-        end
-
-        provides :json, :xml, :text
-
-        get "/foo/bar(.:format)" do
-          "format #{content_type.inspect}"
-        end
-      end # ShortBar
-    end # before
-
-    def app
-      ShortBar.stackup
-    end
-
-    it "should get json by default" do
-      result = get "/foo/bar", {}, "HTTP_ACCEPT" => "application/json"
-      result.status.should == 200
-      result.headers["Content-Type"].should == "application/json"
-      result.body.to_s.should == "format :json"
-    end
-
-    it "should get xml when specified" do
-      result = get "/foo/bar.xml"
-      result.status.should == 200
-      result.headers["Content-Type"].should == "application/xml"
-      result.body.to_s.should == "format :xml"
-    end
-
-    it "should get json when specified with */*" do
-      result = get "/foo/bar", {}, "HTTP_ACCEPT" => "*/*"
-      result.status.should == 200
-      result.body.to_s.should == "format :json"
-      result.headers["Content-Type"].should == "application/json"
-    end
-
-    it "should get the default when specified with */*" do
-      result = get "/foo/bar", {}, "HTTP_ACCEPT" => "application/xml,*/*"
-      result.status.should == 200
-      result.body.to_s.should == "format :json"
-      result.headers["Content-Type"].should == "application/json"
-    end
-
-    it "should use the format in preference to the content type" do
-      result = get "/foo/bar.xml", {}, "HTTP_ACCEPT" => "*/*"
-      result.status.should == 200
-      result.body.to_s.should == "format :xml"
-      result.headers["Content-Type"].should == "application/xml"
-    end
-
-    it "should get json by default" do
-      result = get "/foo/bar"
-      result.status.should == 200
-      result.body.to_s.should == "format :json"
-      result.headers["Content-Type"].should == "application/json"
-    end
-
-    it "should correctly negotiate different scenarios" do
-      r = get "/foo/bar", {}, {}
-      r.body.should == "format :json"
-      r = get "/foo/bar.xml", {}, {}
-      r.body.should == "format :xml"
-      r = get "/foo/bar", {}, {}
-      r.body.should == "format :json"
-      r = get "/foo/bar", {}, "HTTP_ACCEPT" => "application/xml"
-      r.body.should == "format :xml"
-      r = get "/foo/bar.json"
-      r.body.should == "format :json"
-    end
-
-    it "should negotiate based on extension" do
-      r = get "/foo/bar"
-      r.body.should == "format :json"
-      r = get "/foo/bar.text"
-      r.body.should == "format :text"
-      r = get "/foo/bar.xml"
-      r.body.should == "format :xml"
-      r = get "/foo/bar.txt"
-      r.body.should == "format :text"
-    end
-
-    it "should not provide a response to a format that is not provided" do
-      r = get "/foo/bar.svg"
-      r.status.should == 406
-    end
-  end # Accept type negotiations
-
-  describe "error handling" do
-    before do
-      class ::ShortFoo
-        provides :html, :xml
-
-        get "/foo(.:format)" do
-          "HERE"
-        end
-
-        get "/bad" do
-          raise "This is bad"
-        end
-
-        get "/template/:name" do
-          render params[:name]
-        end
-
-      end
-    end
-
-    describe "default error handling" do
-      def app
-        ShortFoo.stackup
-      end
-
-      it "should handle a NotFound  by default" do
-        result = get "/does_not_exist"
-        result.status.should == 404
-        result.body.should include(Pancake::Errors::NotFound.description)
-      end
-
-      it "should return a 500 status for a Random Error by wrapping it in a Pancake::Errors::Server" do
-        result = get "/bad"
-        result.status.should == 500
-        result.body.should include(Pancake::Errors::Server.description)
-      end
-
-      it "should handle a NotAcceptable error" do
-        result = get "/foo.no_format_i_know_of"
-        result.status.should == 406
-        result.body.should include(Pancake::Errors::NotAcceptable.description)
-      end
-
-      it "should return 406 for a format that is in pancake but not in the group" do
-        r = get "/foo.svg"
-        r.status.should == 406
-      end
-    end
-
-    describe "custom error handling" do
-      before do
-        ShortFoo.handle_exception do |error|
-          out = ""
-          out << "CUSTOM "
-          out << error.name
-          out << ": "
-          out << error.description
-        end
-
-        ShortFoo.get "/bad" do
-          raise "Really Bad"
-        end
-      end
-
-      after do
-        ShortFoo.handle_exception(&Pancake::Stacks::Short::Controller::DEFAULT_EXCEPTION_HANDLER)
-      end
-
-      it "should handle Pancake::Errors::NotFound errors" do
-        r = get "/not_a_thing"
-        r.status.should == 404
-        r.body.should include("CUSTOM")
-        r.body.should include(Pancake::Errors::NotFound.description)
-      end
-
-      it "should handle an unknown server error" do
-        r = get "/bad"
-        r.status.should == 500
-        r.body.should include("CUSTOM")
-        r.body.should include(Pancake::Errors::Server.description)
-      end
-
-      it "should let me do stuff on an instance level inside the handle exception" do
-        ShortFoo.handle_exception do |error|
-          self.status = 123
-          "BOOO!"
-        end
-
-        r = get "/bad"
-        r.status.should == 123
-        r.body.should == "BOOO!"
-      end
-
-    end
-
-    describe "rendering" do
-
-      it "should render a template" do
-        result = get "/template/basic"
-        result.body.should include("basic template")
-      end
-
-      it "should inherit from a base view provided by short stacks" do
-        File.file?(File.join(File.expand_path(File.dirname(__FILE__)), "..", "fixtures", "stacks", "short", "foobar", "views", "base.html.haml")).should be_false
-        result = get "/template/inherited_from_base"
-        result.body.should include("inherited from base")
-        result.body.should include("Pancake")
-      end
-
-      it "should allow me to overwrite the base tempalte in later roots" do
-        ShortFoo.add_root(File.expand_path(File.dirname(__FILE__)), "..", "fixtures", "stacks", "short", "foobar", "other_root")
-        result = get "/template/inherited_from_base"
-        result.body.should include("inherited from base")
-        result.body.should include("Not the default pancake")
-      end
-    end
-
-    describe "throwing" do
-      before do
-        ShortFoo.get("/plain_throw"){    throw :halt }
-        ShortFoo.get("/string_throw"){   throw :halt, "output string" }
-        ShortFoo.get("/status_n_throw"){ self.status = 204; throw :halt }
-        ShortFoo.get("/headers_n_throw") do
-          headers["some-header"] = Time.now.to_s
-          throw :halt
-        end
-      end
-
-      it "should handle a plain throw" do
-        result = get "/plain_throw"
-        result.should be_successful
-        result.body.should == ""
-      end
-
-      it "should handle a string throw" do
-        result = get "/string_throw"
-        result.should be_successful
-        result.body.should == "output string"
-      end
-
-      it "should handle a change in the status" do
-        result = get "/status_n_throw"
-        result.status.should == 204
-        result.body.should == ""
-      end
-
-      it "should handle a change in the headers" do
-        result = get "/headers_n_throw"
-        result.headers["some-header"].should_not be_blank
-      end
-    end
-  end
-end