pancake 0.1.29 → 0.2.0

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

@@ -14,7 +14,7 @@ module Pancake
           @renderer = Tilt.new(path)
         end
 
-        def render(context = Object.new, opts = {})
+        def render(context = ViewContext.new, opts = {})
           @renderer.render(context, opts)
         end
       end #Template

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

@@ -1,20 +1,156 @@
-require 'pancake/mixins/render/render.rb'
+require 'any_view'
 module Pancake
   module Mixins
     module Render
       class ViewContext
         # These are included as modules not for modularization, but because super can be called for the module versions
-        include Capture
-        include Renderer
-        include ContentInheritance
+        include ::Tilt::CompileSite
+        include ::AnyView::TiltBase
+
+        class << self
+          def capture_method_for(item)
+            key = case item
+                  when Template
+                    item.renderer.class
+                  when Tilt::Template
+                    item
+                  end
+            AnyView::TiltBase.capture_methods[key]
+          end
+
+          def concat_method_for(item)
+            key = case item
+                  when Template
+                    item.renderer.class
+                  when Tilt::Template
+                    item
+                  end
+            AnyView::TiltBase.concat_methods[key]
+          end
+        end
 
         attr_reader :_view_context_for
-        def initialize(env, renderer_for = nil )
-          super
-          @env = env
+
+        def initialize(renderer_for = nil, opts = {})
+          opts.keys.each do |k,v|
+            instance_variable_set("@#{k}", v)
+          end
+          @_inherit_helper = InheritanceHelper.new
           @_view_context_for = renderer_for
         end
 
+        def inherits_from(ntos, name_or_opts = nil, opts = {})
+          name_or_template = case ntos
+          when String, Symbol
+            if ntos == :default!
+              begin
+                if @format
+                  Pancake.default_base_template(:format => @format)
+                else
+                  Pancake.default_base_template
+                end
+              rescue
+                :base
+              end
+            else
+              ntos
+            end
+          when Pancake::Mixins::Render::Template
+            ntos
+          else
+            if name_or_opts.kind_of?(Hash)
+              opts = name_or_opts
+              name_or_opts = nil
+            end
+            name_or_opts ||= ntos.base_template_name
+            ntos.template(name_or_opts, opts)
+          end
+          @_inherit_helper.inherits_from = name_or_template
+        end
+
+        def content_block(label = nil, &block)
+          return self if label.nil?
+          current_label = @_inherit_helper.current_label
+          @_inherit_helper.current_label = label
+          capture_method = ViewContext.capture_method_for(_current_renderer)
+
+          @_inherit_helper.blocks[label] << [block, capture_method]
+          if @_inherit_helper.inherits_from.nil?
+            result = _capture_content_block(label)
+            send(ViewContext.concat_method_for(_current_renderer), result)
+          end
+          @_inherit_helper.current_label = current_label
+        end
+
+        def super
+          @_inherit_helper.increment_super!
+          result = _capture_content_block(@_inherit_helper.current_label)
+          @_inherit_helper.decrement_super!
+          result
+        end
+
+        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, &blk) # only include the block once
+          end
+
+          if @_inherit_helper.inherits_from
+            next_template = template.owner.template(@_inherit_helper.inherits_from)
+            @_inherit_helper.inherits_from = nil
+            result = _with_renderer next_template do
+              render(next_template, opts)
+            end
+          end
+          result
+        end
+
+        def partial(*args)
+          _view_context_for.partial(*args)
+        end
+
+        def _with_renderer(renderer)
+          orig_renderer = @_current_renderer
+          @_current_renderer = renderer
+          result = yield
+          @_current_renderer = orig_renderer
+          result
+        end
+
+        def _current_renderer
+          @_current_renderer
+        end
+
+        private
+        def _capture_content_block(label)
+          blk, meth = @_inherit_helper.block_for(label)
+          send(meth, &blk)
+        end
+
+
+        class InheritanceHelper
+          attr_accessor :inherits_from, :current_label
+          attr_reader   :blocks, :super_index
+
+          def initialize
+            @blocks = Hash.new{|h,k| h[k] = []}
+            @super_index = 0
+          end
+
+          def block_for(label)
+            @blocks[label][@super_index]
+          end
+
+          def increment_super!
+            @super_index += 1
+          end
+
+          def decrement_super!
+            @super_index -= 1
+          end
+
+        end
       end
     end
   end

data/lib/pancake/mixins/request_helper.rb

@@ -3,7 +3,7 @@ module Pancake
     # Some helpers for requests that come in handy for applications that
     # are part of stacks
     module RequestHelper
-      VARS_KEY = 'pancake.request.vars'
+      VARS_KEY = 'request.variables'
 
       # 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.
@@ -125,6 +125,43 @@ module Pancake
       def logger
         env[Pancake::Constants::ENV_LOGGER_KEY]
       end
+
+      def negotiate_content_type!(*allowed_types)
+        return content_type if content_type
+
+        allowed_types = allowed_types.flatten
+        opts = allowed_types.pop if allowed_types.last.kind_of?(Hash)
+        opts ||= {}
+        if opts[:format]
+          cont, ct, mt = Pancake::MimeTypes.negotiate_by_extension(opts[:format].to_s, allowed_types)
+        else
+          env["HTTP_ACCEPT"] ||= "*/*"
+          cont, ct, mt = Pancake::MimeTypes.negotiate_accept_type(env["HTTP_ACCEPT"], allowed_types)
+        end
+
+        raise Errors::NotAcceptable unless cont
+
+        headers["Content-Type"] = ct
+        self.mime_type    = mt
+        self.content_type = cont
+        cont
+      end
+
+      def content_type
+        env['pancake.request.format']
+      end
+
+      def content_type=(format)
+        env['pancake.request.format'] = format
+      end
+
+      def mime_type
+        env['pancake.request.mime']
+      end
+
+      def mime_type=(mime)
+        env['pancake.request.mime'] = mime
+      end
     end # RequestHelper
   end # Mixins
 end # Pancake

data/lib/pancake/mixins/stack_helper.rb

@@ -2,7 +2,7 @@ module Pancake
   module Mixins
     module StackHelper
       def self.included(base)
-        base.class_inheritable_accessor :_stack_class
+        base.extlib_inheritable_accessor :_stack_class
         base.extend ClassMethods
         base.class_eval do
           include ::Pancake::Mixins::StackHelper::InstanceMethods
@@ -19,7 +19,7 @@ module Pancake
           end
           ns = name.split("::")
           until ns.empty? || klass
-            r = Object.full_const_get(ns.join("::"))
+            r = ns.join("::").constantize
             if r.ancestors.include?(::Pancake::Stack)
               klass = r
             else

data/lib/pancake/paths.rb

@@ -41,7 +41,7 @@ module Pancake
     def self.extended(base) #:nodoc:#
       base.class_eval do
         deep_copy_class_inheritable_reader :_load_paths, :roots
-        @_load_paths = Dictionary.new
+        @_load_paths = ActiveSupport::OrderedHash.new
         @roots = []
       end
     end

data/lib/pancake/router.rb

@@ -38,14 +38,16 @@ module Pancake
   # @since 0.1.2
   # @author Daniel Neighman
   class Router < Usher::Interface::Rack
-    attr_writer :router
+    attr_writer   :router
+    attr_accessor :stack
 
     CONFIGURATION_KEY = "pancake.request.configuration".freeze
     ROUTE_KEY         = "pancake.request.matching_route".freeze
+    LAYOUT_KEY        = "pancake.apply_layout".freeze
 
     class RackApplicationExpected < ArgumentError; end
     attr_accessor :configuration
-    class_inheritable_accessor :mounted_applications
+    extlib_inheritable_accessor :mounted_applications
     self.mounted_applications = []
 
     class MountedApplication
@@ -141,13 +143,18 @@ module Pancake
     end
 
     def call(env)
+      apply_layout = env[LAYOUT_KEY]
+      env[LAYOUT_KEY] = true if stack.use_layout?
+
       orig_config = env[CONFIGURATION_KEY]
       orig_route  = env[ROUTE_KEY]
       env[CONFIGURATION_KEY] = configuration
+
       super(env)
     ensure
       env[CONFIGURATION_KEY] = orig_config
       env[ROUTE_KEY]         = orig_route
+      env[LAYOUT_KEY]        = apply_layout
     end
 
     private
@@ -166,6 +173,7 @@ module Pancake
     # the usher.params into the rack request.params
     # @api private
     def after_match(request, response)
+      request.env['rack.request.query_hash'] = request.params.dup
       super
       consume_path!(request, response) if !response.partial_match? && response.path.route.consuming
       request.params.merge!(request.env['usher.params']) unless request.env['usher.params'].empty?

data/lib/pancake/stack/bootloader.rb

@@ -29,6 +29,11 @@ Pancake::Stack::BootLoader.add(:load_mounted_inits, :level => :init) do
   end
 end
 
+Pancake::Stack::BootLoader.add(:before_stack_loads) do
+  def run!
+    stack_class.before_stack_loads.each{|blk| blk.call}
+  end
+end
 
 Pancake::Stack::BootLoader.add(:load_application, :level => :init) do
   def run!
@@ -61,6 +66,12 @@ Pancake::Stack::BootLoader.add(:before_mount_applicaions) do
   end
 end
 
+Pancake::Stack::BootLoader.add(:load_middlewares) do
+  def run!
+    stack_class.paths_for(:middlewares).each{|f| require f.join}
+  end
+end
+
 Pancake::Stack::BootLoader.add(:mount_applications) do
   def run!
     stack_class.router.mount_applications!
@@ -87,7 +98,7 @@ end
 
 Pancake::Stack::BootLoader.add(:build_stack) do
   def run!
-    mwares = stack_class.middlewares(Pancake.stack_labels)
+    mwares = stack_class.middlewares
     app = Pancake::Middleware.build(config[:app], mwares)
     app_config = Pancake.configuration.configs(config[:app_name])
     app_config.app   = app

data/lib/pancake/stack/router.rb

@@ -12,9 +12,11 @@ module Pancake
         unless self == Pancake::Stack
           r.router = superclass._router.router.dup
         end
+        r.stack = self
         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
@@ -37,7 +39,6 @@ module Pancake
       yield router if block_given?
       router
     end
-
   end
 end
 

data/lib/pancake/stack/stack.rb

@@ -16,6 +16,7 @@ module Pancake
     push_paths(:rake_tasks,   "tasks",                "**/*.rake")
     push_paths(:public,       "public",               "**/*")
     push_paths(:mounts,       "mounts",               "*/pancake_init.rb")
+    push_paths(:middlewares,  "config/middlewares",   "**/*.rb")
 
 
     #Iterates the list of roots in the stack, and initializes the app found their
@@ -135,6 +136,56 @@ module Pancake
       end
     end
 
+    # Specify a layout to use for this stack and all children stacks
+    # Layouts are provided by Wrapt, and Pancake::Stacks::Short will use the layout when directed to by calling this method.  Simply call it to activate layouts with the default options, or provide it with options to direct wrapt.
+    #
+    # You can specify a layout to use by name, provide it options or provide a block that you can use to set the layout via the environment.
+    #
+    # @params name [String] (optional) The name of the layout to use
+    # @params opts [Hash] Options for use with Wrapt
+    #
+    # @block The block is used to determine at runtime which layout to use.  It is yielded the environment where appropriate action can be taken.  It assumes that you will set the layout object directly
+    #
+    # @example
+    #   # Direct the short stack to use a layout
+    #   layout
+    #
+    #   # Set the layout to a non-default one
+    #   layout "non_standard"
+    #
+    #   # Directly set the layout via the Wrapt::Layout object
+    #   layout do |env|
+    #     r = Rack::Request.new(env)
+    #     l = env['layout']
+    #     if r.params['foo'] == 'bar'
+    #       l.template_name = "foo"
+    #     end
+    #   end
+    #
+    # @see Wrapt
+    # @see Wrapt::Layout
+    # @api public
+    def self.apply_layout(name = nil, &blk)
+      @use_layout = true
+      @default_layout = name
+    end
+
+    def self.use_layout?
+      if @use_layout
+        @use_layout
+      else
+        @use_layout = superclass.respond_to?(:use_layout?) && superclass.use_layout?
+      end
+    end
+
+    def self.default_layout
+      if @default_layout
+        @default_layout
+      else
+        @default_layout = superclass.respond_to?(:default_layout) && superclass.default_layout
+      end
+    end
+
     # Sets this as a master stack.  This means that the "master" directory will be added to all existing stack roots
     def self.set_as_master!
       Pancake.master_stack ||= self
@@ -173,7 +224,7 @@ module Pancake
     # @api public
     def self.create_bootloader_hook(*hooks)
       hooks.each do |hook|
-        class_inheritable_reader "_#{hook}"
+        extlib_inheritable_reader "_#{hook}"
         instance_variable_set("@_#{hook}", [])
 
         class_eval <<-RUBY
@@ -185,6 +236,13 @@ module Pancake
       end
     end
 
-    create_bootloader_hook :before_build_stack, :before_mount_applications, :after_initialize_application, :after_build_stack
+    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/lib/pancake/stacks/short/controller.rb

@@ -2,7 +2,6 @@ module Pancake
   module Stacks
     class Short
       inheritable_inner_classes :Controller
-
       class Controller
         extend  Mixins::Publish
         include Mixins::Render
@@ -10,12 +9,44 @@ module Pancake
         include Mixins::ResponseHelper
         include Mixins::StackHelper
 
-        class_inheritable_accessor :_handle_exception
+        class self::ViewContext
+          include Mixins::RequestHelper
+          include AnyView
+
+          # No way to get the env into the view context... this is not good :(
+          def env
+            _view_context_for.env
+          end
+
+          def self.template(name_or_template, opts = {})
+            opts[:format] ||= content_type
+            super
+          end
+
+          def template(name_or_template, opts={})
+            opts[:format] ||= content_type
+            super
+          end
+
+          def _template_name_for(name, opts = {})
+            opts[:format] ||= :html
+            "#{name}.#{opts[:format]}"
+          end
+        end
+
+        extlib_inheritable_accessor :_handle_exception
 
         push_paths(:views, ["app/views", "views"], "**/*")
 
         DEFAULT_EXCEPTION_HANDLER = lambda do |error|
-          "#{error.name}: #{error.description}"
+          use_layout = env[Router::LAYOUT_KEY]
+          if use_layout
+            layout = env['layout']
+            layout.content = render :error, :error => error
+            layout
+          else
+            render :error, :error => error
+          end
         end unless defined?(DEFAULT_EXCEPTION_HANDLER)
 
         # @api private
@@ -24,6 +55,10 @@ module Pancake
           app.dispatch!
         end
 
+        def layout
+          env['layout']
+        end
+
         # @api public
         attr_accessor :status
 
@@ -40,6 +75,7 @@ module Pancake
 
         # Dispatches to an action based on the params["action"] parameter
         def dispatch!
+
           params["action"] ||= params[:action]
           params[:format]  ||= params["format"]
 
@@ -55,14 +91,33 @@ module Pancake
 
           negotiate_content_type!(@action_opts.formats, params)
 
+          # Setup the layout
+          use_layout = env[Router::LAYOUT_KEY]
+          layout = env['layout']
+
+          # Set the layout defaults before the action is rendered
+          if use_layout && stack_class.default_layout
+            layout.template_name = stack_class.default_layout
+          end
+          layout.format = params['format'] if use_layout
+
           logger.info "Dispatching to #{params["action"].inspect}" if logger
 
           result = catch(:halt){ self.send(params['action']) }
+
           case result
           when Array
             result
           when Rack::Response
             result.finish
+          when String
+            out = if use_layout
+              layout.content = result
+              layout
+            else
+              result
+            end
+            Rack::Response.new(out, status, headers).finish
           else
             Rack::Response.new((result || ""), status, headers).finish
           end