@@ -1,18 +1,50 @@ -Pancake: -rack-bug - development -deflect - production -etag - production -deflator - production -rack-cache - production -ShowExceptions - development -content_length - all -content_type - all -mime-type - all -session - all cookie (configurable) -methodoverride - all -NestedParams - all -warden - all +MIDDLEWARE RUN ENV LABEL +Pancake: +rack-bug - development - debugger +deflect - production - nil +etag - production - etag +deflator - production - deflator +rack-cache - production - cache +ShowExceptions - development - exceptions +content_length - all - nil +content_type - all - nil +mime-type - all - nil +session - all cookie (configurable) - session +methodoverride - all - nil +NestedParams - all - nil +rack-uploads - all - upload_parsing +warden - all - auth Pancake Stacks: -[file - for each root] - development \ No newline at end of file +[file - for each root] - development - static + + +middleware, opts, block : middleware + +class MyApp + use Middleware, :middleware => :opts + + mixture.add(:foo, :after => :session).use(MyFoo) + mixture.replace(:session).use( MyOtherSession ) + mixture.configure(:session){|config| #stuff } +end + + use Middleware, {:middleware => :opts}, {:name => :auth, :after => :session, :env => :all} + + + + with_use :env => :all, :after => :session do + use Middlware, :middleware => :opts + end + + mware(:auth, :after => :session, :env => :all).use Middlware, :middleware => :opts + mware_replace(:session).use MySessions, :session => :opts + + use(Middleware, :middleware => :opts).after(:session).env(:all).register + use(Middleware, :middleware => :opts).register(::auth, after => :session, :env => :all) + + +configuration.mware(:authentication, :after => :session, :env => :all).use( MiddleWare, {:middleware => :opts}) do |mw| + # Stuff in there if there's a middlware block on initialization +end \ No newline at end of file MIDDLEWARE_LIST @@ -11,11 +11,12 @@ module Pancake # Declare inner classes to be inherited when the outer class in inherited # :api: public def inheritable_inner_classes(*classes) - @_inhertiable_inner_classes ||= [] + _inhertiable_inner_classes unless classes.empty? - @_inhertiable_inner_classes += classes.flatten - end - @_inhertiable_inner_classes + _inhertiable_inner_classes << classes + _inhertiable_inner_classes.flatten! + end + _inhertiable_inner_classes end # An inherited hook for any extended classes to perform the inheriting of inner @@ -26,6 +27,7 @@ module Pancake class_defs = inheritable_inner_classes.map do |klass| "class #{klass} < #{self}::#{klass}; end\n" end + # puts "#{base.name} is INHERITING INNER CLASSES #{class_defs.inspect}" base.class_eval(class_defs.join) end lib/pancake/hooks/inheritable_inner_classes.rb @@ -1,38 +1,103 @@ module Pancake module Middleware - def self.extended(base) - base.class_eval do - # Provides an inherited reader for middlewares - if base.is_a?(Class) - class_inheritable_reader :middlewares - @middlewares = [] - else - def self.middlewares - @middlewares ||= [] - end - end - end - end def self.build(app, mwares) mwares.reverse.inject(app) do |a, m| - m.middleware.new(a, m.opts, &m.block) + m.middleware.new(a, m.options, &m.block) end end - SomeMiddleware = Struct.new(:middleware, :opts, :block) + def self.extended(base) + base.class_eval <<-RUBY + class StackMiddleware < Pancake::Middleware::StackMiddleware; end + RUBY + if base.is_a?(Class) + base.inheritable_inner_classes :StackMiddleware + end + end # self.extended + + def middlewares + self::StackMiddleware.middlewares + end + + def stack(name = nil, opts = {}) + self::StackMiddleware.new(name, opts) + end - # Use this to define middleware to include in the stack - # + # Use this to define middleware to include in the stackå # :api: public def use(middleware, opts = {}, &block) - middlewares << SomeMiddleware.new(middleware, opts, &block) + self::StackMiddleware.use(middleware, opts, &block) end # use # use this to prepend middleware to the stack # :api: public - def prepend_use(middleware, opts = {}, &block) - middlewares.unshift SomeMiddleware.new(middleware, opts, &block) + # def prepend_use(middleware, opts = {}, &block) + # middlewares.unshift SomeMiddleware.new(middleware, opts, &block) + # end + + class StackMiddleware + # :api: private + class_inheritable_reader :_central_mwares, :_mwares, :_before, :_after + @_central_mwares, @_before, @_after, @_mwares = [], {}, {}, {} + + attr_reader :middleware, :config, :block, :name, :options + + class << self + def use(mware, opts, &block) + new(mware).use(mware, opts, &block) + end + + def reset! + _central_mwares.clear + _mwares.clear + _before.clear + _after.clear + end + + def middlewares + _central_mwares.map do |name| + map_middleware(name) + end.flatten + end + + def map_middleware(name) + result = [] + _before[name] ||= [] + _after[name] ||= [] + result << _before[name].map{|n| map_middleware(n)} + result << _mwares[name] + result << _after[name].map{|n| map_middleware(n)} + result.flatten + end + end + + def [](name) + self.class._mwares[name] + end + + def initialize(name, options = {}) + @name, @options = name, options + end + + def use(mware, config = {}, &block) + @middleware, @config, @block = mware, config, block + @name = @middleware if name.nil? + raise "This middleware has already been declareed" if self.class._central_mwares.include?(name) + if options[:before] + raise "#{options[:before].inspect} middleware is not defined for this stack" unless self.class._mwares.keys.include?(options[:before]) + self.class._before[options[:before]] ||= [] + self.class._before[options[:before]] << name + elsif options[:after] + raise "#{options[:after].inspect} middleware is not defined for this stack" unless self.class._mwares.keys.include?(options[:after]) + self.class._after[options[:after]] ||= [] + self.class._after[options[:after]] << name + else + self.class._central_mwares << name unless self.class._central_mwares.include?(name) + end + self.class._mwares[name] = self + self + end end end # Middleware end # Pancake \ No newline at end of file lib/pancake/middleware.rb @@ -2,10 +2,10 @@ module Pancake class Stack attr_reader :app - include Rack::Router::Routable - extend Middleware + # extend Hooks::InheritableInnerClasses extend Hooks::OnInherit - extend Hooks::InheritableInnerClasses + include Rack::Router::Routable + extend Pancake::Middleware def self.initialize_stack raise "Application root not set" if roots.empty? @@ -54,7 +54,7 @@ module Pancake # Construct a stack using the application, wrapped in the middlewares # :api: public - def self.stack(opts = {}, &block) + def self.stackup(opts = {}, &block) new(nil, opts, &block) end # stack lib/pancake/stack/stack.rb @@ -108,5 +108,14 @@ describe "Pancake::Stack::BootLoader" do class ::Bario < Pancake::Stack; end Bario::BootLoader.map{|n,bl| n}.should include(:default_boot_loader_test) 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::BootLoader.run!(opts) + opts[:result].should == [:foo, :bar] + end end end \ No newline at end of file spec/bootloaders/base_spec.rb @@ -64,15 +64,20 @@ describe "Pancake Inheritance" do it "should inherit the inner class along with the outer class" do class ::OtherFoo < MyFoo; end - OtherFoo::InnerFoo.should inherit_from(MyFoo::InnerFoo) + OtherFoo::InnerFoo.superclass.should equal(MyFoo::InnerFoo) + OtherFoo::InnerFoo.should_not equal(MyFoo::InnerFoo) end it "should inherit the inner class multiple times" do class ::OtherFoo < MyFoo; end class ::SomeFoo < OtherFoo; end class ::DeeperFoo < SomeFoo; end - SomeFoo::InnerFoo.should inherit_from(OtherFoo::InnerFoo) - DeeperFoo::InnerFoo.should inherit_from(SomeFoo::InnerFoo) + + SomeFoo::InnerFoo.superclass.should equal(OtherFoo::InnerFoo) + SomeFoo::InnerFoo.should_not equal(OtherFoo::InnerFoo) + DeeperFoo::InnerFoo.superclass.should equal(SomeFoo::InnerFoo) + DeeperFoo::InnerFoo.should_not equal(OtherFoo::InnerFoo) + DeeperFoo::InnerFoo.superclass.should equal(SomeFoo::InnerFoo) end it "should allow additional inner classes to be declared without polluting the parent" do spec/inheritance_spec.rb @@ -20,20 +20,14 @@ describe "Pancake::Middleware" do end $current_env = {} - Object.class_eval {remove_const("GeneralMiddleware") if defined?(::GeneralMiddleware)} - Object.class_eval {remove_const("FooApp") if defined?(::FooApp)} - Object.class_eval {remove_const("BarApp") if defined?(::BarApp)} - Object.class_eval {remove_const("BazApp") if defined?(::BazApp)} - Object.class_eval {remove_const("FooMiddle") if defined?(::FooMiddle)} - Object.class_eval {remove_const("BarMiddle") if defined?(::BarMiddle)} - + class ::GeneralMiddleware attr_accessor :app def initialize(app, opts={});@app = app; end def mark_env(env) - env["pancake.spec.captures"] ||= [] - env["pancake.spec.captures"] << self.class + env["p.s.c"] ||= [] + env["p.s.c"] << self.class end def call(env) @@ -54,53 +48,55 @@ describe "Pancake::Middleware" do end after(:each) do - clear_constants(:GeneralMiddleware, :FooApp, :BarMiddle, :FooMiddle, :BarApp, :BazApp) + clear_constants(:FooApp, :BarApp, :BazApp, :GeneralMiddleware, :BarMiddle, :FooMiddle, :BazMiddle, :PazMiddle) end describe "pancake middlewares" do before(:each) do @root = File.join(Pancake.get_root(__FILE__), "fixtures", "foo_stack") @the_app = Proc.new{|e| } + Pancake::StackMiddleware.reset! end it "should allow me to add middleware to pancake" do Pancake.use GeneralMiddleware - @app = Pancake.start(:root => @root){ FooApp.stack } + @app = Pancake.start(:root => @root){ FooApp.stackup } + Pancake.middlewares.map{|m| m.middleware}.should == [GeneralMiddleware] get "/" - $current_env["pancake.spec.captures"].should include(GeneralMiddleware) + $current_env["p.s.c"].should include(GeneralMiddleware) end it "should allow me to add multiple middlewares to panckae" do - class FooMiddle < GeneralMiddleware; end + class ::FooMiddle < GeneralMiddleware; end Pancake.use GeneralMiddleware FooApp.use FooMiddle - @app = Pancake.start(:root => @root){ FooApp.stack } + @app = Pancake.start(:root => @root){ FooApp.stackup } get "/" - $current_env["pancake.spec.captures"].should == [GeneralMiddleware, FooMiddle] + $current_env["p.s.c"].should == [GeneralMiddleware, FooMiddle] end - + it "should put the pancake middlewares out in front" do class ::FooMiddle < GeneralMiddleware; end class ::BarMiddle < GeneralMiddleware; end class ::BarApp < FooApp; end class ::BazApp < FooApp; end - + BarApp.use BarMiddle BazApp.use FooMiddle Pancake.use GeneralMiddleware - + FooApp.add_routes do |r| - r.map "/bar", :to => BarApp.stack, :anchor => true - r.map "/baz", :to => BazApp.stack, :anchor => true + r.map "/bar", :to => BarApp.stackup, :anchor => true + r.map "/baz", :to => BazApp.stackup, :anchor => true end BarApp.stack_routes.clear BazApp.stack_routes.clear - @app = Pancake.start(:root => @root){ FooApp.stack } + @app = Pancake.start(:root => @root){ FooApp.stackup } get "/baz" - $current_env["pancake.spec.captures"].should == [GeneralMiddleware, FooMiddle] + $current_env["p.s.c"].should == [GeneralMiddleware, FooMiddle] get "/bar" - $current_env["pancake.spec.captures"].should == [GeneralMiddleware, BarMiddle] + $current_env["p.s.c"].should == [GeneralMiddleware, BarMiddle] end end @@ -108,9 +104,9 @@ describe "Pancake::Middleware" do FooApp.class_eval do use GeneralMiddleware end - @app = FooApp.stack + @app = FooApp.stackup get "/" - $current_env["pancake.spec.captures"].should include(GeneralMiddleware) + $current_env["p.s.c"].should include(GeneralMiddleware) end it "should allow me to add multiple middlewares" do @@ -119,32 +115,34 @@ describe "Pancake::Middleware" do use GeneralMiddleware use FooMiddle end - @app = FooApp.stack + @app = FooApp.stackup get "/" [GeneralMiddleware, FooMiddle].each do |m| - $current_env["pancake.spec.captures"].should include(m) + $current_env["p.s.c"].should include(m) end end it "should prepend middlewares" do - class ::FooMiddle < GeneralMiddleware; end - class ::BarMiddle < GeneralMiddleware; end + pending("Have not re-implemented prepend yet") do + class ::FooMiddle < GeneralMiddleware; end + class ::BarMiddle < GeneralMiddleware; end - FooApp.class_eval do - use GeneralMiddleware - use FooMiddle - prepend_use BarMiddle + FooApp.class_eval do + use GeneralMiddleware + use FooMiddle + prepend_use BarMiddle + end + @app = FooApp.stackup + get "/" + $current_env["p.s.c"].should == [BarMiddle, GeneralMiddleware, FooMiddle] end - @app = FooApp.stack - get "/" - $current_env["pancake.spec.captures"].should == [BarMiddle, GeneralMiddleware, FooMiddle] end it "should allow you to add middleware from outside the class" do FooApp.use GeneralMiddleware - @app = FooApp.stack + @app = FooApp.stackup get "/" - $current_env["pancake.spec.captures"].should == [GeneralMiddleware] + $current_env["p.s.c"].should == [GeneralMiddleware] end describe "Inherited middleware" do @@ -169,14 +167,16 @@ describe "Pancake::Middleware" do end it "should inherit multiple children deep" do - FooApp.use GeneralMiddleware - class BarApp < FooApp; end - BarApp.prepend_use FooMiddle - class BazApp < BarApp; end - BazApp.use BarMiddle - FooApp.middlewares.map{|m| m.middleware}.should == [GeneralMiddleware] - BarApp.middlewares.map{|m| m.middleware}.should == [FooMiddle, GeneralMiddleware] - BazApp.middlewares.map{|m| m.middleware}.should == [FooMiddle, GeneralMiddleware, BarMiddle] + pending("No prepend use yet") do + FooApp.use GeneralMiddleware + class BarApp < FooApp; end + BarApp.prepend_use FooMiddle + class BazApp < BarApp; end + BazApp.use BarMiddle + FooApp.middlewares.map{|m| m.middleware}.should == [GeneralMiddleware] + BarApp.middlewares.map{|m| m.middleware}.should == [FooMiddle, GeneralMiddleware] + BazApp.middlewares.map{|m| m.middleware}.should == [FooMiddle, GeneralMiddleware, BarMiddle] + end end end @@ -195,7 +195,7 @@ describe "Pancake::Middleware" do end after(:each) do - Pancake::Stack.middlewares.clear + Pancake::Stack::StackMiddleware.reset! end it "should clear the middlewares for the specs" do @@ -224,6 +224,101 @@ describe "Pancake::Middleware" do FooApp.middlewares.map{|m| m.middleware}.should == [GeneralMiddleware, FooMiddle] BarApp.middlewares.map{|m| m.middleware}.should == [GeneralMiddleware, BarMiddle] end + + describe "Stack Middleware Enabled Constant", :shared => true do + + before(:each) do + raise "You must set a @konstant for the stack construction spec" unless @konstant + @konstant::StackMiddleware.reset! + end + + describe "named middleware" do + it "should allow me to name a #{@konstant} middleware" do + @konstant.stack(:foo).use(GeneralMiddleware) + @konstant.stack[:foo].middleware.should == GeneralMiddleware + end + + it "should implicitly name a middleware" do + @konstant.stack.use(GeneralMiddleware) + @konstant.stack[GeneralMiddleware].middleware.should == GeneralMiddleware + end + end + + describe "before/after middleware" do + before(:each) do + class ::BazMiddle < GeneralMiddleware; end + class ::PazMiddle < GeneralMiddleware; end + end + # :FooApp, :BarApp, :BazApp, :GeneralMiddleware, :BarMiddle, :FooMiddle, :BazMiddle, :PazMiddle + it "should allow me to add middleware before other middleware" do + @konstant.use(GeneralMiddleware) + @konstant.stack(:bar).use(BarMiddle) + @konstant.stack(:foo, :before => :bar).use(FooMiddle) + result = @konstant.middlewares.map{|m| m.middleware} + result.should == [GeneralMiddleware, FooMiddle, BarMiddle] + end + + it "should allow me to add middleware after other middleware " do + @konstant.use(BarMiddle) + @konstant.stack(:general).use(GeneralMiddleware) + @konstant.stack(:foo, :after => BarMiddle).use(FooMiddle) + result = @konstant.middlewares.map{|m| m.middleware} + result.should == [ BarMiddle, FooMiddle, GeneralMiddleware] + end + + it "should allow me to add middleware arbitrarily and have it in the correct order" do + @konstant.use(GeneralMiddleware) + @konstant.stack(:bar).use(BarMiddle) + @konstant.stack(:foo, :before => :bar).use(FooMiddle) + @konstant.stack(:baz, :after => :foo).use(BazMiddle) + @konstant.stack(:paz, :before => GeneralMiddleware).use(PazMiddle) + result = @konstant.middlewares.map{|m| m.middleware} + result.should == [PazMiddle, GeneralMiddleware, FooMiddle, BazMiddle, BarMiddle] + end + end + end + + describe "Pancake Middleware Construction" do + before(:each) do + @konstant = Pancake + end + + it_should_behave_like("Stack Middleware Enabled Constant") + end + + describe "Pancake Stack Middleware" do + before(:each) do + @konstant = Pancake::Stack + end + it_should_behave_like("Stack Middleware Enabled Constant") + end + + describe "An inherited panckae stack app" do + before(:each) do + class ::FooApp < Pancake::Stack; end + @konstant = FooApp + end + it_should_behave_like("Stack Middleware Enabled Constant") + end + + describe "a deeply inherited stack app" do + before(:each) do + class ::FooApp < Pancake::Stack; end + class ::BarApp < FooApp; end + @konstant = BarApp + end + it_should_behave_like("Stack Middleware Enabled Constant") + end + + it "should allow me to inherit middleware from a parent stack" do + class ::FooApp < Pancake::Stack; end + FooApp.use(GeneralMiddleware) + class ::BarApp < FooApp; end + BarApp.stack(:foo).use(FooMiddle) + BarApp.stack(:bar, :after => GeneralMiddleware).use(BarMiddle) + result = BarApp.middlewares.map{|m|m.middleware} + result.should == [GeneralMiddleware, BarMiddle, FooMiddle] + end + end # Stack Inheritance - end \ No newline at end of file spec/middleware_spec.rb @@ -41,7 +41,7 @@ describe "stack router" do r.map "/foo", :to => INNER_APP, :with => {:action => "foo action"}, :anchor => true end - @app = FooApp.stack + @app = FooApp.stackup expected = { "SCRIPT_NAME" => "/foo", "PATH_INFO" => "", @@ -57,7 +57,7 @@ describe "stack router" do r.map "/foobar", :to => Proc.new{|e| [200, {}, ["IN THE FOOBAR APP"]]}, :anchor => true r.map "/foo" , :to => INNER_APP, :anchor => true end - @app = FooApp.stack + @app = FooApp.stackup get "/foobar" last_response.body.should == "IN THE FOOBAR APP" @@ -78,7 +78,7 @@ describe "stack router" do r.map "/:foo", :to => INNER_APP, :with => {:hah => "hah"}, :anchor => true end - @app = FooApp.stack + @app = FooApp.stackup get "/some_foo" JSON.parse(last_response.body).should == { "SCRIPT_NAME" => "/some_foo", @@ -96,7 +96,7 @@ describe "stack router" do r.map "/bar", :to => INNER_APP, :with => {"originator" => "BarApp"}, :anchor => true end - @app = BarApp.stack + @app = BarApp.stackup get "/bar" response = JSON.parse(last_response.body) @@ -113,7 +113,7 @@ describe "stack router" do FooApp.add_routes do |r| r.mount "/foo", INNER_APP, :action => "foo" end - @app = FooApp.stack + @app = FooApp.stackup get "/foo" result = JSON.parse(last_response.body) result["SCRIPT_NAME"].should == "/foo" spec/stack/router_spec.rb @@ -52,23 +52,23 @@ describe "pancake stack configuration" do describe "configurations" do it "should provide a configuration object for the stack" do - app = FooStack.stack + app = FooStack.stackup app.configuration.should be_an_instance_of(FooStack::Configuration) end it "should put a copy of the application at the stack identified by the class" do - app = FooStack.stack + app = FooStack.stackup Pancake.configuration.stacks[FooStack].should equal(app) end it "should allow me to set a configuration object manually" do config = FooStack::Configuration.new - app = FooStack.stack(:config => config) + app = FooStack.stackup(:config => config) app.configuration.should equal(config) end it "should allow me to have access to the configuration object when creating the stack through a block" do - app = FooStack.stack do |config| + app = FooStack.stackup do |config| config.foo = :foo config.bar = :bar end @@ -77,7 +77,7 @@ describe "pancake stack configuration" do end it "should setup access to the configuration object through Pancakes configuration" do - app = FooStack.stack + app = FooStack.stackup Pancake.configuration.stacks(FooStack).should equal app Pancake.configuration.configs(FooStack).should equal app.configuration end @@ -88,7 +88,7 @@ describe "pancake stack configuration" do end it "should create a stack with an app_name" do - FooStack.stack(:app_name => "my.app.name") + FooStack.stackup(:app_name => "my.app.name") Pancake.configuration.stacks(FooStack).should be_nil Pancake.configuration.stacks("my.app.name").should be_an_instance_of(FooStack) Pancake.configuration.configs("my.app.name").should be_an_instance_of(FooStack::Configuration) @@ -98,7 +98,7 @@ describe "pancake stack configuration" do Pancake.configuration.configs(FooStack) do |config| config.foo = :foo end - @app = FooStack.stack + @app = FooStack.stackup @app.configuration.foo.should == :foo end end spec/stack/stack_configuration_spec.rb ecdc34714ba7bd09cc2b9be29e705fb52739fde4 Daniel Neighman has.sox@gmail.com http://github.com/hassox/pancake/commit/0d18d5dd328323280ffeacf94473736dc8e3c146 0d18d5dd328323280ffeacf94473736dc8e3c146 2009-06-07T06:04:47-07:00 2009-06-07T06:04:47-07:00 Adds mappable middleware to stacks and pancake b88059e5d8b2b546b8ec0b54dd4f9228395b93b5 Daniel Neighman has.sox@gmail.com