pancake 0.2.0 → 0.3.0

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

@@ -1,22 +0,0 @@
-require File.dirname(__FILE__) + '/../../../spec_helper'
-
-describe "short stack middleware" do
-  before do
-    class ::FooBar < Pancake::Stacks::Short
-      add_root(__FILE__)
-    end
-  end
-
-  after do
-    clear_constants :FooBar
-  end
-
-  it "should include the Pancake::Middlewares::Static middleware" do
-    FooBar.stackup
-    middleware = FooBar.middlewares.detect do |m|
-      m.middleware == Pancake::Middlewares::Static
-    end
-    middleware.should_not be_nil
-    middleware.args.should == [FooBar]
-  end
-end

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

@@ -1,150 +0,0 @@
-require File.join(File.expand_path(File.dirname(__FILE__)),'..', '..', '..', 'spec_helper')
-
-describe Pancake::Stacks::Short, "routes" do
-  before do
-    class ::RoutedShortStack < Pancake::Stacks::Short
-      roots << Pancake.get_root(__FILE__)
-
-      get "/", :_name => :root do
-        "get - /"
-      end
-
-      get "/foo", :_name => :foo do
-        "get - foo"
-      end
-
-      get "/bar", :_name => :bar do
-        "get - bar"
-      end
-
-      post "/foo" do
-        "post - foo"
-      end
-
-      post "/bar" do
-        "post - bar"
-      end
-
-      put "/foo" do
-        "put - foo"
-      end
-
-      put "/bar" do
-        "put - bar"
-      end
-
-      delete "/foo" do
-        "delete - foo"
-      end
-
-      delete "/bar" do
-        "delete - bar"
-      end
-
-      any "/any/foo" do
-        "any - foo"
-      end
-
-      get "/baz/:var(/:date)" do
-        "done: var == #{params[:var]} : date == #{params[:date]}"
-      end.name(:baz)
-    end
-    @app = RoutedShortStack.stackup
-  end
-  after do
-    clear_constants "RoutedShortStack", "FooApp", "BarApp"
-  end
-
-  def app
-    @app
-  end
-
-  %w(foo bar).each do |item|
-    %w(get post put delete).each do |method|
-      it "should #{method} /#{item}" do
-        result = self.send(method, "/#{item}")
-        result.status.should == 200
-        result.body.should == "#{method} - #{item}"
-      end
-    end # get post put delete
-  end # foo bar
-
-  it "should return a not found if we try to get an action that has not been defined" do
-    result = get "/blah"
-    result.status.should == 404
-  end
-
-
-  it "should handle tricky routes" do
-    result = get "/baz/hassox"
-    result.status.should == 200
-    result.body.should == "done: var == hassox : date == "
-  end
-
-  it "should handle tricky routes with optional parameters" do
-    result = get "/baz/hassox/2009-08-21"
-    result.status.should == 200
-    result.body.should == "done: var == hassox : date == 2009-08-21"
-  end
-
-  it "should handle the any request method" do
-    [:get, :post, :put, :delete].each do |meth|
-      result = self.send(meth, "/any/foo")
-      result.status.should == 200
-      result.body.should == "any - foo"
-    end
-  end
-
-  describe "url generation" do
-    it "should generate a simple named  url" do
-      Pancake.url(RoutedShortStack, :foo).should == "/foo"
-    end
-
-    it "should generate a complex named  url" do
-      Pancake.url(RoutedShortStack, :baz, :var => "bar").should == "/baz/bar"
-      Pancake.url(RoutedShortStack, :baz, :var => "bar", :date => "today").should == "/baz/bar/today"
-    end
-
-    it "should generate it's url when it's nested" do
-      class ::FooApp < Pancake::Stack; end
-      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
-  end
-
-  describe "inherited route generation" do
-    before do
-      class ::FooApp < RoutedShortStack; end
-      @app = FooApp.stackup
-    end
-
-    it "should generate an inherited simple url" do
-      Pancake.url(FooApp, :foo).should == "/foo"
-    end
-
-    it "should generate a complex url" do
-      Pancake.url(FooApp, :baz, :var => "the_var", :date => "today").should == "/baz/the_var/today"
-    end
-
-    %w(foo bar).each do |item|
-      %w(get post put delete).each do |method|
-        it "should #{method} /#{item}" do
-          result = self.send(method, "/#{item}")
-          result.status.should == 200
-          result.body.should == "#{method} - #{item}"
-        end
-      end # get post put delete
-    end # foo bar
-
-    it "should match the nested route without affecting the parent" do
-      class ::BarApp < Pancake::Stack; end
-      BarApp.router.mount(FooApp, "/mount/point")
-      BarApp.router.mount_applications!
-
-      Pancake.url(FooApp, :foo).should == "/mount/point/foo"
-      Pancake.url(RoutedShortStack, :foo).should == "/foo"
-    end
-  end
-end

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

@@ -1,117 +0,0 @@
-require File.dirname(__FILE__) + '/../../../spec_helper'
-
-describe Pancake::Stacks::Short do
-
-  before do
-    @master_before = [Pancake.master_stack, Pancake.master_templates]
-    $captures = []
-    class ::ShortMiddle
-      attr_accessor :app
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        $captures << ShortMiddle
-        @app.call(env)
-      end
-    end
-
-    class ::ShortFoo < Pancake::Stacks::Short
-      roots << Pancake.get_root(__FILE__)
-      add_root(__FILE__, "..", "..", "fixtures", "stacks", "short", "foobar")
-      add_root(__FILE__, "..", "..", "fixtures", "stacks", "short", "foobar", "other_root")
-      use ShortMiddle
-
-
-      get "/foo" do
-        "HERE"
-      end
-
-      get "/" do
-        $captures << self.class
-        render :inherited_from_base
-      end
-    end
-
-    @app = ShortFoo
-    Pancake.master_stack = ShortFoo
-    Pancake.master_templates = ShortFoo
-  end
-
-  after do
-    clear_constants :ShortFoo, :ShortMiddle, :OtherFoo, "ShortFoo::Router"
-    Pancake.master_stack, Pancake.master_templates = @master_before
-  end
-
-  def app
-    @app.stackup
-  end
-
-  it "should provide access through the stack interface to the templates" do
-    ShortFoo.template(:inherited_from_base).should be_an_instance_of(Pancake::Mixins::Render::Template)
-  end
-
-  it "should go through the middleware to get to the actions" do
-    get "/foo"
-    $captures.should == [ShortMiddle]
-  end
-
-  describe "inheritance" do
-    before do
-      class ::OtherFoo < ShortFoo; end
-      ShortFoo.router.mount(OtherFoo, "/other")
-    end
-
-    it "should render the same template in the child as it does in the parent" do
-      get "/"
-      $captures.pop.should == ShortFoo::Controller
-      last_response.should match(/inherited from base/)
-      result = get "/other/"
-      $captures.pop.should == OtherFoo::Controller
-      last_response.should match(/inherited from base/)
-    end
-  end
-
-  describe "helpers" do
-    before do
-      $captures = []
-      class ::ShortFoo
-        helpers do
-          def in_helper?
-            $captures << :in_helper?
-          end
-        end
-      end
-    end
-
-    it "should allow me to setup a helper method in the stack" do
-      ShortFoo.get("/with_helper"){ in_helper?; "OK" }
-      result = get "/with_helper"
-      result.should be_successful
-      $captures.should include(:in_helper?)
-    end
-
-    it "should provide the helpers in child stacks" do
-      class ::OtherFoo < ShortFoo; end
-      OtherFoo.get("/helper_action"){ in_helper?; "OK" }
-      @app = OtherFoo
-      result = get "/helper_action"
-      result.should be_successful
-      $captures.should include(:in_helper?)
-    end
-
-    it "should let me mixin modules to the helpers" do
-      module ::OtherFoo
-        def other_helper
-          $captures << :other_helper
-        end
-      end
-      ShortFoo.helpers{ include OtherFoo }
-      ShortFoo.get("/foo"){ other_helper; "OK" }
-      result = get "/foo"
-      result.should be_successful
-      $captures.should include(:other_helper)
-    end
-  end
-end