pancake 0.1.29 → 0.2.0

data/lib/pancake/middleware.rb

@@ -47,21 +47,15 @@ module Pancake
 
     # @param [Array<Symbol>] labels An array of labels specifying the stack labels to use to build the middlware list
     #
-    # @example
-    #   MyApp.middlewares(:production) # provides all middlewares matching the :production label, or the implicit :any label
-    #   MyApp.middlewares(:development, :demo) # provides all middlewares matching the :development or :demo or implicit :any label
-    #
     # @return [Array<StackMiddleware>]
     #   An array of middleware specifications in the order they should be used to wrap the application
     #
     # @see Pancake::Middleware::StackMiddleware
-    # @see Pancake.stack_labels for a decription of stack_labels
     # @api public
     # @since 0.1.0
     # @author Daniel Neighman
-    def middlewares(*labels)
-      labels = labels.flatten
-      self::StackMiddleware.middlewares(*labels)
+    def middlewares
+      self::StackMiddleware.middlewares
     end
 
     # Useful for adding additional information into your middleware stack  definition
@@ -70,8 +64,6 @@ module Pancake
     #   The name of a given middleware.  Each piece of middleware has a name in the stack.
     #   By naming middleware we can refer to it later, swap it out for a different class or even just remove it from the stack.
     # @param        [Hash] opts An options hash
-    # @option opts  [Array<Symbol>] :labels ([:any])
-    #   An array of symbols, or a straight symbol that defines what stacks this middleware sould be active in
     # @option opts [Object] :before
     #   Sets this middlware to be run after the middleware named.  Name is either the name given to the
     #   middleware stack, or the Middleware class itself.
@@ -101,15 +93,6 @@ module Pancake
     # This middleware will be named :foo and will be run after the middleware named :bar
     # If :bar is not run, :foo will not be run either
     #
-    # @example Declaring a named middleware with some labels
-    #   MyClass.stack(:foo, :lables => [:demo, :production, :staging]).use(MyMiddleware)
-    #
-    # This middleware will only be run when pancake is set with the :demo, :production or :staging labels
-    #
-    # @example A full example
-    #   MyClass.stack(:foo, :labels => [:staging, :development], :after => :session).use(MyMiddleware)
-    #
-    #
     # @see Pancake::Middleware#use
     # @api public
     # @since 0.1.0
@@ -165,7 +148,7 @@ module Pancake
     # the StackMiddleware class is inherited to an inner class of the same name on the child.
     class StackMiddleware
       # @api private
-      class_inheritable_reader :_central_mwares, :_mwares, :_before, :_after
+      extlib_inheritable_reader :_central_mwares, :_mwares, :_before, :_after
       @_central_mwares, @_before, @_after, @_mwares = [], {}, {}, {}
 
       # @api private
@@ -186,17 +169,7 @@ module Pancake
           _after.clear
         end
 
-        # Get the middleware list for this StackMiddleware for the given labels
-        #
-        # @param [Symbol] labels The label or list of labels to construct a stack from.
-        #
-        # @example Specified labels
-        #   MyClass::StackMiddleware.middlewares(:production, :demo)
-        #
-        # @example No Labels Specified
-        #   MyClass::StackMiddleware.middlewares
-        #
-        # This will include all defined middlewares in the given stack
+        # Get the middleware list for this StackMiddleware
         #
         # @return [Array<StackMiddleware>]
         #   An array of the middleware definitions to use in the order that they should be applied
@@ -207,39 +180,29 @@ module Pancake
         # @api public
         # @since 0.1.0
         # @author Daniel Neighman
-        def middlewares(*labels)
+        def middlewares
           _central_mwares.map do |name|
-            map_middleware(name, *labels)
+            map_middleware(name)
           end.flatten
         end
 
         # Map the middleware for a given <name>ed middleware.  Applies the before and after groups of middlewares
         #
         # @param [Object] name    The name of the middleware to map the before and after groups to
-        # @param [Symbol] labels  A label or list of labels to use to construct the middleware stack
-        #
-        # @example
-        #   MyClass::StackMiddleware.map_middleware(:foo, :production, :demo)
-        #
-        # Constructs the middleware list based on the middleware named :foo, including all :before, and :after groups
-        #
         # @return [Array<StackMiddleware>]
         #   Provides an array of StackMiddleware instances in the array [<before :foo>, <:foo>, <after :foo>]
         #
         # @api private
         # @since 0.1.0
         # @author Daniel Neighman
-        def map_middleware(name, *labels)
+        def map_middleware(name)
           result = []
           _before[name] ||= []
           _after[name]  ||= []
-          if _mwares[name] && _mwares[name].use_for_labels?(*labels)
-            result << _before[name].map{|n| map_middleware(n)}
-            result << _mwares[name]
-            result << _after[name].map{|n| map_middleware(n)}
-            result.flatten
-          end
-          result
+          result << _before[name].map{|n| map_middleware(n)}
+          result << _mwares[name]
+          result << _after[name].map{|n| map_middleware(n)}
+          result.flatten
         end
 
         # Provides access to a named middleware
@@ -268,8 +231,6 @@ module Pancake
       # @param          [Object]  name a name for this middleware definition.  Usually a symbol, but could be the class.
       # @param          [Object]  stack the stack owner of this middleware.
       # @param          [Hash]    options an options hash.  Provide labels for this middleware.
-      # @option options [Array]   :labels ([:any])
-      #   The labels that are associated with this middleware
       # @option options [Object]  :before A middleware name to add this middleware before
       # @option options [Object]  :after A middleware name to add this middleware after
       #
@@ -278,7 +239,6 @@ module Pancake
       # @author Daniel Neighman
       def initialize(name, stack, options = {})
         @name, @stack, @options = name, stack, options
-        @options[:labels] ||= [:any]
       end
 
       # Delete this middleware from the current stack
@@ -322,19 +282,6 @@ module Pancake
         self
       end
 
-      # Checks if this middleware definition should be included from the labels given
-      # @param [Symbol] labels The label or list of labels to check if this middleware should be included
-      #
-      # @return [Boolean] true if this middlware should be included
-      #
-      # @api private
-      # @since 0.1.0
-      # @author Daniel Neighman
-      def use_for_labels?(*labels)
-        return true if labels.empty? || options[:labels].nil? || options[:labels].include?(:any)
-        !(options[:labels] & labels).empty?
-      end
-
       # @api private
       def dup
         result = super

data/lib/pancake/mixins/publish.rb

@@ -2,17 +2,17 @@ require File.join(File.dirname(__FILE__), "publish", "action_options")
 module Pancake
   module Mixins
     module Publish
-      
+
       def self.extended(base)
         base.class_eval do
-          class_inheritable_accessor :actions, :formats
+          extlib_inheritable_accessor :actions, :formats
           self.actions = {}
           self.formats = [:html]
         end
       end
-    
+
       # Accepts a list of symbols representing the formats each action in the
-      # controller will return. By default the list consists only of :html 
+      # controller will return. By default the list consists only of :html
       #
       #   provides :html, :xml
       #
@@ -20,9 +20,9 @@ module Pancake
       def provides(*args)
         self.formats = args
       end
-        
-      # Causes the next method added immediately after it’s call to be defined 
-      # as an action. It also generates an instance of ActionOptions, which 
+
+      # Causes the next method added immediately after it’s call to be defined
+      # as an action. It also generates an instance of ActionOptions, which
       # encapsulates all the parameters the action accepts/expects and also
       # the formats that it can potentially return.
       #
@@ -31,13 +31,13 @@ module Pancake
       #     ...
       #   end
       #
-      # The example above publishes the action "show" and configures the 
+      # The example above publishes the action "show" and configures the
       # following options for it:
       #
       # - The parameter 'id' will be coerced into an Integer
       # - It also must not be blank, it is required.
       #
-      # The publish declaration can also create much more sophisticated 
+      # The publish declaration can also create much more sophisticated
       # constraints. You can declare a parameter as optional, give it a default
       # value if it is missing.
       #
@@ -52,9 +52,9 @@ module Pancake
       # #publish can also handle the specification of formats for an action. It
       # accepts an additional two options, :provides and :only_provides.
       #
-      # To the list of globally declared formats, :provides adds additional 
+      # To the list of globally declared formats, :provides adds additional
       # formats to an action.
-      # 
+      #
       #   publish :provides => :xml
       #
       # The :only_provides option overrides any globally declared formats for an
@@ -66,9 +66,9 @@ module Pancake
       def publish(opts = {})
         @pending_publication_opts = opts
       end
-    
+
       # Used when declaring configuration for parameters in the publish
-      # declaration. It returns an array of the type, default value an 
+      # declaration. It returns an array of the type, default value an
       # additional options.
       #
       # @param type [Object] The
@@ -78,7 +78,7 @@ module Pancake
       # - :date
       # - :string
       #
-      # For details on the options supported by each type, please see the 
+      # For details on the options supported by each type, please see the
       # corresponding methods declared in the ActionOptions class. These methods
       # are named as the type, prefixed with 'validate_and_coerce_'
       #
@@ -96,9 +96,9 @@ module Pancake
       def as(type, default = :req, opts = {})
         [type, default, opts]
       end
-    
+
       # Takes a parameters hash, and validates each entry against the options
-      # defined for this action. It will flag required params when missing, 
+      # defined for this action. It will flag required params when missing,
       # insert defaults or coerce values into the desired type. It mutates
       # the params hash itself.
       #
@@ -106,10 +106,10 @@ module Pancake
       def validate_and_coerce_params(action, params)
         actions[action].validate_and_coerce(params)
       end
-    
-    
-      # This hook is used in conjunction with the #publish method to expose 
-      # instance methods as actions. Obviously, it should never be called 
+
+
+      # This hook is used in conjunction with the #publish method to expose
+      # instance methods as actions. Obviously, it should never be called
       # directly :)
       #
       # @api private

data/lib/pancake/mixins/render.rb

@@ -1,5 +1,4 @@
 require 'pancake/mixins/render/template'
-require 'pancake/mixins/render/render'
 require 'pancake/mixins/render/view_context'
 module Pancake
   module Mixins
@@ -10,11 +9,9 @@ module Pancake
         base.class_eval do
           extend  Pancake::Mixins::Render::ClassMethods
           include Pancake::Mixins::Render::InstanceMethods
-          include Pancake::Mixins::RequestHelper
 
-          class self::ViewContext < Pancake::Mixins::Render::ViewContext
-            include Pancake::Mixins::RequestHelper
-          end
+          class base::ViewContext < Pancake::Mixins::Render::ViewContext; end
+
           inheritable_inner_classes :ViewContext
 
           unless ancestors.include?(Pancake::Paths)
@@ -33,16 +30,19 @@ module Pancake
           @_template_cache ||= {}
         end
 
-        def _find_template(name)
-          renderer = _template_cache[name]
-          return renderer if renderer
-
-          renderer_path = unique_paths_for(:views, :invert => true).detect do |path|
-            path.last =~ %r[^\/?(#{name})\.\w+$]
-          end
+        # Allows you to set path label for the templates for this class
+        #
+        # @example
+        #   MyClass.push_paths(:my_templates, "somewhere", "**/*")
+        #
+        #   MyClass._template_path_name #=> :my_templates
+        # @api public
+        def _template_path_name(opts = {})
+          opts[:template_path_name] || :views
+        end
 
-          raise TemplateNotFound unless renderer_path
-          _template_cache[name] = Template.new(name, self, renderer_path.join)
+        def _find_template(name, opts = {})
+          template(name, opts)
         end
 
         def _view_context_cache
@@ -52,26 +52,55 @@ module Pancake
 
         def _find_view_context_class_for(template)
           _view_context_cache[template] ||= begin
-                                              Class.new(self::ViewContext)
+                                              self::ViewContext
                                             end
           _view_context_cache[template]
         end
 
-        def _renderer_and_view_context_class_for(template)
-          [_find_template(template), _find_view_context_class_for(template)]
+        def _renderer_and_view_context_class_for(tplate)
+          [template(tplate), _find_view_context_class_for(tplate)]
         end
 
-        def _template_name_for(name, opts = {})
-          opts[:format] ||= :html
-          "#{name}.#{opts[:format]}"
+        def _template_name_for(name, opts)
+          "#{name}"
         end
 
-        def template(name_or_template, opts = {})
-          case name_or_template
-          when String, Symbol
-            _find_template(_template_name_for(name_or_template, opts))
+        def template(name, opts = {})
+          case name
           when Template
-            name_or_template
+            name
+          when String, Symbol
+
+            template_names = case __template = _template_name_for(name, opts)
+            when String, Symbol
+              [__template]
+            when Array
+              __template
+            when Proc
+              [__template.call(opts)].flatten
+            else
+              nil
+            end
+
+            renderer = _template_cache[template_names]
+            return renderer if renderer
+
+            unique_paths = unique_paths_for(_template_path_name(opts), :invert => true)
+
+            renderer_path = nil
+            template_name = nil
+
+            template_names.detect do |tn|
+              unique_paths.detect do |path|
+                if path.last =~ %r[^\/?(#{tn})\.\w+$]
+                  template_name = tn
+                  renderer_path = path.join
+                end
+              end
+            end
+
+            raise TemplateNotFound unless renderer_path
+            _template_cache[template_names] = Template.new(template_name, self, renderer_path)
           else
             nil
           end
@@ -87,15 +116,15 @@ module Pancake
         def render(*args)
           opts          = Hash === args.last ? args.pop : {}
           name          = args.shift
-          template_name = _template_name_for(name, opts)
+          template      = self.class.template(name, opts)
           return opts[:text] if opts[:text]
 
           # Get the view context for the tempalte
-          template, vc_class = self.class._renderer_and_view_context_class_for(template_name)
+          template, vc_class = self.class._renderer_and_view_context_class_for(template)
 
           yield v if block_given?
 
-          view_context = vc_class.new(env, self)
+          view_context = vc_class.new(self)
           view_context_before_render(view_context)
           view_context.render(template, opts)
         end
@@ -111,7 +140,7 @@ module Pancake
           # Get the view context for the tempalte
           template, vc_class = self.class._renderer_and_view_context_class_for(partial_name)
 
-          view_context = vc_class.new(env, self)
+          view_context = vc_class.new(self)
           view_context_before_render(view_context)
 
           out = ""
@@ -129,48 +158,9 @@ module Pancake
         end
 
         def template(name_or_template, opts = {})
-          opts[:format] ||= content_type
           self.class.template(name_or_template, opts)
         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)
-          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
-
-
-
         # A place holder method for any implementor that wants
         # to configure the view context prior to rendering occuring
         # any time this method is overwritten, it should call super!
@@ -180,8 +170,8 @@ module Pancake
         end
 
         private
+        # @api_overwritable
         def _template_name_for(name, opts = {})
-          opts[:format] ||= content_type
           self.class._template_name_for(name, opts)
         end