pancake 0.2.0 → 0.3.0

data/lib/pancake/stack/configuration.rb

@@ -28,18 +28,16 @@ end # Pancake
 ####################
 # Setup the default configuration for each stack
 class Pancake::Stack::Configuration
-  default :router, lambda{ _router }, "The router for this stack"
+  default :router, Proc.new{ _router }, "The router for this stack"
 
   def _router
     @_router ||= begin
       unless stack.nil?
-        r = stack.router.dup
-        r.configuration = self
-        r.default(app)
+        r = stack.router.clone
+        r.stack = stack
         r.configuration = self
         r
       end
-
     end
   end
 end

data/lib/pancake/stack/router.rb

@@ -1,44 +1,21 @@
 module Pancake
   class Stack
-    class Router < Pancake::Router; end
     inheritable_inner_classes :Router
-    cattr_writer :_router
-
-    @_router = self::Router.new
+    class Router < Pancake::Router; end
 
-    def self._router
-      @_router ||= begin
-        r = self::Router.new
-        unless self == Pancake::Stack
-          r.router = superclass._router.router.dup
+    def self.router
+      @router ||= begin
+        if superclass.respond_to?(:router) && superclass.router
+          r = superclass.router.clone(self::Router)
+          r.stack = self
+        else
+          r = self::Router.new
+          r.stack = self
         end
-        r.stack = self
+        yield r if block_given?
         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
-    #
-    # When the router is rest, any routes declared in parent stacks will be lost.
-    # @example
-    #   MyStack.reset_router! # => Replaces the current router with MyStack::Router (instance)
-    #
-    # @api public
-    def self.reset_router!
-      self._router = self::Router.new
-    end
-
-    def self.router
-      yield _router if block_given?
-      _router
-    end
-
-    def self.with_router
-      yield router if block_given?
-      router
-    end
   end
 end
 

data/lib/pancake/stack/stack.rb

@@ -2,6 +2,11 @@ module Pancake
   class Stack
     attr_accessor :app_name
 
+    class_inheritable_array :_after_stack_initialize, :_after_build_stack, :_before_build_stack
+    self._after_stack_initialize = []
+    self._after_build_stack     = []
+    self._before_build_stack    = []
+
     # extend Hooks::InheritableInnerClasses
     extend Hooks::OnInherit
     extend Pancake::Middleware
@@ -10,9 +15,6 @@ module Pancake
     # Push the default paths in for this stack
     push_paths(:config,       "config",               "config.rb")
     push_paths(:config,       "config/environments",  "#{Pancake.env}.rb")
-    push_paths(:models,       "app/models",           "**/*.rb")
-    push_paths(:controllers,  "app/controllers",      "**/*.rb")
-    push_paths(:router,       "config",               "router.rb")
     push_paths(:rake_tasks,   "tasks",                "**/*.rake")
     push_paths(:public,       "public",               "**/*")
     push_paths(:mounts,       "mounts",               "*/pancake_init.rb")
@@ -24,14 +26,35 @@ module Pancake
       raise "Stack root not set" if roots.empty?
       master = opts.delete(:master)
       set_as_master! if master
-      # Run any :init level bootloaders for this stack
-      self::BootLoader.run!(:stack_class => self, :only => {:level => :init})
-      # Pick up any new stacks added during the boot process.
-      set_as_master! if master
 
+      paths_for(:config     ).each{ |f| require f.join }
+      paths_for(:mounts     ).each{ |f| require f.join }
+      paths_for(:middleware ).each{ |f| require f.join }
+
+      router.mount_applications!
+
+      set_as_master! if master
       @initialized = true
+      # run the hook for after mounting
+      after_stack_initialize.each{ |blk| blk.call(self) }
     end # initiailze stack
 
+
+    def self.after_stack_initialize(&blk)
+      _after_stack_initialize << blk if blk
+      _after_stack_initialize
+    end
+
+    def self.after_build_stack(&blk)
+      _after_build_stack << blk if blk
+      _after_build_stack
+    end
+
+    def self.before_build_stack(&blk)
+      _before_build_stack << blk if blk
+      _before_build_stack
+    end
+
     # Adds the file to the stack root.
     #
     # @param file - The file identifier
@@ -47,6 +70,14 @@ module Pancake
       !!@initialized
     end
 
+    def self.include_pancake_stack!(include_it = true)
+      @include_pancake_stack = include_it
+    end
+
+    def self.include_pancake_stack?
+      !!@include_pancake_stack
+    end
+
     def initialize(app = nil, opts = {})
       @app_name = opts.delete(:app_name) || self.class
 
@@ -60,22 +91,46 @@ module Pancake
       self.configuration(@app_name)
       yield self.configuration(@app_name) if block_given?
 
-      self.class::BootLoader.run!({
-        :stack_class  => self.class,
-        :stack        => self,
-        :app          => app,
-        :app_name     => @app_name,
-        :except       => {:level => :init}
-      }.merge(opts))
+      @app ||= self.class.new_endpoint_instance
+
+      self.class.before_build_stack.each{|b| b.call(self, @app_name, opts)}
+
+      mwares = self.class.middlewares
+
+      @stack = Pancake::Middleware.build(@app, mwares)
+      app_config = Pancake.configuration.configs(@app_name)
+      app_config.stack = self.class
+      app_config.router.configuration = app_config
+      router = Pancake.configuration.configs[@app_name].router
+      router.mount_applications!
+      router.default(@stack)
+      self.class.after_build_stack.each{ |blk| blk.call(self, @app_name, opts) }
     end
 
     # Construct a stack using the application, wrapped in the middlewares
     # @api public
     def self.stackup(opts = {}, &block)
       app = new(nil, opts, &block)
-      Pancake.configuration.configs[app.app_name].router
+      r = Pancake.configuration.configs[app.app_name].router
+      if include_pancake_stack?
+        Pancake.start{r}
+      else
+        r
+      end
     end # stackup
 
+    def call(env)
+      Pancake.configuration.configs[@app_name].router.call(env)
+    end
+
+
+    # get a new instance of the application for this stack
+    # Ovewrite this to provide custom application initialization
+    # :api: overwritable
+    def self.new_endpoint_instance
+      MISSING_APP
+    end
+
     # Loads the rake task for this stack, and all mounted stacks
     #
     # To have your rake task loaded include a "tasks" director in the stack root
@@ -204,45 +259,10 @@ module Pancake
     def self.base_template_name
       raise Errors::NotImplemented, "Stack may not be used for templates until it implements a base_template_name method"
     end
-
-    # 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|
-        extlib_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, :before_stack_loads
   end # Stack
 end # Pancake
 
 require 'pancake/stack/configuration'
 require 'pancake/stack/router'
-require 'pancake/stack/bootloader'
-require 'pancake/stack/app'
 require 'pancake/defaults/middlewares'
 require 'pancake/defaults/configuration'

data/{spec/helpers → lib/pancake/test}/helpers.rb

@@ -1,5 +1,5 @@
 module Pancake
-  module Spec
+  module Test
     module Helpers
       def clear_constants(*classes)
         classes.flatten.each do |klass|
@@ -16,5 +16,5 @@ module Pancake
         Rack::MockRequest.env_for(path, opts)
       end
     end # Helpers
-  end # Spec
-end # Pancake
+  end
+end

data/lib/pancake/test/matchers.rb

@@ -34,6 +34,26 @@ module Pancake
       def mount(expected, path)
         MountMatcher.new(expected, path)
       end
+
+      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 # Test
 end # Pancake

data/lib/pancake/vendor/hashie/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/lib/pancake/vendor/hashie/.gitignore

@@ -0,0 +1,7 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg
+*.gem
+.bundle

data/lib/pancake/vendor/hashie/Gemfile

@@ -0,0 +1,11 @@
+# A sample Gemfile
+source :gemcutter
+
+group :development do
+  gem 'rake'
+  gem 'json'
+end
+
+group :test do
+  gem 'rspec'
+end

data/lib/pancake/vendor/hashie/Gemfile.lock

@@ -0,0 +1,25 @@
+--- 
+dependencies: 
+  rake: 
+    group: 
+    - :development
+    version: ">= 0"
+  rspec: 
+    group: 
+    - :test
+    version: ">= 0"
+  json: 
+    group: 
+    - :development
+    version: ">= 0"
+specs: 
+- rake: 
+    version: 0.8.7
+- json: 
+    version: 1.4.3
+- rspec: 
+    version: 1.3.0
+hash: d9c314ac1790a9ac25dfdaf7574b86d62b88f1d5
+sources: 
+- Rubygems: 
+    uri: http://gemcutter.org

data/lib/pancake/{generators/templates/short/%stack_name%/LICENSE.tt → vendor/hashie/LICENSE}

@@ -1,4 +1,4 @@
-Copyright (c) <%= Date.today.year %> <YOUR NAME HERE>
+Copyright (c) 2009 Intridea, Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/lib/pancake/vendor/hashie/README.rdoc

@@ -0,0 +1,101 @@
+= Hashie
+
+Hashie is a growing collection of tools that extend Hashes and make
+them more useful.
+
+== Installation
+    
+Hashie is available as a RubyGem:
+
+    gem install hashie
+
+== Mash
+
+Mash is an extended Hash that gives simple pseudo-object functionality
+that can be built from hashes and easily extended. It is designed to
+be used in RESTful API libraries to provide easy object-like access 
+to JSON and XML parsed hashes.
+
+=== Example:
+  
+    mash = Hashie::Mash.new
+    mash.name? # => false
+    mash.name # => nil
+    mash.name = "My Mash"
+    mash.name # => "My Mash"
+    mash.name? # => true
+    mash.inspect # => <Hashie::Mash name="My Mash">
+  
+    mash = Mash.new
+    # use bang methods for multi-level assignment
+    mash.author!.name = "Michael Bleigh"
+    mash.author # => <Hashie::Mash name="Michael Bleigh">
+  
+== Dash
+
+Dash is an extended Hash that has a discrete set of defined properties
+and only those properties may be set on the hash. Additionally, you
+can set defaults for each property.
+
+=== Example:
+
+    class Person < Hashie::Dash
+      property :name
+      property :email
+      property :occupation, :default => 'Rubyist'
+    end
+
+    p = Person.new
+    p.name # => nil
+    p.email = 'abc@def.com'
+    p.occupation   # => 'Rubyist'
+    p.email        # => 'abc@def.com'
+    p[:awesome]    # => NoMethodError
+    p[:occupation] # => 'Rubyist'
+    
+    p = Person.new(:name => "Bob")
+    p.name       # => 'Bob'
+    p.occupation # => 'Rubyist'
+    
+== Clash
+
+Clash is a Chainable Lazy Hash that allows you to easily construct
+complex hashes using method notation chaining. This will allow you
+to use a more action-oriented approach to building options hashes.
+
+Essentially, a Clash is a generalized way to provide much of the same
+kind of "chainability" that libraries like Arel or Rails 2.x's named_scopes
+provide.
+
+=== Example
+
+    c = Hashie::Clash.new
+    c.where(:abc => 'def').order(:created_at)
+    c # => {:where => {:abc => 'def}, :order => :created_at}
+
+    # You can also use bang notation to chain into sub-hashes,
+    # jumping back up the chain with _end!
+    c = Hashie::Clash.new
+    c.where!.abc('def').ghi(123)._end!.order(:created_at)
+    c # => {:where => {:abc => 'def', :ghi => 123}, :order => :created_at}
+
+    # Multiple hashes are merged automatically
+    c = Hashie::Clash.new
+    c.where(:abc => 'def').where(:hgi => 123)
+    c # => {:where => {:abc => 'def', :hgi => 123}}
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a future version unintentionally.
+* Commit, do not mess with rakefile, version, or history. (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Authors
+
+* Michael Bleigh
+
+== Copyright
+
+Copyright (c) 2009 Intridea, Inc (http://intridea.com/). See LICENSE for details.