merb-core 0.9.3 → 0.9.4

data/lib/merb-core/controller/merb_controller.rb

@@ -1,7 +1,12 @@
 class Merb::Controller < Merb::AbstractController
 
-  class_inheritable_accessor :_hidden_actions, :_shown_actions
-  cattr_accessor :_subclasses, :_session_id_key, :_session_secret_key, :_session_expiry
+  class_inheritable_accessor :_hidden_actions, :_shown_actions,
+                             :_session_id_key, :_session_secret_key, :_session_expiry, :_session_cookie_domain
+
+  self._hidden_actions ||= []
+  self._shown_actions ||= []
+  
+  cattr_accessor :_subclasses
   self._subclasses = Set.new
 
   def self.subclasses_list() _subclasses end
@@ -9,13 +14,12 @@ class Merb::Controller < Merb::AbstractController
   self._session_secret_key = nil
   self._session_id_key = Merb::Config[:session_id_key] || '_session_id'
   self._session_expiry = Merb::Config[:session_expiry] || Merb::Const::WEEK * 2
+  self._session_cookie_domain = Merb::Config[:session_cookie_domain]
 
   include Merb::ResponderMixin
   include Merb::ControllerMixin
   include Merb::AuthenticationMixin
 
-  attr_accessor :route
-
   class << self
 
     # ==== Parameters
@@ -23,8 +27,8 @@ class Merb::Controller < Merb::AbstractController
     #   The Merb::Controller inheriting from the base class.
     def inherited(klass)
       _subclasses << klass.to_s
-      self._template_root = Merb.dir_for(:view) unless self._template_root
       super
+      klass._template_root = Merb.dir_for(:view) unless self._template_root
     end
 
     # Hide each of the given methods from being callable as actions.
@@ -74,26 +78,6 @@ class Merb::Controller < Merb::AbstractController
       self._shown_actions = self._shown_actions | names.map {|n| n.to_s}
     end
 
-    # This list of actions that should not be callable.
-    #
-    # ==== Returns
-    # Array[String]:: An array of actions that should not be dispatchable.
-    def _hidden_actions
-      actions = read_inheritable_attribute(:_hidden_actions)
-      actions ? actions : write_inheritable_attribute(:_hidden_actions, [])
-    end
-
-    # This list of actions that should be callable.
-    #
-    # ==== Returns
-    # Array[String]::
-    #   An array of actions that should be dispatched to even if they would not
-    #   otherwise be.
-    def _shown_actions
-      actions = read_inheritable_attribute(:_shown_actions)
-      actions ? actions : write_inheritable_attribute(:_shown_actions, [])
-    end
-
     # The list of actions that are callable, after taking defaults,
     # _hidden_actions and _shown_actions into consideration. It is calculated
     # once, the first time an action is dispatched for this controller.
@@ -101,16 +85,7 @@ class Merb::Controller < Merb::AbstractController
     # ==== Returns
     # SimpleSet[String]:: A set of actions that should be callable.
     def callable_actions
-      unless @callable_actions
-        callables = []
-        klass = self
-        begin
-          callables << (klass.public_instance_methods(false) + klass._shown_actions) - klass._hidden_actions
-          klass = klass.superclass
-        end until klass == Merb::AbstractController || klass == Object
-        @callable_actions = Merb::SimpleSet.new(callables.flatten)
-      end
-      @callable_actions
+      @callable_actions ||= Extlib::SimpleSet.new(_callable_methods)
     end
 
     # This is a stub method so plugins can implement param filtering if they want.
@@ -126,6 +101,22 @@ class Merb::Controller < Merb::AbstractController
       params
     end
 
+    private
+    
+    # All methods that are callable as actions.
+    #
+    # ==== Returns
+    # Array:: A list of method names that are also actions
+    def _callable_methods
+      callables = []
+      klass = self
+      begin
+        callables << (klass.public_instance_methods(false) + klass._shown_actions) - klass._hidden_actions
+        klass = klass.superclass
+      end until klass == Merb::AbstractController || klass == Object
+      callables.flatten.reject{|action| action =~ /^_.*/}
+    end
+
   end # class << self
 
   # The location to look for a template for a particular controller, context,
@@ -147,7 +138,24 @@ class Merb::Controller < Merb::AbstractController
   #---
   # @public
   def _template_location(context, type = nil, controller = controller_name)
-    controller ? "#{controller}/#{context}.#{type}" : "#{context}.#{type}"
+    _conditionally_append_extension(controller ? "#{controller}/#{context}" : "#{context}", type)
+  end
+  
+  # The location to look for a template and mime-type. This is overridden 
+  # from AbstractController, which defines a version of this that does not 
+  # involve mime-types.
+  #
+  # ==== Parameters
+  # template<String>:: 
+  #    The absolute path to a template - without mime and template extension.
+  #    The mime-type extension is optional - it will be appended from the 
+  #    current content type if it hasn't been added already.
+  # type<~to_s>::
+  #    The mime-type of the template that will be rendered. Defaults to nil.
+  #
+  # @public
+  def _absolute_template_location(template, type)
+    _conditionally_append_extension(template, type)
   end
 
   # Build a new controller.
@@ -168,7 +176,7 @@ class Merb::Controller < Merb::AbstractController
   # @semipublic
   def initialize(request, status=200, headers={'Content-Type' => 'text/html; charset=utf-8'})
     super()
-    @request, @status, @headers = request, status, headers
+    @request, @_status, @headers = request, status, headers
   end
 
   # Dispatch the action.
@@ -184,6 +192,7 @@ class Merb::Controller < Merb::AbstractController
   #---
   # @semipublic
   def _dispatch(action=:index)
+    Merb.logger.info("Params: #{self.class._filter_params(request.params).inspect}")
     start = Time.now
     if self.class.callable_actions.include?(action.to_s)
       super(action)
@@ -191,10 +200,14 @@ class Merb::Controller < Merb::AbstractController
       raise ActionNotFound, "Action '#{action}' was not found in #{self.class}"
     end
     @_benchmarks[:action_time] = Time.now - start
+    self
   end
 
   attr_reader :request, :headers
-  attr_reader :status
+  
+  def status
+    @_status
+  end
 
   # Set the response status code.
   #
@@ -202,9 +215,9 @@ class Merb::Controller < Merb::AbstractController
   # s<Fixnum, Symbol>:: A status-code or named http-status
   def status=(s)
     if s.is_a?(Symbol) && STATUS_CODES.key?(s)
-      @status = STATUS_CODES[s]
+      @_status = STATUS_CODES[s]
     elsif s.is_a?(Fixnum)
-      @status = s
+      @_status = s
     else
       raise ArgumentError, "Status should be of type Fixnum or Symbol, was #{s.class}"
     end
@@ -227,12 +240,28 @@ class Merb::Controller < Merb::AbstractController
   # ==== Returns
   # Hash:: The session that was extracted from the request object.
   def session() request.session end
-
+  
+  # The results of the controller's render, to be returned to Rack.
+  #
+  # ==== Returns
+  # Array[Integer, Hash, String]::
+  #   The controller's status code, headers, and body
+  def rack_response
+    [status, headers, body]
+  end
+  
+  # Hide any methods that may have been exposed as actions before.
+  hide_action(*_callable_methods)
+  
   private
 
-  # Create a default cookie jar, and pre-set a fixation cookie
-  # if fixation is enabled
+  # If not already added, add the proper mime extension to the template path.
+  def _conditionally_append_extension(template, type = nil)
+    type && !template.match(/\.#{type.to_s.escape_regexp}$/) ? "#{template}.#{type}" : template
+  end
+
+  # Create a default cookie jar, and pre-set a fixation cookie if fixation is enabled.
   def _setup_cookies
     ::Merb::Cookies.new(request.cookies, @headers)
   end
-end
+end

data/lib/merb-core/controller/mime.rb

@@ -28,17 +28,35 @@ module Merb
     #   The associated method to call on objects to convert them to the
     #   appropriate mime-type. For instance, :json would use :to_json as its
     #   transform_method.
-    # values<Array[String]>::
+    # mimes<Array[String]>::
     #   A list of possible values sent in the Accept header, such as text/html,
     #   that should be associated with this content-type.
     # new_response_headers<Hash>::
-    #   The response headers to set for the the mime type.
-    def add_mime_type(key, transform_method, values, new_response_headers = {}) 
-      enforce!(key => Symbol, values => Array)
+    #   The response headers to set for the the mime type. For example: 
+    #   'Content-Type' => 'application/json; charset=utf-8'; As a shortcut for
+    #   the common charset option, use :charset => 'utf-8', which will be
+    #   correctly appended to the mimetype itself.
+    # &block:: a block which recieves the current controller when the format
+    #   is set (in the controller's #content_type method)
+    def add_mime_type(key, transform_method, mimes, new_response_headers = {}, &block) 
+      enforce!(key => Symbol, mimes => Array)
+      
+      content_type = new_response_headers["Content-Type"] || mimes.first
+      
+      if charset = new_response_headers.delete(:charset)
+        content_type += "; charset=#{charset}"
+      end
+      
       ResponderMixin::TYPES.update(key => 
-        {:request_headers   => values, 
+        {:accepts           => mimes, 
          :transform_method  => transform_method,
-         :response_headers  => new_response_headers })
+         :content_type      => content_type,
+         :response_headers  => new_response_headers,
+         :response_block    => block })
+
+      mimes.each do |mime|
+        ResponderMixin::MIMES.update(mime => key)
+      end
 
       Merb::RenderMixin.class_eval <<-EOS, __FILE__, __LINE__
         def render_#{key}(thing = nil, opts = {})
@@ -81,7 +99,7 @@ module Merb
     # ==== Returns
     # Hash:: The mime type information.
     def mime_by_request_header(header)
-      available_mime_types.find {|key,info| info[request_headers].include?(header)}.first
+      available_mime_types.find {|key,info| info[:accepts].include?(header)}.first
     end
     
   end

data/lib/merb-core/controller/mixins/authentication.rb

@@ -51,7 +51,7 @@ module Merb::AuthenticationMixin
     BasicAuthentication.new(self, realm, &authenticator)
   end
   
-  class BasicAuthentication #:nodoc:
+  class BasicAuthentication
     # So we can have access to the status codes
     include Merb::ControllerExceptions
 

data/lib/merb-core/controller/mixins/controller.rb

@@ -1,6 +1,22 @@
 module Merb
   # Module that is mixed in to all implemented controllers.
   module ControllerMixin
+    
+    # Enqueu a block to run in a background thread outside of the request
+    # response dispatch
+    #
+    # ==== Parameters
+    # takes a block to run later
+    #
+    # ==== Example
+    # run_later do
+    #   SomeBackgroundTask.run
+    # end
+    #
+    def run_later(&blk)
+      Merb::Dispatcher.work_queue << blk
+    end
+    
     # Renders the block given as a parameter using chunked encoding.
     #
     # ==== Parameters
@@ -88,24 +104,43 @@ module Merb
         blk.call        
       }      
     end
-        
+
     # ==== Parameters
     # url<String>::
     #   URL to redirect to. It can be either a relative or fully-qualified URL.
+    # opts<Hash>:: An options hash (see below)
+    #
+    # ==== Options (opts)
+    # :message<Hash>::
+    #   Messages to pass in url query string as value for "_message"
+    # :permanent<Boolean>::
+    #   When true, return status 301 Moved Permanently
     #
     # ==== Returns
     # String:: Explanation of redirect.
     #
     # ==== Examples
     #   redirect("/posts/34")
+    #   redirect("/posts/34", :message => { :notice => 'Post updated successfully!' })
     #   redirect("http://www.merbivore.com/")
-    def redirect(url)
-      Merb.logger.info("Redirecting to: #{url}")
-      self.status = 302
+    #   redirect("http://www.merbivore.com/", :permanent => true)
+    def redirect(url, opts = {})
+      default_redirect_options = { :message => nil, :permanent => false }
+      opts = default_redirect_options.merge(opts)
+      if opts[:message]
+        notice = Merb::Request.escape([Marshal.dump(opts[:message])].pack("m"))
+        url = url =~ /\?/ ? "#{url}&_message=#{notice}" : "#{url}?_message=#{notice}"
+      end
+      self.status = opts[:permanent] ? 301 : 302
+      Merb.logger.info("Redirecting to: #{url} (#{self.status})")
       headers['Location'] = url
       "<html><body>You are being <a href=\"#{url}\">redirected</a>.</body></html>"
     end
     
+    def message
+      @_message = defined?(@_message) ? @_message : request.message
+    end
+    
     # Sends a file over HTTP.  When given a path to a file, it will set the
     # right headers so that the static file is served directly.
     #
@@ -131,7 +166,7 @@ module Merb
         'Content-Disposition'       => disposition,
         'Content-Transfer-Encoding' => 'binary'
       )
-      File.open(file)
+      File.open(file, 'rb')
     end
     
     # Send binary data over HTTP to the user as a file download. May set content type,
@@ -190,7 +225,8 @@ module Merb
         'Content-Type'              => opts[:type].strip,  # fixes a problem with extra '\r' with some browsers
         'Content-Disposition'       => disposition,
         'Content-Transfer-Encoding' => 'binary',
-        'CONTENT-LENGTH'            => opts[:content_length]
+        # Rack specification requires header values to respond to :each
+        'CONTENT-LENGTH'            => opts[:content_length].to_s
       )
       Proc.new{|response|
         response.send_status(opts[:content_length])
@@ -206,8 +242,8 @@ module Merb
     # ==== Parameters
     # file<String>:: Path to file to send to the client.
     def nginx_send_file(file)
-      headers['X-Accel-Redirect'] = File.expand_path(file)
-      return
+      headers['X-Accel-Redirect'] = file
+      return ' '
     end  
   
     # Sets a cookie to be included in the response.

data/lib/merb-core/controller/mixins/render.rb

@@ -1,7 +1,7 @@
 module Merb::RenderMixin
   # So we can do raise TemplateNotFound
   include Merb::ControllerExceptions
-  
+
   # ==== Parameters
   # base<Module>:: Module that is including RenderMixin (probably a controller)
   def self.included(base)
@@ -10,9 +10,9 @@ module Merb::RenderMixin
       class_inheritable_accessor :_default_render_options
     end
   end
-  
+
   module ClassMethods
-    
+
     # Return the default render options.
     #
     # ==== Returns
@@ -20,7 +20,7 @@ module Merb::RenderMixin
     def default_render_options
       self._default_render_options ||= {}
     end
-    
+
     # Set default render options at the class level.
     #
     # ==== Parameters
@@ -28,53 +28,57 @@ module Merb::RenderMixin
     def render_options(opts)
       self._default_render_options = opts
     end
-    
+
     # Set the default layout to use or nil/false to disable layout rendering.
-    # This is a shortcut for render_options :layout => false. 
+    # This is a shortcut for render_options :layout => false.
     #
     # ==== Parameters
-    # layout<~to_s>:: The layout that should be used for this class
-    # 
+    # layout<~to_s>:: The layout that should be used for this class.
+    #
+    # ==== Notes
+    # You can override by passing :layout => true to render method.
+    #
     # ==== Returns
     # Hash:: The default render options.
     def layout(layout)
       self.default_render_options.update(:layout => (layout ? layout : false))
     end
-    
+
     # Enable the default layout logic - reset the layout option.
     def default_layout
       self.default_render_options.delete(:layout)
     end
-    
+
   end
-  
+
   # Render the specified item, with the specified options.
   #
   # ==== Parameters
-  # thing<String, Symbol, nil>:: 
+  # thing<String, Symbol, nil>::
   #   The thing to render. This will default to the current action
   # opts<Hash>:: An options hash (see below)
   #
   # ==== Options (opts)
   # :format<Symbol>:: A registered mime-type format
-  # :template<String>:: 
+  # :template<String>::
   #   The path to the template relative to the template root
-  # :status<~to_i>:: 
+  # :status<~to_i>::
   #   The status to send to the client. Typically, this would be an integer
   #   (200), or a Merb status code (Accepted)
-  # :layout<~to_s>::
+  # :layout<~to_s, FalseClass>::
   #   A layout to use instead of the default. This should be relative to the
   #   layout root. By default, the layout will be either the controller_name or
   #   application. If you want to use an alternative content-type than the one
   #   that the base template was rendered as, you will need to do :layout =>
-  #   "foo.#{content_type}" (i.e. "foo.json")
+  #   "foo.#{content_type}" (i.e. "foo.json"). If you want to render without
+  #   layout, use :layout => false. This overrides layout set by +layout+ method.
   #
   # ==== Returns
   # String:: The rendered template, including layout, if appropriate.
   #
   # ==== Raises
   # TemplateNotFound:: There is no template for the specified location.
-  # 
+  #
   # ==== Alternatives
   # If you pass a Hash as the first parameter, it will be moved to opts and
   # "thing" will be the current action
@@ -83,59 +87,65 @@ module Merb::RenderMixin
   def render(thing = nil, opts = {})
     # render :format => :xml means render nil, :format => :xml
     opts, thing = thing, nil if thing.is_a?(Hash)
-    
+
     # Merge with class level default render options
     opts = self.class.default_render_options.merge(opts)
-    
+
     # If you don't specify a thing to render, assume they want to render the current action
     thing ||= action_name.to_sym
 
     # Content negotiation
-    opts[:format] ? (self.content_type = opts[:format]) : content_type 
-    
+    opts[:format] ? (self.content_type = opts[:format]) : content_type
+
     # Handle options (:status)
-    _handle_options!(opts)    
-    
+    _handle_options!(opts)
+
     # Do we have a template to try to render?
     if thing.is_a?(Symbol) || opts[:template]
 
-      template_method, template_location = _template_for(thing, content_type, controller_name, opts)
-  
+      template_method, template_location = 
+        _template_for(thing, content_type, controller_name, opts[:template])
+
       # Raise an error if there's no template
-      raise TemplateNotFound, "No template found at #{template_location}.*"  \
-        unless template_method && self.respond_to?(template_method)
+      unless template_method && self.respond_to?(template_method)
+        template_files = Merb::Template.template_extensions.map { |ext| "#{template_location}.#{ext}" }
+        raise TemplateNotFound, "Oops! No template found. Merb was looking for #{template_files.join(', ')}" + 
+          "for content type '#{content_type}'. You might have mispelled the template or file name. " + 
+          "Registered template extensions: #{Merb::Template.template_extensions.join(', ')}. " +
+          "If you use Haml or some other template plugin, make sure you required Merb plugin dependency " + 
+          "in your init file."
+      end
 
       # Call the method in question and throw the content for later consumption by the layout
       throw_content(:for_layout, self.send(template_method))
-      
+
     # Do we have a string to render?
     elsif thing.is_a?(String)
-      
+
       # Throw it for later consumption by the layout
       throw_content(:for_layout, thing)
     end
-    
+
     # If we find a layout, use it. Otherwise, just render the content thrown for layout.
-    layout = opts[:layout] != false && _get_layout(opts[:layout])
-    layout ? send(layout) : catch_content(:for_layout)
+    (layout = _get_layout(opts[:layout])) ? send(layout) : catch_content(:for_layout)
   end
-    
+
   # Renders an object using to registered transform method based on the
   # negotiated content-type, if a template does not exist. For instance, if the
   # content-type is :json, Merb will first look for current_action.json.*.
   # Failing that, it will run object.to_json.
   #
   # ==== Parameter
-  # object<Object>:: 
+  # object<Object>::
   #   An object that responds_to? the transform method registered for the
   #   negotiated mime-type.
   # thing<String, Symbol>::
   #   The thing to attempt to render via #render before calling the transform
   #   method on the object. Defaults to nil.
-  # opts<Hash>:: 
+  # opts<Hash>::
   #   An options hash that will be used for rendering
   #   (passed on to #render or serialization methods like #to_json or #to_xml)
-  # 
+  #
   # ==== Returns
   # String::
   #   The rendered template or if no template is found, the transformed object.
@@ -144,10 +154,10 @@ module Merb::RenderMixin
   # NotAcceptable::
   #   If there is no transform method for the specified mime-type or the object
   #   does not respond to the transform method.
-  # 
+  #
   # ==== Alternatives
   # A string in the second parameter will be interpreted as a template:
-  #   display @object, "path/to/foo" 
+  #   display @object, "path/to/foo"
   #   #=> display @object, nil, :template => "path/to/foo"
   #
   # A hash in the second parameters will be interpreted as opts:
@@ -157,18 +167,20 @@ module Merb::RenderMixin
   # If you need to pass extra parameters to serialization method, for instance,
   # to exclude some of attributes or serialize associations, just pass options
   # for it.
-  # For instance, 
+  # For instance,
   #
-  # display	@locations, :except => [:locatable_type, :locatable_id], :include => [:locatable]
+  # display @locations, :except => [:locatable_type, :locatable_id], :include => [:locatable]
+  #
+  # serializes object with polymorphic association, not raw locatable_* attributes.
   #
-  # serializes object with polymorphic association,	not raw	locatable_* attributes.
   #
-  #  
   # ==== Options
   #
   # :template                a template to use for rendering
   # :layout                  a layout to use for rendering
-  
+  # :status                  the status code to return (defaults to 200)
+  # :location                the value of the Location header
+  #
   # all other options        options that will be pass to serialization method
   #                          like #to_json or #to_xml
   #
@@ -177,62 +189,50 @@ module Merb::RenderMixin
   # explicitly passed in the opts.
   #
   def display(object, thing = nil, opts = {})
-    # display @object, "path/to/foo" means display @object, nil, :template => "path/to/foo"
-    # display @object, :template => "path/to/foo" means display @object, nil, :template => "path/to/foo"
     template_opt = opts.delete(:template)
-    
+
     case thing
+    # display @object, "path/to/foo" means display @object, nil, :template => "path/to/foo"
     when String
       template_opt, thing = thing, nil
+    # display @object, :template => "path/to/foo" means display @object, nil, :template => "path/to/foo"
     when Hash
       opts, thing = thing, nil
     end
-    
+
     # Try to render without the object
     render(thing || action_name.to_sym, opts.merge(:template => template_opt))
-  
+
   # If the render fails (i.e. a template was not found)
-  rescue TemplateNotFound
+  rescue TemplateNotFound => e
     # Merge with class level default render options
+    # @todo can we find a way to refactor this out so we don't have to do it everywhere?
     opts = self.class.default_render_options.merge(opts)
-    
+
     # Figure out what to transform and raise NotAcceptable unless there's a transform method assigned
     transform = Merb.mime_transform_method(content_type)
-    raise NotAcceptable unless transform && object.respond_to?(transform)
+    if !transform
+      raise NotAcceptable, "#{e.message} and there was no transform method registered for #{content_type.inspect}"
+    elsif !object.respond_to?(transform)
+      raise NotAcceptable, "#{e.message} and your object does not respond to ##{transform}"
+    end
 
-    # Only use a layout if one was specified
     layout_opt = opts.delete(:layout)
+    _handle_options!(opts)
+    throw_content(:for_layout, opts.empty? ? object.send(transform) : object.send(transform, opts))
     
-    if layout_opt
-      # Look for the layout under the default layout directly. If it's not found, reraise
-      # the TemplateNotFound error
-      template = _template_location(layout_opt, layout.index(".") ? content_type : nil, "layout")      
-      layout = _template_for(_template_root / template) ||
-        (raise TemplateNotFound, "No layout found at #{_template_root / template}.*")      
-              
-      # If the layout was found, call it
-      send(layout)
-    
-    # Otherwise, just render the transformed object
-    else
-      unless opts.empty?
-        # there are options for serialization method
-        throw_content(:for_layout, object.send(transform, opts))
-      else
-        throw_content(:for_layout, object.send(transform))
-      end  
-      catch_content(:for_layout)
-    end
+    meth, _ = _template_for(layout_opt, layout_opt.to_s.index(".") ? nil : content_type, "layout") if layout_opt
+    meth ? send(meth) : catch_content(:for_layout)
   end
 
   # Render a partial template.
   #
   # ==== Parameters
   # template<~to_s>::
-  #   The path to the template, relative to the current controller or the 
-  #   template root. If the template contains a "/", Merb will search for it
-  #   relative to the template root; otherwise, Merb will search for it
-  #   relative to the current controller.
+  #   The path to the template, relative to the current controller or the
+  #   template root; absolute path will work too. If the template contains a "/", 
+  #   Merb will search for it relative to the template root; otherwise, 
+  #   Merb will search for it relative to the current controller.
   # opts<Hash>:: A hash of options (see below)
   #
   # ==== Options (opts)
@@ -244,56 +244,95 @@ module Merb::RenderMixin
   #   A Hash object names and values that will be the local names and values
   #   inside the partial.
   #
-  # ==== Example
+  # ==== Examples
   #   partial :foo, :hello => @object
   #
   # The "_foo" partial will be called, relative to the current controller,
   # with a local variable of +hello+ inside of it, assigned to @object.
+  #
+  #   partial :bar, :with => ['one', 'two', 'three']
+  #
+  # The "_bar" partial will be called once for each element of the array
+  # specified by :with for a total of three iterations. Each element
+  # of the array will be available in the partial via a local variable named
+  # +bar+. Additionally, there will be two extra local variables:
+  # +collection_index+ and +collection_size+. +collection_index+ is the index
+  # of the object currently referenced by +bar+ in the collection passed to
+  # the partial. +collection_size+ is the total size of the collection.
+  #
+  # By default, the object specified by :with will be available through a
+  # local variable with the same name as the partial template. However,
+  # this can be changed using the :as option.
+  #
+  #   partial :bar, :with => "one", :as => :number
+  #
+  # In this case, "one" will be available in the partial through the local
+  # variable named +number+.
+  #
+  # ==== Notes
+  # It is important to note that the object being passed to the partial
+  # as well as any extra local variables cannot use names of helper methods
+  # since any helper method of the same name will take precedence over the
+  # passed variable. Example:
+  #
+  #   partial :bar, :with => "one", :as => :partial
+  #
+  # In this case, "one" will not be available in the partial because "partial"
+  # is already a helper method.
   def partial(template, opts={})
 
     # partial :foo becomes "#{controller_name}/_foo"
     # partial "foo/bar" becomes "foo/_bar"
     template = template.to_s
-    kontroller = (m = template.match(/.*(?=\/)/)) ? m[0] : controller_name
-    template = "_#{File.basename(template)}"
-    
-    template_method, template_location = _template_for(template, opts.delete(:format) || content_type, kontroller)
+    if template =~ %r{^/}
+      template_path = File.dirname(template) / "_#{File.basename(template)}"
+    else
+      kontroller = (m = template.match(/.*(?=\/)/)) ? m[0] : controller_name
+      template = "_#{File.basename(template)}"
+    end
+    template_method, template_location = 
+      _template_for(template, opts.delete(:format) || content_type, kontroller, template_path)
 
     (@_old_partial_locals ||= []).push @_merb_partial_locals
-
-    if opts.key?(:with)
-      with = opts.delete(:with)
-      as = opts.delete(:as) || template_location.match(%r[.*/_([^\.]*)])[1]
-      @_merb_partial_locals = opts
-      sent_template = [with].flatten.map do |temp|
-        @_merb_partial_locals[as.to_sym] = temp
-        send(template_method)
-      end.join
-    else
-      @_merb_partial_locals = opts
+    
+    # This handles no :with as well
+    with = [opts.delete(:with)].flatten
+    as = opts.delete(:as) || template_location.match(%r[.*/_([^\.]*)])[1]
+    
+    @_merb_partial_locals = opts.merge(:collection_index => -1, :collection_size => with.size)
+    
+    # this handles an edge-case where the name of the partial is _foo.* and your opts
+    # have :foo as a key.
+    named_local = @_merb_partial_locals.key?(as.to_sym)
+    
+    sent_template = with.map do |temp|
+      @_merb_partial_locals[as.to_sym] = temp unless named_local
       if template_method && self.respond_to?(template_method)
-        sent_template = send(template_method)
+        @_merb_partial_locals[:collection_index] += 1
+        send(template_method)
       else
         raise TemplateNotFound, "Could not find template at #{template_location}.*"
       end
-    end
+    end.join
+    
     @_merb_partial_locals = @_old_partial_locals.pop
     sent_template
-  end      
-  
+  end
+
   # Take the options hash and handle it as appropriate.
-  # 
+  #
   # ==== Parameters
   # opts<Hash>:: The options hash that was passed into render.
-  # 
+  #
   # ==== Options
   # :status<~to_i>::
   #   The status of the response will be set to opts[:status].to_i
-  # 
+  #
   # ==== Returns
   # Hash:: The options hash that was passed in.
   def _handle_options!(opts)
-    self.status = opts[:status].to_i if opts[:status]
+    self.status = opts.delete(:status).to_i if opts[:status]
+    headers["Location"] = opts.delete(:location) if opts[:location]
     opts
   end
 
@@ -305,22 +344,26 @@ module Merb::RenderMixin
   #
   # ==== Parameters
   # layout<~to_s>:: A layout, relative to the layout root. Defaults to nil.
-  # 
+  #
   # ==== Returns
   # String:: The method name that corresponds to the found layout.
-  # 
+  #
   # ==== Raises
   # TemplateNotFound::
   #   If a layout was specified (either via layout in the class or by passing
   #   one in to this method), and not found. No error will be raised if no
   #   layout was specified, and the default layouts were not found.
   def _get_layout(layout = nil)
+    return false if layout == false
+    
     layout = layout.instance_of?(Symbol) && self.respond_to?(layout, true) ? send(layout) : layout
     layout = layout.to_s if layout
-    
+
     # If a layout was provided, throw an error if it's not found
-    if layout
-      template_method, template_location = _template_for(layout, layout.index(".") ? nil : content_type, "layout")
+    if layout      
+      template_method, template_location = 
+        _template_for(layout, layout.index(".") ? nil : content_type, "layout")
+        
       raise TemplateNotFound, "No layout found at #{template_location}" unless template_method
       template_method
 
@@ -331,13 +374,13 @@ module Merb::RenderMixin
       template
     end
   end
-  
-  # Iterate over the template roots in reverse order, and return the template 
+
+  # Iterate over the template roots in reverse order, and return the template
   # and template location of the first match.
   #
   # ==== Parameters
-  # context<Object>:: The controller action or template basename.
-  # content_type<~to_s>:: The content type. Defaults to nil.
+  # context<Object>:: The controller action or template (basename or absolute path).
+  # content_type<~to_s>:: The content type (like html or json).
   # controller<~to_s>:: The name of the controller. Defaults to nil.
   #
   # ==== Options (opts)
@@ -348,25 +391,44 @@ module Merb::RenderMixin
   # ==== Returns
   # Array[Symbol, String]::
   #   A pair consisting of the template method and location.
-  def _template_for(context, content_type, controller=nil, opts={})
-    template_method = nil
-    template_location = nil
-    
-    self.class._template_roots.reverse_each do |root, template_location| 
-      if opts[:template] # use the given template as the location context
-        template_location = root / self.send(template_location, opts[:template], content_type, nil)
-        template_method = Merb::Template.template_for(template_location)
-        break if template_method && self.respond_to?(template_method)
+  def _template_for(context, content_type, controller=nil, template=nil)
+    template_method, template_location = nil, nil
+
+    # absolute path to a template (:template => "/foo/bar")
+    if template.is_a?(String) && template =~ %r{^/}
+      template_location = self._absolute_template_location(template, content_type)
+      return [_template_method_for(template_location), template_location]
+    end
+
+    self.class._template_roots.reverse_each do |root, template_meth|
+      # :template => "foo/bar.html" where root / "foo/bar.html.*" exists
+      if template
+        template_location = root / self.send(template_meth, template, content_type, nil)
+      # :layout => "foo" where root / "layouts" / "#{controller}.html.*" exists        
+      else
+        template_location = root / self.send(template_meth, context, content_type, controller)
       end
       
-      template_location = root / (opts[:template] || self.send(template_location, context, content_type, controller))
-      template_method = Merb::Template.template_for(template_location)
-      break if template_method && self.respond_to?(template_method)
+      break if template_method = _template_method_for(template_location.to_s)
     end
 
-    [template_method, template_location]
+    # template_location is a Pathname
+    [template_method, template_location.to_s]
   end
-    
+  
+  # Return the template method for a location, and check to make sure the current controller
+  # actually responds to the method.
+  #
+  # ==== Parameters
+  # template_location<String>:: The phyical path of the template
+  #
+  # ==== Returns
+  # String:: The method, if it exists. Otherwise return nil.
+  def _template_method_for(template_location)
+    meth = Merb::Template.template_for(template_location)
+    meth && self.respond_to?(meth) ? meth : nil
+  end
+
   # Called in templates to get at content thrown in another template. The
   # results of rendering a template are automatically thrown into :for_layout,
   # so catch_content or catch_content(:for_layout) can be used inside layouts
@@ -377,9 +439,9 @@ module Merb::RenderMixin
   #---
   # @public
   def catch_content(obj = :for_layout)
-    @_caught_content[obj]
+    @_caught_content[obj] * '' unless @_caught_content[obj].nil?
   end
-  
+
   # Called in templates to test for the existence of previously thrown content.
   #
   # ==== Parameters
@@ -389,7 +451,7 @@ module Merb::RenderMixin
   def thrown_content?(obj = :for_layout)
     @_caught_content.key?(obj)
   end
-  
+
   # Called in templates to store up content for later use. Takes a string
   # and/or a block. First, the string is evaluated, and then the block is
   # captured using the capture() helper provided by the template languages. The
@@ -412,7 +474,8 @@ module Merb::RenderMixin
     unless string || block_given?
       raise ArgumentError, "You must pass a block or a string into throw_content"
     end
-    @_caught_content[obj] = string.to_s << (block_given? ? capture(&block) : "")
+    @_caught_content[obj] = [] if @_caught_content[obj].nil?
+    @_caught_content[obj] << string.to_s << (block_given? ? capture(&block) : "")
   end
-  
+
 end