pancake 0.1.12 → 0.1.13

data/README.textile

@@ -1,95 +1,284 @@
-__This read me is getting thrown to get there in little bits of time snatched between other bits of snatched time... it will be magnificient, eventually... please bare with it...__
+h1. Pancake
 
-h3. Whats this then
+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.
 
-A tool for making pancake stacks. Where, as you know, pancake == ruby web thing.
+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.
 
-It essentially takes the awesome "rack":rack.github.com and "rack router":http://github.com/carllerche/rack-router/ and mixes it with flour and water and eggs to bind it together into a pancake thin layer of goodness providing a structured way of orgnaising (stacking) your assortment of ruby web things. In doing so, it  allows you to provide each of your ruby web things (lets call them "middlewares") with some underlying contextual functionality.
+h2. Stacks
 
-h3. Why stack pancakes?
+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.
 
-Well, simply put, reuse! I'm building something... and what do you know i need another forum/asset manager/bla thing etc. Typically I can:
+The general form of a stack is as follows:
 
-  * Write/include the functionality directly in to my current app.
-  * Add a second app, theme it up similarly and use apache/nginx/other configs to glue it up, and perhaps come up with a devious approach for auth with some cunning SSO... or not
+<pre>
+-----------------------------------
+|                                 |
+|           Router                |
+|                                 |
+-----------------------------------
+|           Middleware            |
+-----------------------------------
+|           Middleware            |
+-----------------------------------
+|           Middleware            |
+-----------------------------------
+|                                 |
+|           Application           |
+|            Endpoint             |
+|                                 |
+-----------------------------------
+</pre>
 
-What we'd like to facilitate with pancake is you take your existing much loved forum/asset manager/bla thing etc and mount it into pancake, sharing auth and other contextual information between apps.
+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.
 
-Insert helpful diagram here...
+<pre><code>MyStack.router do |r|
+  r.mount(OtherStack, "/stack/mount/point")
+end</code></pre>
 
-h3. Getting Started
+A stack doesn't have to mount other stacks.  Pancake stacks are full applications in their own right and can be used standalone as Rack endpoints, or as middleware.
 
-h4. You'll need to have installed (as well as your usual ruby stuffs)...
+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.
 
-* wycats-thor 
-* Carllerches rack router
+All stacks are namespaced.  Pancake makes heavy use of namespacing to help construct applications concisely.
 
-h4. Installing
+h2. Middleware Stacks
 
-<pre>
-  $sudo gem install hassox-pancake
-</pre>
+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.
 
-h4. Create your own stack
+<pre><code>class MyStack < Pancake::Stack
+  stack(:session).use(Rack::Sessions::Cookie)
+  stack(:auth, :after => :session).use(Warden::Manager, #...)
 
-<pre>
-  $pancake-gen stack yummy-app
-</pre>
+  stack(:bugz, :labels => [:development]).use(Rack::Bug)
 
-h4. Does it work?
+  use(AlwaysUse)
+end
+</code></pre>
 
-(I've used curl here, feel free to use your point your browser to http://localhost:9292/ instead)
-<pre>
-  $cd yummy-app/lib/yummy-app
-  $rackup config.ru
-  Loading Development Environment
-</pre>
+h2. What can a stack do
 
-Now in your browser, visit http://localhost:9292/
-Or, with curl like here:
-<pre>
-  $curl -I localhost:9292
-  127.0.0.1 - - [26/Jul/2009 15:42:55] "HEAD / HTTP/1.1" 404 9 0.0011
-  HTTP/1.1 404 Not Found
-  Connection: close
-  Date: Sun, 26 Jul 2009 05:42:55 GMT
-  Content-Type: text/plain
-  Content-Length: 9
-</pre>
+Pancake provides a whole bunch of functionality as mixins.
 
-You should see 'NOT FOUND' in your browser window and something like this appear in your rackup console window.
+* 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
 
-<pre>
-  127.0.0.1 - - [26/Jul/2009 15:42:55] "GET / HTTP/1.1" 404 9 0.0011
-</pre>
+Stacks bundle these behaviors together into a cohesive unit.
 
-That 404 is good news! The stack is running.. we just haven't cooked any pancakes yet, theres nothing to find. Next step add something...
+The true power of a Pancake stack is that it is fully inheritable.
 
-h4. Routing
+h2. Stack Inheritance
 
-Edit config/router.rb with:
-<pre>
-  home = lambda {|e| [200,{"Content-Type" => "text/plain", "Content-Length" => "12"}, "Welcome home" ]}
-  
-  YummyApp.add_routes do |r|
-    r.map "/", :to => home
+When you inherit a stack, you're really inheriting a full applictation.  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.
+
+<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.
+
+h3. Inheritable Inner Classes
+
+There a fairly unique issue with inheriting a full application.  Model data clashes.
+
+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.
+
+<pre><code>class AStack < Pancake::Stack
+  class Post < ActiveRecord::Base
+    # post code
   end
-</pre>
-Now, restart the server (^C) and try again:
-<pre>
-  $rackup config.ru
-  Loading Development Environment
-</pre>
-Reload you page and you should see "Welcome home".
-And, in your console window, rack should log the request like so:
-<pre>
-  127.0.0.1 - - [26/Jul/2009 16:16:23] "GET / HTTP/1.1" 200 12 0.0012
-  127.0.0.1 - - [26/Jul/2009 16:16:23] "GET /favicon.ico HTTP/1.1" 200 12 0.0012
-</pre>
+end
+
+class AnotherStack  < AStack; end
+class ADifferentOne < AStack; end
+
+AnotherStack::Post == ADifferentOne::Post == AStack::Post
+</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.
+
+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 AStack < Pancake::Stack
+  inheritable_inner_classes :Post
+
+  class Post < ActiveRecord::Base
+    # post code
+  end
+end
+
+class AnotherStack  < AStack; end
+class ADifferentOne < AStack; end
+
+class FurtherDown   < AnotherStack; end
+
+# Results in
+
+class AnotherStack::Post  < AStack::Post;       end
+class ADifferentOne::Post < AStack::Post;       end
+class FurtherDown::Post   < AnotherStack::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.
+
+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.
+
+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.
+
+<pre><code>my_stack
+-- mounts
+  -- another_app
+    -- pancake.init # Called to initialize the mounted app
+</code></pre>
+
+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.
+
+Really this is best demonstrated with an example:
+
+<pre><code># base.html.erb
+<html>
+  <head><title>Hey There</title></head>
+  <body>
+  <h1>My Page</h1>
+
+  <ul class='nav'>
+    <% content_block :navigation do -%>
+      <li><a href="/">Home</a></li>
+    <% end -%>
+  </ul>
+
+  <hr/>
+
+  <% content_block :content do- %>
+    <div class='emtpy'>Nothing Found</div>
+  <% end -%>
+
+  <% content_block :footer do -%>
+    Footer Text
+  <% end -%>
+</html>
+
+</code></pre>
+<pre><code># index.html.erb
+
+<% inherits_from :base %>
+
+<% content_block :navigation do -%>
+  <%= content_block.super %>
+  <li><a href="/index">Home</a></li>
+<% end -%>
+
+<% content_block :content do -%>
+  # Stuff for the content
+<% 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.
+
+Templates can be inherited as many times as required, so you could inherit from the :index template to build on it's 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.
+
+h2. Short Stack
+
+As part of the development of Pancake, the initial milestone was to develop a stack based on the awesome "Sinatra":http://sinatrarb.com framework.  This was done as a way to develop Pancake to a simple level, not as a way to replace Sinatra.  Pancake is very happy to mount Sinatra applications inside and make use of them.
+
+A short stack is a resource focused.  It uses the HTTP verbs and routes to access the code that defines a "resource"
+
+Short stacks make use of content negotiation and views in addition to the normal stack behavior.
+
+h3. Get Started
+
+h4. Install
+
+@$ gem install pancake@
+
+h4. Generate your stack
+
+To start with a short stack use pancakes built in generator:
+
+@$ pancake-gen short my_stack@
+
+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.
+
+<pre><code>class MyStack < Pancake::Stacks::Short
+  add_root(__FILE__)
+
+  router.mount(UserStack, "/users")
+
+  provides :html, :xml, :json
+
+  get "(/)",  :_name => :home do
+    v[:some_models] = SomeModel.all
+    render :welcome
+  end
+
+  get "/new", :_name => :new do
+    v[: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
+      redirect url(:home)
+    else
+      render :new
+    end
+  end
+end
+</code></pre>
+
+h4. The Vault
+
+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.
+
+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.
+
+h4. Templates
+
+Templates are searched for in (stack root)/views/<name>.<format>.<template_engine> and rendered.
+
+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.
+
+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.
+
+h4. 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)
+* h4. me a pull request. Bonus points for topic branches.
 
-h4. Whats next:
+h4. Copyright
 
-Well we don't want to be writing our apps as lambdas jemmied into the router, instead next we start to build stacks, out of other middlewares... merbs, other pancake stacks, some sinatra, more rack ups or what ever.
+Copyright (c) 2009 Daniel Neighman. See LICENSE for details.
 
-To be continued...
 

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

@@ -4,9 +4,9 @@ require 'pancake'
 require ::File.join(::File.expand_path(::File.dirname(__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 
+# 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 }
+app = Pancake.start(:root => Pancake.get_root(__FILE__)){ <%= stack_name.camel_case %>.stackup(:master => true) }
 
-run app
+run app

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

@@ -18,6 +18,9 @@ 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'

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

@@ -5,6 +5,6 @@ require ::File.join(::File.expand_path(::File.dirname(__FILE__)), "..", "<%= sta
 # 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 }
+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%/Rakefile.tt

@@ -18,6 +18,9 @@ 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'

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

@@ -7,6 +7,6 @@ require Pancake.get_root(__FILE__, "<%= stack_name %>")
 # 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 }
+app = Pancake.start(:root => Pancake.get_root(__FILE__)){ <%= stack_name.camel_case %>.stackup(:master => true) }
 
 run app

data/lib/pancake/mixins/render/render.rb

@@ -40,11 +40,11 @@ module Pancake
         _concat_methods[ Tilt::ErubisTemplate ] = :_erb_concat
 
         module Renderer
-          def render(template, opts = {})
+          def render(template, opts = {}, &blk)
             template = _view_context_for.template(template)
             raise TemplateNotFound unless template
             result = _with_renderer template do
-              _current_renderer.render(self, opts)
+              _current_renderer.render(self, opts, &blk) # only include the block once
             end
 
             if @_inherit_helper.inherits_from

data/lib/pancake/mixins/render.rb

@@ -74,6 +74,8 @@ module Pancake
           # Get the view context for the tempalte
           template, vc_class = self.class._renderer_and_view_context_class_for(template_name)
 
+          yield v if block_given?
+
           view_context = vc_class.new(env, self)
           view_context_before_render(view_context)
           view_context.render(template, opts)

data/lib/pancake/mixins/request_helper.rb

@@ -9,12 +9,14 @@ module Pancake
       # Stores the data in session for the length of the request.
       #
       # @example
-      #   v[:user] = @user
+      #   vault[:user] = @user
+      #   v[:user] == vault[:user]
       #   # This is now stored in the environment and is available later
-      def v
+      def vault
         env[VAULT_KEY] ||= {}
         env[VAULT_KEY]
       end
+      alias_method :v, :vault
 
       # Generate a url for the current stacks router.
       #

data/lib/pancake/paths.rb

@@ -23,8 +23,8 @@ module Pancake
   #
   #   Foo.dirs_and_glob_for(:model) == [
   #     ["#{root}/relative/path/to/models",         "**/*.rb"],
-  #     ["#{root}//another/path/to/models",         "**/*.rb"],
-  #     ["#{root}//yet/another",                    nil]
+  #     ["#{root}/another/path/to/models",         "**/*.rb"],
+  #     ["#{root}/yet/another",                    nil]
   #   ]
   #
   #   Foo.paths_for(:model) == [

data/lib/pancake/stack/bootloader.rb

@@ -24,7 +24,17 @@ Pancake::Stack::BootLoader.add(:load_mounted_inits, :level => :init) do
   end
 end
 
-Pancake::Stack::BootLoader.add(:load_configuration, :level => :init) do
+Pancake::Stack::BootLoader.add(:set_as_master) do
+  def run!
+    return unless config[:master]
+    roots = stack_class.roots.dup
+    roots.each do |root|
+      stack_class.roots << File.join(root, "master")
+    end
+  end
+end
+
+Pancake::Stack::BootLoader.add(:load_configuration) do
   def run!
     stack_class.roots.each do |root|
       stack_class.paths_for(:config).each{|f| require f.join}
@@ -32,7 +42,7 @@ Pancake::Stack::BootLoader.add(:load_configuration, :level => :init) do
   end
 end
 
-Pancake::Stack::BootLoader.add(:load_application, :level => :init) do
+Pancake::Stack::BootLoader.add(:load_application) do
   def run!
     stack_class.roots.each do |root|
       [:models, :controllers].each do |type|

data/lib/pancake/stack/defaults/tasks/pancake.rake

@@ -0,0 +1,9 @@
+namespace :pancake do
+  desc "symlink all public files to the current public directory"
+  task :symlink_to_public do
+    puts "Symlinking files to public"
+    THIS_STACK.stackup
+    THIS_STACK.symlink_public_files!
+    puts "Done"
+  end
+end

data/lib/pancake/stack/stack.rb

@@ -13,10 +13,13 @@ module Pancake
     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",               "**/*")
+
 
     #Iterates the list of roots in the stack, and initializes the app found their
     def self.initialize_stack
-      raise "Application root not set" if roots.empty?
+      raise "Stack root not set" if roots.empty?
 
       # Run any :init level bootloaders for this stack
       self::BootLoader.run!(:stack_class => self, :only => {:level => :init})
@@ -32,6 +35,8 @@ module Pancake
     def self.add_root(*args)
       roots << Pancake.get_root(*args)
     end
+    add_root __FILE__, "defaults"
+
 
     def self.initialized?
       !!@initialized
@@ -57,12 +62,72 @@ module Pancake
     end
 
     # Construct a stack using the application, wrapped in the middlewares
-    # :api: public
+    # @api public
     def self.stackup(opts = {}, &block)
       app = new(nil, opts, &block)
       Pancake.configuration.configs[app.app_name].router
     end # stackup
 
+    # 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
+    #
+    # Tasks found in all stack roots are loaded in the order of the stack roots declearations
+    #
+    # @api public
+    def self.load_rake_tasks!(opts={})
+      stackup(opts) # load the application
+      opts[:_rake_files_loaded] ||= []
+
+      # For each mounted application, load the rake tasks
+      self::Router.mounted_applications.each do |app|
+        if app.mounted_app.respond_to?(:load_rake_tasks!)
+          app.mounted_app.load_rake_tasks!(opts)
+        end
+      end
+      paths_for(:rake_tasks).each do |f|
+        path = File.join(*f)
+        unless opts[:_rake_files_loaded].include?(path)
+          load path
+          opts[:_rake_files_loaded] << path
+        end
+      end
+    end
+
+    # Symlinks files in the public roots of this stack and all mounted stacks.
+    # Provided a mounted application responds to the +symlink_public_files!+ method then it will be called.
+    # symlinks public files from all roots of the stacks to Pancake.root/public
+    #
+    # @api public
+    # @author Daniel Neighman
+    def self.symlink_public_files!
+      raise "Pancake root not set" unless Pancake.root
+
+      public_root = File.join(Pancake.root, "public")
+      mount_point = configuration.router.base_url
+
+      unique_paths_for(:public).sort_by{|(r,p)| p}.each do |(r,p)|
+        # don't try to symlink the symlinks
+        origin_path = File.join(r, p)
+        next if r == public_root || FileTest.directory?(origin_path)
+
+        output_path = File.join(public_root, mount_point, p)
+
+        unless File.exists?(File.dirname(output_path))
+          FileUtils.mkdir_p(File.dirname(output_path))
+        end
+        # unless the dir exists... create it
+        puts "Linking #{output_path}"
+        FileUtils.ln_s(origin_path, output_path, :force => true)
+      end
+
+      router.mounted_applications.each do |s|
+        if s.mounted_app.respond_to?(:symlink_public_files!)
+          s.mounted_app.symlink_public_files!
+        end
+      end
+    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!)
     #

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

@@ -1,7 +1,5 @@
 Pancake::Stacks::Short::BootLoader.add(:paths, :before => :load_mounted_inits  ) do
   def run!
-    stack_class.push_paths :public, "public"
-
     stack_class::Controller.push_paths :views, ["app/views", "views"], "**/*"
   end
 end

data/spec/pancake/fixtures/tasks/root1/tasks/task1.rake

@@ -0,0 +1 @@
+$captures << "root1/tasks/task1.rake"

data/spec/pancake/fixtures/tasks/root1/tasks/task2.rake

@@ -0,0 +1 @@
+$captures << "root1/tasks/task2.rake"

data/spec/pancake/fixtures/tasks/root2/tasks/task1.rake

@@ -0,0 +1 @@
+$captures << "root2/tasks/task1.rake"

data/spec/pancake/fixtures/tasks/root2/tasks/task2.rake

@@ -0,0 +1 @@
+$captures << "root2/tasks/task2.rake"

data/spec/pancake/middlewares/static_spec.rb

@@ -54,7 +54,10 @@ describe Pancake::Middlewares::Static do
   it "should return a 404 if the file requested is outside the root directory" do
     static = Pancake::Middlewares::Static.new(@app, FooBar)
     file = "/../../../middlewares/static_spec.rb"
-    File.exists?(File.join(FooBar.dirs_for(:public).first, file)).should be_true
+    result = FooBar.dirs_for(:public).map do |r|
+      File.exists?(File.join(r, file))
+    end
+    result.should include(true)
     env = Rack::MockRequest.env_for(file)
     result = static.call(env)
     result[2].body.map{|e| e}.join.should_not == "OK"

data/spec/pancake/mixins/render_spec.rb

@@ -53,4 +53,13 @@ describe Pancake::Mixins::Render do
     $captures.first.should be_a_kind_of(Pancake::Mixins::Render::ViewContext)
   end
 
+  it "should yield v when rendering" do
+    mock_v = {}
+    mock_v.should_receive(:in_the_block)
+    @render.should_receive(:v).and_return(mock_v)
+    @render.render(:haml_template) do |v|
+      v.should be_a_kind_of(Hash)
+      v.in_the_block
+    end
+  end
 end

data/spec/pancake/stack/stack_spec.rb

@@ -4,10 +4,11 @@ describe "Pancake::Stack" do
   before(:each) do
     class ::StackSpecStack < Pancake::Stack
     end
+    StackSpecStack.roots.clear
   end
 
   after(:each) do
-    clear_constants(:StackSpecStack)
+    clear_constants(:StackSpecStack, :FooSpecStack)
   end
 
   describe "roots" do
@@ -57,4 +58,62 @@ describe "Pancake::Stack" do
       StackSpecStack.should_not be_initialized
     end
   # end
+    describe "master stack" do
+      it "should set the stack to be master, and include the master dir in each root" do
+        StackSpecStack.add_root(__FILE__)
+        before_roots = StackSpecStack.roots.dup
+        s = StackSpecStack.stackup(:master => true)
+        before_roots.each do |r|
+          StackSpecStack.roots.should include(File.join(r, "master"))
+        end
+      end
+    end
+
+    describe "loading rake tasks" do
+      before do
+        $captures = []
+        StackSpecStack.add_root(__FILE__, "..", "fixtures", "tasks", "root1")
+      end
+
+      it "should load the rake tasks in the stacks root" do
+        StackSpecStack.load_rake_tasks!
+        $captures.should == ["root1/tasks/task1.rake", "root1/tasks/task2.rake"]
+      end
+
+      it "should load the rake tasks in order of the roots" do
+        StackSpecStack.add_root(__FILE__, "..", "fixtures", "tasks", "root2")
+        StackSpecStack.load_rake_tasks!
+        $captures.should == [
+          "root1/tasks/task1.rake",
+          "root1/tasks/task2.rake",
+          "root2/tasks/task1.rake",
+          "root2/tasks/task2.rake"
+        ]
+      end
+
+      it "should load rake tasks for mounted applications" do
+        class ::FooSpecStack < Pancake::Stacks::Short
+          add_root(__FILE__, "..", "fixtures", "tasks", "root2")
+        end
+        StackSpecStack.router.mount(FooSpecStack, "/foo")
+        StackSpecStack.load_rake_tasks!
+        # Mounted stacks should have their rake tasks loaded first so they can be overwritten
+        $captures.should == [
+          "root2/tasks/task1.rake",
+          "root2/tasks/task2.rake",
+          "root1/tasks/task1.rake",
+          "root1/tasks/task2.rake"
+        ]
+      end
+
+      it "should not try to load rake tasks of a mounted app that does not respond to load_rake_tasks!" do
+        class ::FooSpecStack < Object
+          def self.call(env); Rack::Response.new("OK").finish; end
+        end
+        StackSpecStack.router.mount(FooSpecStack, "/foo/spec")
+        lambda do
+          StackSpecStack.load_rake_tasks!
+        end.should_not raise_error
+      end
+    end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: pancake
 version: !ruby/object:Gem::Version 
-  version: 0.1.12
+  version: 0.1.13
 platform: ruby
 authors: 
 - Daniel Neighman
@@ -9,7 +9,7 @@ autorequire: pancake
 bindir: bin
 cert_chain: []
 
-date: 2009-10-30 00:00:00 +11:00
+date: 2009-11-09 00:00:00 +11:00
 default_executable: pancake-gen
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -175,6 +175,8 @@ files:
 - lib/pancake/stack/app.rb
 - lib/pancake/stack/bootloader.rb
 - lib/pancake/stack/configuration.rb
+- lib/pancake/stack/defaults/public/favicon.ico
+- lib/pancake/stack/defaults/tasks/pancake.rake
 - lib/pancake/stack/middleware.rb
 - lib/pancake/stack/router.rb
 - lib/pancake/stack/stack.rb
@@ -249,6 +251,10 @@ files:
 - spec/pancake/fixtures/stacks/short/foobar/views/inherited_from_base.html.haml
 - spec/pancake/fixtures/stacks/short/foobar/views/template.html.haml
 - spec/pancake/fixtures/stacks/short/foobar/views/vault.html.haml
+- spec/pancake/fixtures/tasks/root1/tasks/task1.rake
+- spec/pancake/fixtures/tasks/root1/tasks/task2.rake
+- spec/pancake/fixtures/tasks/root2/tasks/task1.rake
+- spec/pancake/fixtures/tasks/root2/tasks/task2.rake
 - spec/pancake/hooks/on_inherit_spec.rb
 - spec/pancake/inheritance_spec.rb
 - spec/pancake/middleware_spec.rb