merb-core 0.9.7 → 0.9.8

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

@@ -227,7 +227,6 @@ class Merb::AbstractController
   def initialize(*args)
     @_benchmarks = {}
     @_caught_content = {}
-    @_template_stack = []
   end
   
   # This will dispatch the request, calling internal before/after dispatch_callbacks
@@ -427,19 +426,13 @@ class Merb::AbstractController
   # ==== Alternatives
   # If a hash is used as the first argument, a default route will be
   # generated based on it and rparams.
-  def url(name, rparams = {}, qparams = {})
-    unless rparams.is_a?(Hash) || qparams.empty?
-      rparams = qparams.merge(:id => rparams)
-    end
-    uri = Merb::Router.generate(name, rparams,
-      { :controller => controller_name,
-        :action => action_name,
-        :format => params[:format]
-      }
-    ) 
-    uri = Merb::Config[:path_prefix] + uri if Merb::Config[:path_prefix]
-    uri
+  # ====
+  # TODO: Update this documentation
+  def url(name, *args)
+    args << {}
+    Merb::Router.url(name, *args)
   end
+  
   alias_method :relative_url, :url
 
   # ==== Parameters
@@ -458,30 +451,71 @@ class Merb::AbstractController
   # ==== Alternatives
   # If a hash is used as the first argument, a default route will be
   # generated based on it and rparams.
-  def absolute_url(name, rparams={})
+  def absolute_url(name, *args)
     # FIXME: arrgh, why request.protocol returns http://?
     # :// is not part of protocol name
-    if rparams.is_a?(Hash)
-      protocol = rparams.delete(:protocol)
-      protocol << "://" if protocol
-      host = rparams.delete(:host)
-    end
+    options  = extract_options_from_args!(args) || {}
+    protocol = options.delete(:protocol)
+    host     = options.delete(:host)
     
-    (protocol || request.protocol) +
-      (host || request.host) +
-      url(name, rparams)
+    raise ArgumentError, "The :protocol option must be specified" unless protocol
+    raise ArgumentError, "The :host option must be specified"     unless host
+    
+    args << options
+    
+    protocol + "://" + host + url(name, *args)
+  end
+  
+  # Generates a URL for a single or nested resource.
+  #
+  # ==== Parameters
+  # resources<Symbol,Object>:: The resources for which the URL
+  #   should be generated. These resources should be specified
+  #   in the router.rb file using #resources and #resource.
+  #
+  # options<Hash>:: Any extra parameters that are needed to
+  #   generate the URL.
+  #
+  # ==== Returns
+  # String:: The generated URL.
+  #
+  # ==== Examples
+  #
+  # Merb::Router.prepare do
+  #   resources :users do
+  #     resources :comments
+  #   end
+  # end
+  #
+  # resource(:users)            # => /users
+  # resource(@user)             # => /users/10
+  # resource(@user, :comments)  # => /users/10/comments
+  # resource(@user, @comment)   # => /users/10/comments/15
+  # resource(:users, :new)      # => /users/new
+  # resource(:@user, :edit)     # => /users/10/edit
+  #
+  def resource(*args)
+    args << params
+    Merb::Router.resource(*args)
   end
 
   # Calls the capture method for the selected template engine.
   #
   # ==== Parameters
   # *args:: Arguments to pass to the block.
-  # &block:: The template block to call.
+  # &block:: The block to call.
   #
   # ==== Returns
-  # String:: The output of the block.
+  # String:: The output of a template block or the return value of a non-template block converted to a string.
   def capture(*args, &block)
-    send("capture_#{@_engine}", *args, &block)
+    ret = nil
+
+    captured = send("capture_#{@_engine}", *args) do |*args|
+      ret = yield *args
+    end
+
+    # return captured value only if it is not empty
+    captured.empty? ? ret.to_s : captured
   end
 
   # Calls the concatenate method for the selected template engine.
@@ -571,15 +605,4 @@ class Merb::AbstractController
     opts[:exclude]  = Array(opts[:exclude]).map {|x| x.to_s} if opts[:exclude]
     return opts
   end
-
-  # Attempts to return the partial local variable corresponding to sym.
-  #
-  # ==== Paramteres
-  # sym<Symbol>:: Method name.
-  # *arg:: Arguments to pass to the method.
-  # &blk:: A block to pass to the method.
-  def method_missing(sym, *args, &blk)
-    return @_merb_partial_locals[sym] if @_merb_partial_locals && @_merb_partial_locals.key?(sym)
-    super
-  end  
 end

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

@@ -278,6 +278,8 @@ module Merb
 
     class ServerError                   < Merb::ControllerExceptions::Base; end
 
+      class InternalServerError         < Merb::ControllerExceptions::ServerError; self.status = 500; end
+
       class NotImplemented              < Merb::ControllerExceptions::ServerError; self.status = 501; end
 
       class BadGateway                  < Merb::ControllerExceptions::ServerError; self.status = 502; end
@@ -287,21 +289,6 @@ module Merb
       class GatewayTimeout              < Merb::ControllerExceptions::ServerError; self.status = 504; end
 
       class HTTPVersionNotSupported     < Merb::ControllerExceptions::ServerError; self.status = 505; end
-
-      class InternalServerError         < Merb::ControllerExceptions::ServerError #:doc: 
-        self.status = 500;
-        def initialize(exception = nil)
-          @exception = exception
-        end
-
-        def backtrace
-          @exception ? @exception.backtrace : backtrace
-        end
-
-        def message
-          @exception ? @exception.message : message
-        end
-      end
   end
   
   # Required to show exceptions in the log file

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

@@ -218,6 +218,33 @@ class Merb::Controller < Merb::AbstractController
   # ==== Returns
   # Hash:: The parameters from the request object
   def params()  request.params  end
+    
+  # ==== Parameters
+  # name<~to_sym, Hash>:: The name of the URL to generate.
+  # rparams<Hash>:: Parameters for the route generation.
+  #
+  # ==== Returns
+  # String:: The generated URL.
+  #
+  # ==== Alternatives
+  # If a hash is used as the first argument, a default route will be
+  # generated based on it and rparams.
+  # ====
+  # TODO: Update this documentation
+  def url(name, *args)
+    args << params
+    Merb::Router.url(name, *args)
+  end
+
+  alias_method :relative_url, :url
+  
+  def absolute_url(*args)
+    options  = extract_options_from_args!(args) || {}
+    options[:protocol] ||= request.protocol
+    options[:host] ||= request.host
+    args << options
+    super(args.first, *args[1..-1])
+  end
 
   # The results of the controller's render, to be returned to Rack.
   #
@@ -225,7 +252,23 @@ class Merb::Controller < Merb::AbstractController
   # Array[Integer, Hash, String]::
   #   The controller's status code, headers, and body
   def rack_response
-    [status, headers, body]
+    [status, headers, Merb::Rack::StreamWrapper.new(body)]
+  end
+
+  # Sets a controller to be "abstract" 
+  # This controller will not be able to be routed to
+  # and is used for super classing only
+  def self.abstract!
+    @_abstract = true
+  end
+  
+  # Asks a controller if it is abstract
+  #
+  # === Returns
+  # Boolean
+  #  true if the controller has been set as abstract
+  def self.abstract?
+    !!@_abstract 
   end
 
   # Hide any methods that may have been exposed as actions before.

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

@@ -7,6 +7,10 @@ module Merb
       ResponderMixin::TYPES
     end
 
+    def available_accepts
+      ResponderMixin::MIMES
+    end
+
     # Any specific outgoing headers should be included here.  These are not
     # the content-type header but anything in addition to it.
     # +transform_method+ should be set to a symbol of the method used to

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

@@ -62,6 +62,7 @@ module Merb
     # ==== Parameters
     # data<String>:: a chunk of data to return.
     def send_chunk(data)
+      only_runs_on_mongrel!
       @response.write('%x' % data.size + "\r\n")
       @response.write(data + "\r\n")
     end
@@ -76,12 +77,8 @@ module Merb
     #   A block that Mongrel can call later, allowing Merb to release the
     #   thread lock and render another request.
     def render_deferred(&blk)
-      must_support_streaming!
       Proc.new {|response|
-        result = blk.call
-        response.send_status(result.length)
-        response.send_header
-        response.write(result)
+        response.write(blk.call)
       }
     end
     
@@ -96,10 +93,7 @@ module Merb
     # Proc::
     #   A block that Mongrel can call after returning the string to the user.
     def render_then_call(str, &blk)
-      must_support_streaming!
       Proc.new {|response|
-        response.send_status(str.length)
-        response.send_header
         response.write(str)
         blk.call        
       }      
@@ -166,7 +160,13 @@ module Merb
         'Content-Disposition'       => disposition,
         'Content-Transfer-Encoding' => 'binary'
       )
-      File.open(file, 'rb')
+      Proc.new {|response|
+        file = File.open(file, 'rb')
+        while chunk = file.read(16384)
+          response.write chunk
+        end  
+        file.close
+      }
     end
     
     # Send binary data over HTTP to the user as a file download. May set content type,
@@ -217,7 +217,6 @@ module Merb
     #     end
     #   end
     def stream_file(opts={}, &stream)
-      must_support_streaming!
       opts.update(Merb::Const::DEFAULT_SEND_FILE_OPTIONS.merge(opts))
       disposition = opts[:disposition].dup || 'attachment'
       disposition << %(; filename="#{opts[:filename]}")
@@ -229,8 +228,6 @@ module Merb
         'CONTENT-LENGTH'            => opts[:content_length].to_s
       )
       Proc.new{|response|
-        response.send_status(opts[:content_length])
-        response.send_header
         stream.call(response)
       }
     end
@@ -239,10 +236,30 @@ module Merb
     # from nginx. For more information, see the nginx wiki:
     # http://wiki.codemongers.com/NginxXSendfile
     #
+    # and the following sample gist:
+    # http://gist.github.com/11225
+    #
+    # there's also example application up on GitHub:
+    #
+    # http://github.com/michaelklishin/nginx-x-accel-redirect-example-application/tree/master
+    #
+    # Unless Content-Disposition is set before calling this method,
+    # it is set to attachment with streamed file name.
+    #
     # ==== Parameters
-    # file<String>:: Path to file to send to the client.
-    def nginx_send_file(file)
-      headers['X-Accel-Redirect'] = file
+    # path<String>:: Path to file to send to the client.
+    # content_type<String>:: content type header value. By default is set to empty string to let
+    #                        Nginx detect it.
+    #
+    # ==== Return
+    # One space string.
+    def nginx_send_file(path, content_type = "")
+      # Let Nginx detect content type unless it is explicitly set
+      headers['Content-Type']        = content_type
+      headers["Content-Disposition"] ||= "attachment; filename=#{path.split('/').last}"
+      
+      headers['X-Accel-Redirect']    = path
+      
       return ' '
     end  
   
@@ -283,16 +300,16 @@ module Merb
       Erubis::XmlHelper.escape_xml(obj.to_s)
     end
     alias h escape_xml
-    alias html_escape escape_xml
+    alias escape_html escape_xml
     
     private
-      # Checks whether streaming is supported by the current Rack adapter.
+      # Marks an output method that only runs on the mongrel webserver.
       #
       # ==== Raises
-      # NotImplemented:: The Rack adapter doens't support streaming.
-      def must_support_streaming!
-        unless request.env['rack.streaming']
-          raise(Merb::ControllerExceptions::NotImplemented, "Current Rack adapter does not support streaming")
+      # NotImplemented:: The Rack adapter is not mongrel.
+      def only_runs_on_mongrel!
+        unless Merb::Config[:log_stream] == 'mongrel'
+          raise(Merb::ControllerExceptions::NotImplemented, "Current Rack adapter is not mongrel. cannot support this feature")
         end
       end
   end

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

@@ -268,17 +268,6 @@ module Merb::RenderMixin
   #
   # 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"
@@ -290,32 +279,36 @@ module Merb::RenderMixin
       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
-    
     # 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)
+    as = (opts.delete(:as) || template.match(%r[(?:.*/)?_([^\./]*)])[1]).to_sym
+
+    # Ensure that as is in the locals hash even if it isn't passed in here
+    # so that it's included in the preamble. 
+    locals = opts.merge(:collection_index => -1, :collection_size => with.size, as => opts[as])
+    template_method, template_location = _template_for(
+      template, 
+      opts.delete(:format) || content_type, 
+      kontroller, 
+      template_path, 
+      locals.keys)
     
     # 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)
+    named_local = opts.key?(as)
     
     sent_template = with.map do |temp|
-      @_merb_partial_locals[as.to_sym] = temp unless named_local
+      locals[as] = temp unless named_local
+
       if template_method && self.respond_to?(template_method)
-        @_merb_partial_locals[:collection_index] += 1
-        send(template_method)
+        locals[:collection_index] += 1
+        send(template_method, locals)
       else
         raise TemplateNotFound, "Could not find template at #{template_location}.*"
       end
     end.join
     
-    @_merb_partial_locals = @_old_partial_locals.pop
     sent_template
   end
 
@@ -382,6 +375,7 @@ module Merb::RenderMixin
   # 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.
+  # locals<Array[Symbol]>:: A list of locals to assign from the args passed into the compiled template.
   #
   # ==== Options (opts)
   # :template<String>::
@@ -391,13 +385,13 @@ module Merb::RenderMixin
   # ==== Returns
   # Array[Symbol, String]::
   #   A pair consisting of the template method and location.
-  def _template_for(context, content_type, controller=nil, template=nil)
+  def _template_for(context, content_type, controller=nil, template=nil, locals=[])
     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]
+      return [_template_method_for(template_location, locals), template_location]
     end
 
     self.class._template_roots.reverse_each do |root, template_meth|
@@ -409,7 +403,7 @@ module Merb::RenderMixin
         template_location = root / self.send(template_meth, context, content_type, controller)
       end
       
-      break if template_method = _template_method_for(template_location.to_s)
+      break if template_method = _template_method_for(template_location.to_s, locals)
     end
 
     # template_location is a Pathname
@@ -421,11 +415,12 @@ module Merb::RenderMixin
   #
   # ==== Parameters
   # template_location<String>:: The phyical path of the template
+  # locals<Array[Symbol]>:: A list of locals to assign from the args passed into the compiled template.
   #
   # ==== Returns
   # String:: The method, if it exists. Otherwise return nil.
-  def _template_method_for(template_location)
-    meth = Merb::Template.template_for(template_location)
+  def _template_method_for(template_location, locals)
+    meth = Merb::Template.template_for(template_location, [], locals)
     meth && self.respond_to?(meth) ? meth : nil
   end
 
@@ -439,7 +434,7 @@ module Merb::RenderMixin
   #---
   # @public
   def catch_content(obj = :for_layout)
-    @_caught_content[obj] * '' unless @_caught_content[obj].nil?
+    @_caught_content[obj] || ''
   end
 
   # Called in templates to test for the existence of previously thrown content.
@@ -474,6 +469,26 @@ 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) : "")
+  end
+
+  # Called in templates to append content for later use. Works like throw_content.
+  #
+  # @param [Object] obj
+  #   Key used in the thrown_content hash.
+  # @param [String] string
+  #   Textual content. Default to nil.
+  # @yield 
+  #   Evaluated with result concatenated to string.
+  #
+  # @raise [ArgumentError]
+  #   Neither string nor block given
+  #
+  # @api public
+  def append_content(obj, string = nil, &block)
+    unless string || block_given?
+      raise ArgumentError, "You must pass a block or a string into append_content"
+    end
     @_caught_content[obj] = [] if @_caught_content[obj].nil?
     @_caught_content[obj] << string.to_s << (block_given? ? capture(&block) : "")
   end