pancake 0.1.13 → 0.1.15

data/README.textile

@@ -1,35 +1,76 @@
 h1. Pancake
 
-Pancake is primarily a tool for making rack applictions.  "Rack":http://rack.github.com has come up in the Ruby web world as _the framework that matters_ when developing web applications.  All the major frameworks use it, although so many application frameworks and middlewares are not really re-usable yet away from their specific implementations.
+Modern web applications often need to be constructed by interacting with numerous independent service/applications, each optimised for a specific task. However, making each of these components interact and work cohesively is difficult and time consuming.  Pancake helps you construct clean, modular, re-usable code to create your web masterpieces.
 
-Pancake addresses this by making Rack the fundamental building block of an applicaiton.  It provides very useful helpers on top of rack that assist in constructing rack stacks as mixins.  Almost all aspects of web frameworks are covered as Pancake mixins to help you create your own re-usable Rack Stacks without worrying about the really low level plumbing.
+Pancake is primarily a tool for making rack applications.  "Rack":http://rack.github.com has come up in the Ruby web world as _the framework that matters_ when developing web applications.  All the major frameworks use it, although many of the application frameworks and their middlewares are not really re-usable away from their specific implementations yet.
+
+Pancake addresses this by making Rack the fundamental building block of an application.  It provides very useful helpers on top of Rack that assist in constructing Rack stacks as mixins.  Almost all key aspects of web frameworks are covered in Pancake as mixins to help you create your own re-usable Rack Stacks without worrying about the really low level plumbing.
+
+This README is a very high level overview only and doesn't really cover a great deal of Pancake unfortunately.
 
 h2. Stacks
 
-While Rack provides the framework for building web applications on.  Pancake provides a stack as a place to start your application.  A stack provides a whole bunch of behavior for you including a router and middleware stack.  The stack will accept any valid rack application as the endpoint.
+While Rack provides the low level framework for building web applications on, Pancake provides a stack as a place to start your application.  A stack provides a whole bunch of behavior for you including a router and middleware stack.  The stack will accept any valid Rack application as the endpoint.  If you're not familiar with what makes a "valid Rack application":http://rack.rubyforge.org/doc/SPEC.html it basically comes down to an object that receives the "call" method with exactly one argument, the environment hash, and returns an array with exactly 3 elements.  The status, headers and body.
 
 The general form of a stack is as follows:
-
-<pre>
+<pre><code>
 -----------------------------------
 |                                 |
 |           Router                |
 |                                 |
------------------------------------
+|---------------------------------|
 |           Middleware            |
------------------------------------
+|---------------------------------|
 |           Middleware            |
------------------------------------
+|---------------------------------|
 |           Middleware            |
------------------------------------
+|---------------------------------|
 |                                 |
 |           Application           |
 |            Endpoint             |
 |                                 |
 -----------------------------------
+
+</code></pre>
+
+Each stack has its own router, middleware stack and application endpoint.  Stacks can be combined and also put inside Pancake.
+
+Combined into a Pancake application it may look like this:
+
+<pre>
+
+-------------------------------------------------------------------------------
+|                                 Pancake Middleware                          |
+|-----------------------------------------------------------------------------|
+|                                 Pancake Middleware                          |
+|-----------------------------------------------------------------------------|
+|                                 Pancake Middleware                          |
+|-----------------------------------------------------------------------------|
+|                                                                             |
+|  -----------------------------------   -----------------------------------  |
+|  |                                 |   |                                 |  |
+|  |           Router                |   |           Router                |  |
+|  |                                 |   |                                 |  |
+|  |---------------------------------|   |---------------------------------|  |
+|  |           Middleware            |   |           Middleware            |  |
+|  |---------------------------------|   |---------------------------------|  |
+|  |           Middleware            |   |           Middleware            |  |
+|  |---------------------------------|   |---------------------------------|  |
+|  |           Middleware            |   |           Middleware            |  |
+|  |---------------------------------|   |---------------------------------|  |
+|  |                                 |   |                                 |  |
+|  |           Application           |   |           Application           |  |
+|  |            Endpoint             |   |            Endpoint             |  |
+|  |                                 |   |                                 |  |
+|  -----------------------------------   -----------------------------------  |
+|                                                                             |
+-------------------------------------------------------------------------------
+
+
+
 </pre>
 
-Stacks are designed to work together.  It's trivially easy to mount one stack inside another, or just mount any valid rack application inside your stack.  They're also designed to be gemed and used as libraries as full applications.
+Stacks are designed to work together.  It's trivially easy to mount one stack inside another, or just mount any valid rack application inside your stack.  They're also designed to be gemmed and used as libraries or full applications.
 
 <pre><code>MyStack.router do |r|
   r.mount(OtherStack, "/stack/mount/point")
@@ -39,11 +80,17 @@ A stack doesn't have to mount other stacks.  Pancake stacks are full application
 
 Rails 3 is shipping with a pluggable router which can be the awesome "Usher":http://github.com/joshbuddy/usher router.  If you use Usher in your Rails app, you'll be able to mount Pancake stacks directly.  For now, you can mount them as Metals.
 
+TODO: Demonstrate in a gist mounting pancake in a rails application
+
 All stacks are namespaced.  Pancake makes heavy use of namespacing to help construct applications concisely.
 
-h2. Middleware Stacks
+h2. Middleware In Stacks
+
+Middleware is a specialised kind of rack application that can either respond to a request, or pass it on to another application.
 
-When you use Pancake middleware management, you can name middleware, set middleware to come before or after other middleware, or be included or not based on a stack type label.  Lets have a look at that.
+There's two main places for middleware in Pancake. Pancake level, and stack level.  If you attach middleware to Pancake itself, all requests will pass through those middlewares.  If you attach it at the stack level, only that stack will have that middleware active for its requests.
+
+When you use Pancake middleware management, you can name middleware, set middleware to come before or after other middleware, or be included or not based on a stack type label(s).  Lets have a look at that.
 
 <pre><code>class MyStack < Pancake::Stack
   stack(:session).use(Rack::Sessions::Cookie)
@@ -51,7 +98,7 @@ When you use Pancake middleware management, you can name middleware, set middlew
 
   stack(:bugz, :labels => [:development]).use(Rack::Bug)
 
-  use(AlwaysUse)
+  use(AlwaysUseThisMiddleware)
 end
 </code></pre>
 
@@ -59,14 +106,16 @@ h2. What can a stack do
 
 Pancake provides a whole bunch of functionality as mixins.
 
-* BootLoaders
-* Router ("Usher":http://github.com/joshbuddy/usher Based.  Please read.)
-* Sophisticated Middlware Configuration
-* Stack/Custom Configuration
-* Path Management with multiple roots (makes working with gem stacks transparent)
-* Content Type negotiation
-* Inheritable Templating System
-* Action Publish Control
+* "BootLoaders":http://gist.github.com/229784
+* "Router":http://gist.github.com/229785 ("Usher":http://github.com/joshbuddy/usher Based.  Please read.)
+* "Sophisticated Middlware Configuration":http://gist.github.com/229787
+* "Stack/Custom Configuration":http://gist.github.com/229788
+* "Path Management with multiple roots":http://gist.github.com/229789 (makes working with gem stacks transparent)
+* "Content Type negotiation":http://gist.github.com/229790
+* "Inheritable Stacks":http://gist.github.com/229792
+* Inheritable Templating System (see below)
+
+("See here for examples":https://gist.github.com/542e8b01412fe4a682bc )
 
 Stacks bundle these behaviors together into a cohesive unit.
 
@@ -74,41 +123,53 @@ The true power of a Pancake stack is that it is fully inheritable.
 
 h2. Stack Inheritance
 
-When you inherit a stack, you're really inheriting a full applictation.  All the features above are inherited along with the stack class.
+When you inherit a stack, you're really inheriting a full application.  All the features above are inherited along with the stack class.
 
 The easiest way to explain stack inheritance is perhaps with an example.
 
-Lets take the example of a basic application skeleton.  Many times I've seen github repos with pre-generated applications with some basic functionality.  This is then cloned as a start point for further app development.  It's basically the same as a generator but a little more flexible.  What if rather than generate an application skeleton with the basic functionality, you could construct a stack complete with router, default configuration, base templates, css and javascript, even mounted applications, and gem it up.  Then when you want to start an application you just require the gem and inherit the stack class.  This is what Pancake stacks provide.
+Let's take the example of a basic application skeleton.  Many times I've seen GitHub repos with pre-generated applications with some basic functionality.  This is then cloned as a start point for further app development.  It's basically the same as a generator but a little more flexible.  What if rather than generate an application skeleton with the basic functionality, you could construct a stack complete with router, default configuration, base templates, css and javascript, even mounted applications, and gem it up?  Then when you want to start an application you just require the gem and inherit the stack class.  This is what Pancake stacks provide.
 
 <pre><code>class MyStack < SomeOtherStack; end # A full application </code></pre>
 
 h3. Namespacing
 
-Pancake makes heavy use of namespacing.  Namespacing is a good idea to begin with, but inside mounted applications it's a must.  By embracing the constraint of namespacing, there are many benefits.  Unexpected name clashes of course being the big one.
+Pancake makes heavy use of namespacing.  Namespacing is a good idea to begin with, but inside mounted applications it's a must.  Embracing the constraint of namespacing provides many benefits.  Avoiding unexpected name clashes, of course, is the big one.
 
 h3. Inheritable Inner Classes
 
-There a fairly unique issue with inheriting a full application.  Model data clashes.
+There is a fairly unique issue when inheriting a full application.  Model data may clash.
 
-Normally when you inherit a class in Ruby, when you reference an inner class in the child, it's actually a reference to the inner class in the parent.  Lets see why this is a problem.
+Normally when you inherit a class in Ruby, when you reference an inner class in the child, it's actually a reference to the inner class in the parent.  Let's see why this is a problem:
 
-<pre><code>class AStack < Pancake::Stack
+<pre><code>class BlogStack < Pancake::Stack
   class Post < ActiveRecord::Base
     # post code
   end
 end
 
-class AnotherStack  < AStack; end
-class ADifferentOne < AStack; end
+class BobsBlog  < BlogStack; end
+class RosesBlog < BlogStack; end
 
-AnotherStack::Post == ADifferentOne::Post == AStack::Post
+BobsBlog::Post == RosesBlog::Post == BlogStack::Post
+</code></pre>
+
+Now, let's mount those inside some master stack:
+
+<pre><code>class MyMasterStack < Pancake::Stack
+  router.mount(RobsBlog,      "/rob")
+  router.mount(RosesBlog,     "/rose")
+end
 </code></pre>
 
-When we create posts in all 3 stacks, and then select the posts in AStack::Post.all we'll actually get the posts from all of the stacks.  This referencing of inner classes is great for ruby efficiency, but not so good when we want to keep data seperate.
+Now, Bob creates a post at his blog.  Then goes away and creates the model (BlogStack::Post).
 
-Awesomely some of the ORM's include STI (Single Table Inheritance) that we can make use of.  When using Pancake, we can set an inner class to inherit along with the parent.  Lets have another look at that example:
+Now someone visits Rose's blog.  Because both Bob's and Rose's blogs _reference_ the same BlogStack::User model, Bob's post is fetched when we do a RosesBlog::Post.all
 
-<pre><code>class AStack < Pancake::Stack
+It's efficient for Ruby to reference the parent class's inner class like this, but it's not always what we want.
+
+Awesomely, some of the ORM's include STI (Single Table Inheritance) that we can make use of.  When using Pancake, we can set an inner class to inherit along with the parent.  Lets have another look at that example:
+
+<pre><code>class BlogStack < Pancake::Stack
   inheritable_inner_classes :Post
 
   class Post < ActiveRecord::Base
@@ -116,39 +177,41 @@ Awesomely some of the ORM's include STI (Single Table Inheritance) that we can m
   end
 end
 
-class AnotherStack  < AStack; end
-class ADifferentOne < AStack; end
+class BobsBlog  < BlogStack; end
+class RosesBlog < BlogStack; end
 
-class FurtherDown   < AnotherStack; end
+class RosesOtherBlog  < RosesBlog; end
 
 # Results in
 
-class AnotherStack::Post  < AStack::Post;       end
-class ADifferentOne::Post < AStack::Post;       end
-class FurtherDown::Post   < AnotherStack::Post; end
+class BobsBlog::Post        < BlogStack::Post; end
+class RosesBlog::Post       < BlogStack::Post; end
+class RosesOtherBlog::Post  < RosesBlog::Post; end
 </code></pre>
 
-In this case STI will be activated and each stack will use it's own sti version of the Post model, segregating the data between the stacks.
+In this case STI will be activated and each stack will use its own STI version of the Post model, segregating the data between the stacks.
 
-If your Data layer doesn't support STI there are on_inherit hooks for all classes provided by Pancake to make any changes you need to.
+If your Data layer doesn't support STI, there are on_inherit hooks for all classes provided by Pancake to make any changes you need to.
 
 h2. Mounting Applications
 
-You can mount any valid rack application inside pancake.
+You can mount any valid Rack application inside Pancake. See "Rack Spec":http://rack.rubyforge.org/SPEC.html for guidance on what a valid Rack application is.
 
-Stacks look inside their root(s) for a "mounts" directory.  Where they in-turn look for a sub-directory containing the file "pancake.init".  When you want to mount an application you just include that file (and any support files) and the pancake stack will load it.
+Stacks look inside their root(s) for a "mounts" directory.  Where they in-turn look for a sub-directory containing the file "pancake_init.rb".  When you want to mount an application you just include that file (and any support files) and the Pancake stack will load it.
 
 <pre><code>my_stack
 -- mounts
   -- another_app
-    -- pancake.init # Called to initialize the mounted app
+    -- pancake_init.rb # Called to initialize the mounted app
 </code></pre>
 
+Usually pancake_init.rb would just require the files for your application.  But there's nothing stopping you from defining the entire application in there if you wanted.
+
 h2. Inheritable Templates
 
-Templates in Pancake are similar to Django templates.  They define named content_blocks that can supply a default, but that can also be inherited from, and have their content either combined with some other content, or replaced.  Unlike Django, templates are built on known templating languages like ERB and Haml.  The templating system in Pancake is built on top of the great "Tilt":http://github.com/rtomayko/tilt project.
+Templates in Pancake are similar to Django templates.  They define named content_blocks that can supply a default, but that can also be inherited from, and have their content combined with some other content or replaced.  Unlike Django, templates are built on known Ruby templating languages like ERB and Haml.  The templating system in Pancake is built on top of the great "Tilt":http://github.com/rtomayko/tilt project.
 
-Really this is best demonstrated with an example:
+This is best demonstrated with an example:
 
 <pre><code># base.html.erb
 <html>
@@ -188,13 +251,13 @@ Really this is best demonstrated with an example:
 <% end -%>
 </code></pre>
 
-When you @render :index@ in your stack, the index template will be activated, rendering the :base template but replacing the content_block, :content, with new data.  And appending to the :navigation block.
+When you <code>render :index</code> in your stack, the index template will be activated, rendering the :base template but replacing the content_block, :content, with new data.  And appending to the :navigation block.
 
-Templates can be inherited as many times as required, so you could inherit from the :index template to build on it's content.
+Templates can be inherited as many times as required, so you could inherit from the :index template to build on its content.
 
 When specifying which template to inherit from, you can dynamically specify which template you'd like to use if it makes sense to do so.
 
-At the moment only ERB, Erubis and Haml are supported with inheritable templates.  Other tilt templates are able to be rendered, but not inherited.
+At the moment only ERB, Erubis and Haml are supported with inheritable templates.  Other Tilt templates are able to be rendered, but the inheritance features are not supported.
 
 h2. Short Stack
 
@@ -208,13 +271,13 @@ h3. Get Started
 
 h4. Install
 
-@$ gem install pancake@
+<code>$ gem install pancake</code>
 
 h4. Generate your stack
 
 To start with a short stack use pancakes built in generator:
 
-@$ pancake-gen short my_stack@
+<code>$ pancake-gen short my_stack</code>
 
 This will generate the basic stack for you.  It's generated as a gem and based on Jeweler so you can gem it up super easy.
 
@@ -226,18 +289,18 @@ This will generate the basic stack for you.  It's generated as a gem and based o
   provides :html, :xml, :json
 
   get "(/)",  :_name => :home do
-    v[:some_models] = SomeModel.all
+    vars[:some_models] = SomeModel.all
     render :welcome
   end
 
   get "/new", :_name => :new do
-    v[:some_model] = SomeModel.new(params[:some_model])
+    vars[:some_model] = SomeModel.new(params[:some_model])
     render :new
   end
 
   post "(/)" do
-    v[:some_model] = SomeModel.new(params[:some_model])
-    if v[:some_model].save
+    vars[:some_model] = SomeModel.new(params[:some_model])
+    if vars[:some_model].save
       redirect url(:home)
     else
       render :new
@@ -246,27 +309,40 @@ This will generate the basic stack for you.  It's generated as a gem and based o
 end
 </code></pre>
 
-h4. The Vault
+h4. The Vars
 
-In the example above you can see the "v" method.  This method accesses the vault.  The vault is where per-request data may be stored for later use.  In this case, the data is stored so that we can access it in the views.
+In the example above you can see the "vars" method.  This method provides a place for variables on a per-request basis for later use.  In this case, the data is stored so that we can access it in the views.  It could just as easily be used to share information between middlewares.
 
-This is a way to seperate the concerns of Controller and View.  These contexts are supposed to be seperate.  Breaking the encapsulation of instance variables does not need to be done in a short stack.
+This is a way to separate the concerns of Controller and View.  These contexts are supposed to be separate.  Breaking the encapsulation of instance variables does not need to be done in a short stack.
 
 h4. Templates
 
 Templates are searched for in (stack root)/views/<name>.<format>.<template_engine> and rendered.
 
+Templates are separate in each sub-application and will not clash.  They're able to be looked up in parent stacks, however.  Meaning, if you inherit from AStack, all of AStacks views will be used unless you replace them in the child stacks views directory.
+
 h2. URL generation
 
-When you're in a stack, you can call @url(named_url) to generate a url.  This will generate the url, taking into account the mount path for the stack.
+When you're in a stack, you can call @url(named_url)@ to generate a url.  This will generate the url, taking into account the mount path for the stack.
 
 You can generate urls for other stacks also by using the global Pancake.url helper.
 
 <pre><code>Pancake.url(SomeStack, :named_url)</code></pre>
 
-There's a whole bunch more to Pancake than what I can go over here.  But hopefully I've been able to provide a taste of what it is and why I think it's pretty awesome in the up-coming Rack landscape.
+There's a whole bunch more to Pancake than I can go over here.  But hopefully I've been able to provide a taste of what it is and why I think it's pretty awesome in the upcoming Rack landscape.
+
+h2. Community
+
+IRC:          #pancake
+"Google Group":http://groups.google.com.au/group/pancake-stacks
+Twitter:      #pancakestacks (hashtag)
+"Blog / News":http://pancakestacks.wordpress.com
+
+h2. Bugs
+
+If you find a bug please report it at "our tails account":http://www.bugtails.com/projects/259/show.html, create a fork, and publish your fix in a topic branch.
 
-h4. Note on Patches/Pull Requests
+h3. Note on Patches/Pull Requests
 
 * Fork the project.
 * Make your feature addition or bug fix.
@@ -275,7 +351,7 @@ h4. Note on Patches/Pull Requests
 * 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)
-* h4. me a pull request. Bonus points for topic branches.
+* send me a pull request. Bonus points for topic branches.
 
 h4. Copyright
 

data/TODO

@@ -2,16 +2,7 @@ TODO:
 
 * Add default middleware to the short stack
 * Add a default base template and some default css to the short stack
-* Add a global logger
-* Add some view helpers
-** url, link_to, form_for, form_field_helpers (can we use formtastic), v[:data]
-* Add partial support
-* Add sass support so that a stack can compile sass
-* Add a mechanism for a rake task to be called on the parent and all mounted stacks
-* Add a way to cache public files into the pancake roots public directory
 * Add bundler support
 * Do some introductory posts
 * optimise template lookup
-* Add caching / symlinking option for static middlware to prevent lookup
-* Add a rake task to copy / symlink all mounted apps public files into the public Pancake.public directory
 

data/bin/pancake-gen

@@ -6,8 +6,6 @@ require 'pancake/generators'
 
 # TODO update for pancake to have a version
 case ARGV.shift
-when "stack"
-  Pancake::Generators::Stack.start
 when "short"
   Pancake::Generators::Short.start
 when "micro"

data/lib/pancake.rb

@@ -8,6 +8,7 @@ require 'extlib/object'
 require 'extlib/symbol'
 require 'extlib/blank'
 require "extlib/dictionary"
+require 'extlib/mash'
 require 'extlib/logger'
 require 'usher'
 require 'usher/interface/rack_interface'
@@ -18,6 +19,7 @@ $:.unshift File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
 module Pancake
   autoload    :Logger,    "pancake/logger"
   autoload    :Constants, "pancake/constants"
+  autoload    :Console,   "pancake/console"
 
   module Stacks
     autoload :Short,      "pancake/stacks/short"

data/lib/pancake/console.rb

@@ -0,0 +1,27 @@
+require 'rack/test'
+class Pancake::Console
+  attr_accessor :app
+  include Rack::Test::Methods
+
+  def initialize(stack)
+    @stack    = stack
+    @app      = stack.stackup(:master => true)
+    app = self
+    Object.__send__(:define_method, :stack){ app }
+    Pancake.handle_errors! true
+    Pancake.configuration.log_to_file = false
+
+    require 'irb'
+    require 'irb/completion'
+    if File.exists? ".irbrc"
+      ENV['IRBRC'] = ".irbrc"
+    end
+
+    catch(:IRB_EXIT) do
+      IRB.start
+      exit
+    end
+  end
+end
+
+

data/lib/pancake/generators/templates/short/%stack_name%/lib/%stack_name%.rb.tt

@@ -1,5 +1,10 @@
 class <%= stack_name.camel_case %> < Pancake::Stacks::Short
   add_root(__FILE__, "<%= stack_name %>")
+
+  # Hook to use before we mount any applications
+  # before_mount_applications do
+  # end
+
   initialize_stack
 end
 

data/lib/pancake/generators/templates/short/%stack_name%/lib/%stack_name%/config/config.rb.tt

@@ -0,0 +1,23 @@
+# Enter any global configuration for the stack in this file.
+
+class <%= stack_name.camel_case %>
+  # include middleware for the development stack
+  # Labels can be set in the config/environments/<env>.rb file to limit
+  # middleware loading.
+  # stack(:middleware_name, :labels => [:development, :production]).use(MiddlewareClass)
+
+  class self::Configuration
+    # Add defaults to your stack configuration.
+    # This is scoped to this stack, and is inhertied into child stacks
+    #
+    # Fixed value defaults:
+    #   default :var_name, :value, "A description of the variable"
+    #
+    # Lazy Defaults:
+    #   default :var_name, lambda{ configuration_method }, "Some Description"
+
+    # Declare methods on your configuraiton
+    # def configuration_method; #stuff; end
+  end
+end
+

data/lib/pancake/generators/templates/short/%stack_name%/lib/%stack_name%/config/environments/development.rb.tt

@@ -0,0 +1,18 @@
+Pancake.logger.info "Loading Development Environment"
+
+# Set the middleware lables to load
+Pancake.stack_labels = [:development]
+
+# Pancake.handle_errors!(true) # uncomment to have the stack handle any errors that occur
+
+class <%= stack_name.camel_case %>
+  # include middleware for the development stack
+  # stack(:middleware_name).use(MiddlewareClass)
+end
+
+# Add code to hooks.  Default available hooks:
+# :before_build_stack, :before_mount_applications, :after_initialize_application, :after_build_stack
+
+# <%= stack_name.camel_case %>.before_build_stack do
+#   # stuff to do
+# end

data/lib/pancake/generators/templates/short/%stack_name%/lib/%stack_name%/config/environments/production.rb.tt

@@ -0,0 +1,19 @@
+Pancake.logger.info "Loading Production Environment"
+
+# Set the middleware lables to load
+Pancake.stack_labels = [:production]
+
+Pancake.handle_errors!(true) # uncomment to have the stack handle any errors that occur
+
+class <%= stack_name.camel_case %>
+  # include middleware for the development stack
+  # stack(:middleware_name).use(MiddlewareClass)
+end
+
+# Add code to hooks.  Default available hooks:
+# :before_build_stack, :before_mount_applications, :after_initialize_application, :after_build_stack
+
+# <%= stack_name.camel_case %>.before_build_stack do
+#   # stuff to do
+# end
+

data/lib/pancake/generators/templates/short/%stack_name%/lib/%stack_name%/config/environments/staging.rb.tt

@@ -0,0 +1,20 @@
+Pancake.logger.info "Loading Staging Environment"
+
+# Set the middleware lables to load
+Pancake.stack_labels = [:staging]
+
+Pancake.handle_errors!(true) # uncomment to have the stack handle any errors that occur
+
+class <%= stack_name.camel_case %>
+  # include middleware for the development stack
+  # stack(:middleware_name).use(MiddlewareClass)
+end
+
+# Add code to hooks.  Default available hooks:
+# :before_build_stack, :before_mount_applications, :after_initialize_application, :after_build_stack
+
+# <%= stack_name.camel_case %>.before_build_stack do
+#   # stuff to do
+# end
+
+

data/lib/pancake/generators/templates/short/%stack_name%/lib/%stack_name%/script/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+ENV['RACK_ENV'] ||= ARGV[0] || "development"
+
+ARGV.clear # Don't pass args to irb
+
+require 'rubygems'
+require 'pancake'
+
+Pancake.root = Pancake.get_root(__FILE__, "..")
+
+# Load the <%= stack_class.camel_case %> stack
+require File.join(Pancake.root, "..", "<%= stack_class %>")
+Pancake::Console.new(<%= stack_class.camel_case %>)
+
+

data/lib/pancake/generators/templates/short/%stack_name%/lib/%stack_name%/tasks/%stack_name%.rake.tt

@@ -0,0 +1,4 @@
+namespace :<%= stack_name %> do
+  # Create your tasks here
+end
+

data/lib/pancake/mime_types.rb

@@ -15,7 +15,7 @@ module Pancake
     def self.types
       @types || reset! && @types
     end
-    
+
     # Finds a Pancake::MimeTypes::Type object by the provided
     # extension
     #
@@ -35,9 +35,9 @@ module Pancake
       ext = ext.to_s
       types.detect{|t| t.extension == ext}
     end
-    
+
     # Pancake manages mime types by grouping them together.
-    # 
+    #
     # @return [Set<Pancake::MimeTypes::Type>] - A enumerable of Type
     # objects associated with this group
     #
@@ -47,11 +47,11 @@ module Pancake
     def self.groups
       @groups || reset! && @groups
     end
-    
+
     # Pancake::MimeTypes are managed by grouping them together.
     # Each group may consist of many mime types by extension
     # By Accessing a group that doesn't yet exist, the group is
-    # created and initialized with the matching type wwith extension
+    # created and initialized with the matching type with extension
     # A group may have many mime type / accept types associated with
     # it
     #
@@ -71,7 +71,7 @@ module Pancake
     def self.group(name)
       groups[name.to_s]
     end
-    
+
     # Creates a group of mime types.  Any group of mimes can be
     # arbitrarily grouped under the specified name.  The group is
     # initilized with the mime type whose extension matches the name,
@@ -92,7 +92,7 @@ module Pancake
       end
       group(name)
     end
-    
+
     # Resets the Pancake::MimeType cache and re-creates the
     # Pancake::MimeTypes default types and groups
     # Good for use in specs
@@ -121,13 +121,13 @@ module Pancake
         e = $1
         t = type_by_extension(ext)
         if t
-          t.type_strings << type 
+          t.type_strings << type
        else
-          t = Type.new(e, type) 
+          t = Type.new(e, type)
         end
       end
     end
-    
+
     # Used in specs to reset the default mime groups of
     # pancake::MimeTypes
     # @api private
@@ -139,7 +139,7 @@ module Pancake
 
       group_as(:svg, "svgz")
     end
-    
+
     # Negotiates the type and group that the accept_type string
     # matches
     # @param type [String] the accept_type header string from the
@@ -162,16 +162,16 @@ module Pancake
       provided = provided.flatten
       key = [accepted_types, provided]
       return negotiated_accept_types[key] if negotiated_accept_types[key]
-      
+
       accepted_type = nil
-      
+
       if accepted_types.include?("*/*")
         name = provided.first
         accepted_type = group(name).first
         negotiated_accept_types[key] = [name, accepted_type.type_strings.first, accepted_type]
         return negotiated_accept_types[key]
       end
-      
+
       # Check to see if any accepted types match
       accepted_types.each do |at|
         provided.flatten.each do |name|
@@ -190,7 +190,7 @@ module Pancake
       end
       nil
     end
-    
+
     # Negotiates the content type based on the extension and the
     # provided groups to see if there is a match.
     #
@@ -223,7 +223,7 @@ module Pancake
       end
       result
     end # self.negotiate_by_extension
-    
+
 
     # A basic type for mime types
     # Each type can have an extension and many type strings that
@@ -243,7 +243,7 @@ module Pancake
         MimeTypes.types << self
       end
     end
-    
+
     private
     # Checks to see if a group matches an accept type string
     # @api private
@@ -252,13 +252,13 @@ module Pancake
         t.type_strings.include?(accept_type) || accept_type == "*/*"
       end
     end
-    
+
     # Provides a cache for already negotiated types
     # @api private
     def self.negotiated_accept_types
       @negotiated_accept_types ||= {}
     end
-        
+
   end # MimeTypes
 end # Pancake
 

data/lib/pancake/mixins/request_helper.rb

@@ -3,20 +3,20 @@ module Pancake
     # Some helpers for requests that come in handy for applications that
     # are part of stacks
     module RequestHelper
-      VAULT_KEY = 'pancake.request.vault'
+      VARS_KEY = 'pancake.request.vars'
 
-      # A data vault that allows you to carry data accross middlewares, controller / views etc.
+      # A data area that allows you to carry data accross middlewares, controller / views etc.
       # Stores the data in session for the length of the request.
       #
       # @example
-      #   vault[:user] = @user
+      #   vars[:user] = @user
       #   v[:user] == vault[:user]
       #   # This is now stored in the environment and is available later
-      def vault
-        env[VAULT_KEY] ||= {}
-        env[VAULT_KEY]
+      def vars
+        env[VARS_KEY] ||= {}
+        env[VARS_KEY]
       end
-      alias_method :v, :vault
+      alias_method :v, :vars
 
       # Generate a url for the current stacks router.
       #

data/lib/pancake/stack/bootloader.rb

@@ -19,7 +19,7 @@ Pancake::Stack::BootLoader.add(:load_mounted_inits, :level => :init) do
   def run!
     # Mount any stacks this stack may have in it.
     stack_class.roots.each do |root|
-      Dir["#{root}/mounts/*/pancake.init"].each{|f| load f if File.exists?(f)}
+      Dir["#{root}/mounts/*/pancake_init.rb"].each{|f| load f if File.exists?(f)}
     end
   end
 end

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

@@ -1,9 +1,3 @@
-Pancake::Stacks::Short::BootLoader.add(:paths, :before => :load_mounted_inits  ) do
-  def run!
-    stack_class::Controller.push_paths :views, ["app/views", "views"], "**/*"
-  end
-end
-
 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)

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

@@ -12,6 +12,7 @@ module Pancake
 
         class_inheritable_accessor :_handle_exception
 
+        push_paths(:views, ["app/views", "views"], "**/*")
 
         DEFAULT_EXCEPTION_HANDLER = lambda do |error|
           "#{error.name}: #{error.description}"
@@ -64,14 +65,14 @@ module Pancake
           # set the response header
           headers["Content-Type"] = ct
 
-          result = self.send(params['action'])
+          result = catch(:halt){ 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
+            Rack::Response.new((result || ""), status, headers).finish
           end
 
         rescue Errors::HttpError => e

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

@@ -3,6 +3,8 @@ module Pancake
     class Short < Pancake::Stack
       add_root(__FILE__, "default")
 
+      push_paths(:models,"models", "**/*.rb")
+
       def self.new_app_instance
         self::Controller
       end
@@ -32,6 +34,11 @@ module Pancake
         self::Controller.handle_exception(*args, &block)
       end
 
+      def self.helpers(&blk)
+        m = Module.new(&blk)
+        self::Controller.class_eval{ include m }
+      end
+
       # Gets a resource at a given path
       #
       # The block should finish with the final result of the action

data/spec/pancake/mixins/request_helper_spec.rb

@@ -30,7 +30,7 @@ describe Pancake::Mixins::RequestHelper do
       foo = FooBar.new
       foo.env = env
       foo.v[:data] = :some_data
-      env[Pancake::Mixins::RequestHelper::VAULT_KEY][:data].should == :some_data
+      env[Pancake::Mixins::RequestHelper::VARS_KEY][:data].should == :some_data
     end
   end
 end

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

@@ -402,5 +402,40 @@ describe Pancake::Stacks::Short::Controller do
         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

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

@@ -32,6 +32,8 @@ describe Pancake::Stacks::Short do
         render :inherited_from_base
       end
     end
+
+    @app = ShortFoo
   end
 
   after do
@@ -39,7 +41,7 @@ describe Pancake::Stacks::Short do
   end
 
   def app
-    ShortFoo.stackup
+    @app.stackup
   end
 
   it "should go through the middleware to get to the actions" do
@@ -62,4 +64,46 @@ describe Pancake::Stacks::Short do
       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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: pancake
 version: !ruby/object:Gem::Version 
-  version: 0.1.13
+  version: 0.1.15
 platform: ruby
 authors: 
 - Daniel Neighman
@@ -9,7 +9,7 @@ autorequire: pancake
 bindir: bin
 cert_chain: []
 
-date: 2009-11-09 00:00:00 +11:00
+date: 2009-11-12 00:00:00 +11:00
 default_executable: pancake-gen
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -102,6 +102,7 @@ files:
 - lib/pancake.rb
 - lib/pancake/bootloaders.rb
 - lib/pancake/configuration.rb
+- lib/pancake/console.rb
 - lib/pancake/constants.rb
 - lib/pancake/core_ext/class.rb
 - lib/pancake/core_ext/object.rb
@@ -113,12 +114,11 @@ files:
 - lib/pancake/generators/base.rb
 - lib/pancake/generators/micro_generator.rb
 - lib/pancake/generators/short_generator.rb
-- lib/pancake/generators/stack_generator.rb
 - lib/pancake/generators/templates/common/dotgitignore
 - lib/pancake/generators/templates/common/dothtaccess
 - lib/pancake/generators/templates/micro/%stack_name%/%stack_name%.rb.tt
 - lib/pancake/generators/templates/micro/%stack_name%/config.ru.tt
-- lib/pancake/generators/templates/micro/%stack_name%/pancake.init.tt
+- lib/pancake/generators/templates/micro/%stack_name%/pancake_init.rb.tt
 - lib/pancake/generators/templates/micro/%stack_name%/public/.empty_directory
 - lib/pancake/generators/templates/micro/%stack_name%/tmp/.empty_directory
 - lib/pancake/generators/templates/micro/%stack_name%/views/root.html.haml
@@ -129,29 +129,20 @@ files:
 - lib/pancake/generators/templates/short/%stack_name%/lib/%stack_name%.rb.tt
 - lib/pancake/generators/templates/short/%stack_name%/lib/%stack_name%/%stack_name%.rb.tt
 - lib/pancake/generators/templates/short/%stack_name%/lib/%stack_name%/config.ru.tt
+- lib/pancake/generators/templates/short/%stack_name%/lib/%stack_name%/config/config.rb.tt
+- lib/pancake/generators/templates/short/%stack_name%/lib/%stack_name%/config/environments/development.rb.tt
+- lib/pancake/generators/templates/short/%stack_name%/lib/%stack_name%/config/environments/production.rb.tt
+- lib/pancake/generators/templates/short/%stack_name%/lib/%stack_name%/config/environments/staging.rb.tt
+- lib/pancake/generators/templates/short/%stack_name%/lib/%stack_name%/models/.empty_directory
 - lib/pancake/generators/templates/short/%stack_name%/lib/%stack_name%/mounts/.empty_directory
 - lib/pancake/generators/templates/short/%stack_name%/lib/%stack_name%/public/.empty_directory
+- lib/pancake/generators/templates/short/%stack_name%/lib/%stack_name%/script/console
+- lib/pancake/generators/templates/short/%stack_name%/lib/%stack_name%/tasks/%stack_name%.rake.tt
 - lib/pancake/generators/templates/short/%stack_name%/lib/%stack_name%/tmp/.empty_directory
 - lib/pancake/generators/templates/short/%stack_name%/lib/%stack_name%/views/root.html.haml
-- lib/pancake/generators/templates/short/%stack_name%/pancake.init.tt
+- lib/pancake/generators/templates/short/%stack_name%/pancake_init.rb.tt
 - lib/pancake/generators/templates/short/%stack_name%/spec/%stack_name%_spec.rb.tt
 - lib/pancake/generators/templates/short/%stack_name%/spec/spec_helper.rb.tt
-- lib/pancake/generators/templates/stack/%stack_name%/LICENSE.tt
-- lib/pancake/generators/templates/stack/%stack_name%/README.tt
-- lib/pancake/generators/templates/stack/%stack_name%/Rakefile.tt
-- lib/pancake/generators/templates/stack/%stack_name%/VERSION.tt
-- lib/pancake/generators/templates/stack/%stack_name%/lib/%stack_name%.rb.tt
-- lib/pancake/generators/templates/stack/%stack_name%/lib/%stack_name%/config.ru.tt
-- lib/pancake/generators/templates/stack/%stack_name%/lib/%stack_name%/config/environments/development.rb.tt
-- lib/pancake/generators/templates/stack/%stack_name%/lib/%stack_name%/config/environments/production.rb.tt
-- lib/pancake/generators/templates/stack/%stack_name%/lib/%stack_name%/config/router.rb.tt
-- lib/pancake/generators/templates/stack/%stack_name%/lib/%stack_name%/gems/cache/.empty_directory
-- lib/pancake/generators/templates/stack/%stack_name%/lib/%stack_name%/mounts/.empty_directory
-- lib/pancake/generators/templates/stack/%stack_name%/lib/%stack_name%/public/.empty_directory
-- lib/pancake/generators/templates/stack/%stack_name%/lib/%stack_name%/tmp/.empty_directory
-- lib/pancake/generators/templates/stack/%stack_name%/pancake.init.tt
-- lib/pancake/generators/templates/stack/%stack_name%/spec/%stack_name%_spec.rb.tt
-- lib/pancake/generators/templates/stack/%stack_name%/spec/spec_helper.rb.tt
 - lib/pancake/hooks/inheritable_inner_classes.rb
 - lib/pancake/hooks/on_inherit.rb
 - lib/pancake/logger.rb

data/lib/pancake/generators/stack_generator.rb

@@ -1,17 +0,0 @@
-module Pancake
-  module Generators
-    class Stack < Base
-      argument :stack_name, :banner => "Name of stack"
-      
-      desc "Generates a stack"
-      def stack
-        say "Creating The Stack For #{stack_name}"
-        directory "stack/%stack_name%", stack_name
-        template  File.join(self.class.source_root, "common/dotgitignore"), "#{stack_name}/.gitignore"
-        template  File.join(self.class.source_root, "common/dothtaccess"),  "#{stack_name}/lib/#{stack_name}/public/.htaccess"
-      end
-       
-       
-    end
-  end
-end

data/lib/pancake/generators/templates/stack/%stack_name%/LICENSE.tt

@@ -1,20 +0,0 @@
-Copyright (c) <%= Date.today.year %> <YOUR NAME HERE>
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/pancake/generators/templates/stack/%stack_name%/README.tt

@@ -1,7 +0,0 @@
-= <%= stack_name %>
-
-Description goes here.
-
-== Copyright
-
-Copyright (c) <%= Date.today.year %> <YOUR NAME HERE>. See LICENSE for details.

data/lib/pancake/generators/templates/stack/%stack_name%/Rakefile.tt

@@ -1,53 +0,0 @@
-require 'rubygems'
-require 'rake'
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "<%= stack_name %>"
-    gem.summary = %Q{TODO}
-    gem.email = "TODO"
-    gem.homepage = "TODO"
-    gem.authors = ["TODO"]
-    gem.add_dependency "pancake", ">=0.1.8"
-    gem.files = FileList["[A-Z]*", "pancake.init", "{lib,spec,rails}/**/*"]
-    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
-  end
-
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
-end
-
-require File.join(File.dirname(__FILE__), "lib", "<%= stack_name %>")
-<%= stack_name.camel_case %>.load_rake_tasks!
-
-require 'spec/rake/spectask'
-Spec::Rake::SpecTask.new(:spec) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.spec_files = FileList['spec/**/*_spec.rb']
-end
-
-Spec::Rake::SpecTask.new(:rcov) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.pattern = 'spec/**/*_spec.rb'
-  spec.rcov = true
-end
-
-
-task :default => :spec
-
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  if File.exist?('VERSION.yml')
-    config = YAML.load(File.read('VERSION.yml'))
-    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
-  else
-    version = ""
-  end
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "foo #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
-

data/lib/pancake/generators/templates/stack/%stack_name%/VERSION.tt

@@ -1 +0,0 @@
-0.0.0

data/lib/pancake/generators/templates/stack/%stack_name%/lib/%stack_name%.rb.tt

@@ -1,4 +0,0 @@
-class <%= stack_name.camel_case %> < Pancake::Stack
-  add_root __FILE__, "<%= stack_name %>"
-  initialize_stack
-end

data/lib/pancake/generators/templates/stack/%stack_name%/lib/%stack_name%/config.ru.tt

@@ -1,12 +0,0 @@
-require 'rubygems'
-
-require 'pancake'
-require Pancake.get_root(__FILE__, "<%= stack_name %>")
-
-# get the application to run.  The applicadtion in the Pancake.start block
-# is the master application.  It will have all requests directed to it through the
-# pancake middleware
-# This should be a very minimal file, but should be used when any stand alone code needs to be included
-app = Pancake.start(:root => Pancake.get_root(__FILE__)){ <%= stack_name.camel_case %>.stackup(:master => true) }
-
-run app

data/lib/pancake/generators/templates/stack/%stack_name%/lib/%stack_name%/config/environments/development.rb.tt

@@ -1,18 +0,0 @@
-puts "Loading Development Environment"
-
-# Get Access
-Pancake.configuration.configs(<%= stack_name.camel_case %> ) do |config|
-  config.foo = :foo
-end
-
-# Allows Pancake to selectively apply middlewares in the stack.  
-# If a middleware is not declared with a specific stack label then it will always be loaded
-# You can specify Middleware to be active under particular stack labels only however.
-# 
-# Example
-# <%= stack_name.camel_case %>.stack(:my_middlware, :labels => [:demo, :development]).use(Middlware, :with => :opts)
-#
-# This would only include the middleware Middlware in stacks with either the :demo, or :development label 
-#
-# Setting The Pancake.stack_labels will use any relevant stacks
-Pancake.stack_labels = [:development]

data/lib/pancake/generators/templates/stack/%stack_name%/lib/%stack_name%/config/environments/production.rb.tt

@@ -1,18 +0,0 @@
-puts "Loading Production Environment"
-
-# Get Access
-Pancake.configuration.configs(<%= stack_name.camel_case %> ) do |config|
-  # config.foo = :foo
-end
-
-# Allows Pancake to selectively apply middlewares in the stack.  
-# If a middleware is not declared with a specific stack label then it will always be loaded
-# You can specify Middleware to be active under particular stack labels only however.
-# 
-# Example
-# <%= stack_name.camel_case %>.stack(:my_middlware, :labels => [:demo, :development]).use(Middlware, :with => :opts)
-#
-# This would only include the middleware Middlware in stacks with either the :demo, or :development label 
-#
-# Setting The Pancake.stack_labels will use any relevant stacks
-Pancake.stack_labels = [:production]

data/lib/pancake/generators/templates/stack/%stack_name%/lib/%stack_name%/config/router.rb.tt

@@ -1,6 +0,0 @@
-<%= stack_name.camel_case %>.router do |r|
-  # Add your routes here
-  r.add("/") do |e|
-    Rack::Response.new("Hi From <%= stack_name.camel_case %>").finish
-  end
-end

data/lib/pancake/generators/templates/stack/%stack_name%/pancake.init.tt

@@ -1 +0,0 @@
-require File.join(File.dirname(__FILE__), "lib", "<%= stack_name %>")

data/lib/pancake/generators/templates/stack/%stack_name%/spec/%stack_name%_spec.rb.tt

@@ -1,11 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "<%= stack_name %>" do
-  def app
-    <%= stack_name %>.stackup
-  end
-
-  it "fails" do
-    fail "hey buddy, you should probably rename this file and start specing for real"
-  end
-end

data/lib/pancake/generators/templates/stack/%stack_name%/spec/spec_helper.rb.tt

@@ -1,13 +0,0 @@
-require 'spec'
-require 'rack/test'
-require 'pancake'
-
-
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require '<%= stack_name -%>'
-
-Spec::Runner.configure do |config|
-  config.include(Rack::Test::Methods)
-  config.include(Pancake::Test::Matchers)
-end