merb-core 0.9.3 → 0.9.4

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

@@ -1,6 +1,7 @@
 require 'enumerator'
 require 'merb-core/controller/mime'
 require "merb-core/vendor/facets/dictionary"
+
 module Merb
   # The ResponderMixin adds methods that help you manage what
   # formats your controllers have available, determine what format(s)
@@ -98,12 +99,13 @@ module Merb
   module ResponderMixin
     
     TYPES = Dictionary.new
+    MIMES = {}
 
     class ContentTypeAlreadySet < StandardError; end
     
     # ==== Parameters
     # base<Module>:: The module that ResponderMixin was mixed into
-    def self.included(base) # :nodoc:
+    def self.included(base)
       base.extend(ClassMethods)
       base.class_eval do
         class_inheritable_accessor :class_provided_formats
@@ -132,9 +134,7 @@ module Merb
       #---
       # @public
       def provides(*formats)
-        formats.each do |fmt|
-          self.class_provided_formats << fmt unless class_provided_formats.include?(fmt)
-        end
+        self.class_provided_formats |= formats
       end
       
       # This class should only provide the formats listed here, despite any
@@ -195,28 +195,6 @@ module Merb
       @_provided_formats ||= class_provided_formats.dup
     end
     
-    # Sets the provided formats for this action.  Usually, you would use a
-    # combination of provides, only_provides and does_not_provide to manage
-    # this, but you can set it directly.
-    # 
-    # ==== Parameters
-    # *formats<Symbol>:: A list of formats to be passed to provides.
-    #
-    # ==== Raises
-    # Merb::ResponderMixin::ContentTypeAlreadySet::
-    #   Content negotiation already occured, and the content_type is set.
-    #
-    # ==== Returns
-    # Array[Symbol]:: List of formats passed in.
-    def _set_provided_formats(*formats)
-      if @_content_type
-        raise ContentTypeAlreadySet, "Cannot modify provided_formats because content_type has already been set"
-      end
-      @_provided_formats = []
-      provides(*formats)
-    end
-    alias :_provided_formats= :_set_provided_formats   
-    
     # Adds formats to the list of provided formats for this particular request.
     # Usually used to add formats to a single action. See also the
     # controller-level provides that affects all actions in a controller.
@@ -238,9 +216,7 @@ module Merb
       if @_content_type
         raise ContentTypeAlreadySet, "Cannot modify provided_formats because content_type has already been set"
       end
-      formats.each do |fmt|
-        _provided_formats << fmt unless _provided_formats.include?(fmt)
-      end
+      @_provided_formats = self._provided_formats | formats # merges with class_provided_formats if not already
     end
 
     # Sets list of provided formats for this particular request. Usually used
@@ -257,7 +233,8 @@ module Merb
     #---
     # @public
     def only_provides(*formats)
-      _set_provided_formats(*formats)
+      @_provided_formats = []
+      provides(*formats)
     end
     
     # Removes formats from the list of provided formats for this particular 
@@ -275,8 +252,7 @@ module Merb
     #---
     # @public
     def does_not_provide(*formats)
-      formats.flatten!
-      self._provided_formats -= formats
+      @_provided_formats -= formats.flatten
     end
     
     # Do the content negotiation:
@@ -285,22 +261,29 @@ module Merb
     # 3. If it's */*, use the first provided format
     # 4. Look for one that is provided, in order of request
     # 5. Raise 406 if none found
-    def _perform_content_negotiation # :nodoc:
-      raise Merb::ControllerExceptions::NotAcceptable if _provided_formats.empty?
+    def _perform_content_negotiation
       if (fmt = params[:format]) && !fmt.empty?
         accepts = [fmt.to_sym]
+      elsif request.accept =~ %r{^(text/html|\*/\*)} && _provided_formats.first == :html
+        # Handle the common case of text/html and :html provided after checking :format
+        return :html
       else
         accepts = Responder.parse(request.accept).map {|t| t.to_sym}.compact
       end
-      specifics = accepts & _provided_formats
+      
+      # no need to make a bunch of method calls to _provided_formats
+      provided_formats = _provided_formats
+      
+      specifics = accepts & provided_formats
       return specifics.first unless specifics.length == 0
-      return _provided_formats.first if accepts.include? :all
+      return provided_formats.first if accepts.include?(:all) && !provided_formats.empty?
+      
       message  = "A format (%s) that isn't provided (%s) has been requested. "
       message += "Make sure the action provides the format, and be "
       message += "careful of before filters which won't recognize "
       message += "formats provided within actions."
       raise Merb::ControllerExceptions::NotAcceptable,
-        (message % [accepts.join(', '), _provided_formats.join(', ')])
+        (message % [accepts.join(', '), provided_formats.join(', ')])
     end
 
     # Returns the output format for this request, based on the 
@@ -350,8 +333,18 @@ module Merb
     def content_type=(type)
       unless Merb.available_mime_types.has_key?(type)
         raise Merb::ControllerExceptions::NotAcceptable.new("Unknown content_type for response: #{type}") 
-      end        
-      headers['Content-Type'] = Merb.available_mime_types[type][:request_headers].first
+      end
+
+      mime = Merb.available_mime_types[type]
+      
+      headers["Content-Type"] = mime[:content_type]
+      
+      # merge any format specific response headers
+      mime[:response_headers].each { |k,v| headers[k] ||= v }
+      
+      # if given, use a block to finetune any runtime headers
+      mime[:response_block].call(self) if mime[:response_block]
+
       @_content_type = type
     end
     
@@ -369,19 +362,19 @@ module Merb
     # ==== Returns
     # Array[AcceptType]:: The accepted types.
     def self.parse(accept_header)
-      list = accept_header.to_s.split(/,/).enum_for(:each_with_index).map do |entry,index|
-        AcceptType.new(entry,index += 1)
-      end.sort.uniq
-      # firefox (and possibly other browsers) send broken default accept headers.
-      # fix them up by sorting alternate xml forms (namely application/xhtml+xml)
-      # ahead of pure xml types (application/xml,text/xml).
-      if app_xml = list.detect{|e| e.super_range == 'application/xml'}
-        list.select{|e| e.to_s =~ /\+xml/}.each { |acc_type|
-          list[list.index(acc_type)],list[list.index(app_xml)] = 
-            list[list.index(app_xml)],list[list.index(acc_type)] }
+      # FF2 is broken. If we get FF2 headers, use FF3 headers instead.
+      if accept_header == "text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5"
+        accept_header = "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
+      end
+      
+      headers = accept_header.split(/,/)
+      idx, list = 0, []
+      while idx < headers.size
+        list << AcceptType.new(headers[idx], idx)
+        idx += 1
       end
-      list
-    end   
+      list.sort
+    end
       
   end
 
@@ -396,12 +389,15 @@ module Merb
     #   priority.
     def initialize(entry,index)
       @index = index
-      @media_range, quality = entry.split(/;\s*q=/).map{|a| a.strip }
-      @type, @sub_type = @media_range.split(/\//)
-      quality ||= 0.0 if @media_range == '*/*'
-      @quality = ((quality || 1.0).to_f * 100).to_i
+      
+      entry =~ /\s*([^;\s]*)\s*(;\s*q=\s*(.*))?/
+      @media_range, quality = $1, $3
+      
+      @type, @sub_type = @media_range.split(%r{/})
+      (quality ||= 0.0) if @media_range == "*/*"
+      @quality = quality ? (quality.to_f * 100).to_i : 100
     end
-
+    
     # Compares two accept types for sorting purposes.
     #
     # ==== Parameters
@@ -412,11 +408,14 @@ module Merb
     #   -1, 0 or 1, depending on whether entry has a lower, equal or higher
     #   priority than the accept type being compared.
     def <=>(entry)
-      c = entry.quality <=> quality
-      c = index <=> entry.index if c == 0
-      c
+      if entry.quality == quality
+        @index <=> entry.index
+      else
+        entry.quality <=> @quality
+      end
     end
 
+
     # ==== Parameters
     # entry<AcceptType>:: The accept type to compare.
     #
@@ -439,9 +438,12 @@ module Merb
     # Array[String]::
     #   All Accept header values, such as "text/html", that match this type.
     def synonyms
-      @syns ||= Merb.available_mime_types.values.map do |e| 
-        e[:request_headers] if e[:request_headers].include?(@media_range)
-      end.compact.flatten
+      return @syns if @syns
+      if mime = Merb.available_mime_types[Merb::ResponderMixin::MIMES[@media_range]]
+        @syns = mime[:accepts]
+      else
+        @syns = []
+      end
     end
 
     # ==== Returns
@@ -456,7 +458,7 @@ module Merb
     # Symbol: The type as a symbol, e.g. :html.
     def to_sym
       Merb.available_mime_types.select{|k,v| 
-        v[:request_headers] == synonyms || v[:request_headers][0] == synonyms[0]}.flatten.first
+        v[:accepts] == synonyms || v[:accepts][0] == synonyms[0]}.flatten.first
     end
 
     # ==== Returns

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

@@ -29,6 +29,27 @@ module Merb::Template
       path.gsub(/[^\.a-zA-Z0-9]/, "__").gsub(/\./, "_")
     end
 
+    # For a given path, get an IO object that responds to #path.
+    #
+    # This is so that plugins can override this if they provide
+    # mechanisms for specifying templates that are not just simple
+    # files. The plugin is responsible for ensuring that the fake
+    # path provided will work with #template_for, and thus the
+    # RenderMixin in general.
+    #
+    # ==== Parameters
+    # path<String>:: A full path to find a template for. This is the
+    #   path that the RenderMixin assumes it should find the template
+    #   in.
+    # 
+    # ==== Returns
+    # IO#path:: An IO object that responds to path (File or VirtualFile).
+    #---
+    # @semipublic
+    def load_template_io(path)
+      File.open(path, "r")
+    end
+
     # Get the name of the template method for a particular path.
     #
     # ==== Parameters
@@ -44,25 +65,34 @@ module Merb::Template
       
       ret = 
       if Merb::Config[:reload_templates]
-        file = Dir["#{path}.{#{Merb::Template::EXTENSIONS.keys.join(',')}}"].first
-        METHOD_LIST[path] = file ? inline_template(file) : nil
+        file = Dir["#{path}.{#{template_extensions.join(',')}}"].first
+        METHOD_LIST[path] = file ? inline_template(load_template_io(file)) : nil
       else
         METHOD_LIST[path] ||= begin
-          file = Dir["#{path}.{#{Merb::Template::EXTENSIONS.keys.join(',')}}"].first          
-          file ? inline_template(file) : nil
+          file = Dir["#{path}.{#{template_extensions.join(',')}}"].first          
+          file ? inline_template(load_template_io(file)) : nil
         end
       end
       
       ret
     end
     
+    # Get all known template extensions
+    #
+    # ==== Returns
+    #   Array:: Extension strings.
+    #---
+    # @semipublic
+    def template_extensions
+      EXTENSIONS.keys
+    end
+    
     # Takes a template at a particular path and inlines it into a module and
     # adds it to the METHOD_LIST table to speed lookup later.
     # 
     # ==== Parameters
-    # path<String>::
-    #   The full path of the template (minus the templating specifier) to
-    #   inline.
+    # io<#path>::
+    #   An IO that responds to #path (File or VirtualFile)
     # mod<Module>::
     #   The module to put the compiled method into. Defaults to
     #   Merb::InlineTemplates
@@ -72,10 +102,12 @@ module Merb::Template
     # must be available to instances of AbstractController that will use it.
     #---
     # @public
-    def inline_template(path, mod = Merb::InlineTemplates)
-      path = File.expand_path(path)
-      METHOD_LIST[path.gsub(/\.[^\.]*$/, "")] = 
-        engine_for(path).compile_template(path, template_name(path), mod)
+    def inline_template(io, mod = Merb::InlineTemplates)
+      path = File.expand_path(io.path)
+      ret = METHOD_LIST[path.gsub(/\.[^\.]*$/, "")] = 
+        engine_for(path).compile_template(io, template_name(path), mod)
+      io.close
+      ret
     end
     
     # Finds the engine for a particular path.
@@ -122,28 +154,21 @@ module Merb::Template
 
   class Erubis    
     # ==== Parameters
-    # path<String>:: A full path to the template.
+    # io<#path>:: An IO containing the full path of the template.
     # name<String>:: The name of the method that will be created.
     # mod<Module>:: The module that the compiled method will be placed into.
-    def self.compile_template(path, name, mod)
-      template = ::Erubis::Eruby.new(File.read(path))
-      template.def_method(mod, name, path) 
+    def self.compile_template(io, name, mod)
+      template = ::Erubis::BlockAwareEruby.new(io.read)
+
+      _old_verbose, $VERBOSE = $VERBOSE, nil
+      template.def_method(mod, name, File.expand_path(io.path))
+      $VERBOSE = _old_verbose
+      
       name
     end
 
     module Mixin
       
-      # Provides direct acccess to the buffer for this view context
-      #
-      # ==== Parameters
-      # the_binding<Binding>:: The binding to pass to the buffer.
-      #
-      # ==== Returns
-      # DOC
-      def _erb_buffer( the_binding )
-        @_buffer = eval( "_buf", the_binding, __FILE__, __LINE__)
-      end
-
       # ==== Parameters
       # *args:: Arguments to pass to the block.
       # &block:: The template block to call.
@@ -158,30 +183,16 @@ module Merb::Template
       #     <p>Some Foo content!</p> 
       #   <% end %>
       def capture_erb(*args, &block)
-        # get the buffer from the block's binding
-        buffer = _erb_buffer( block.binding ) rescue nil
-
-        # If there is no buffer, just call the block and get the contents
-        if buffer.nil?
-          block.call(*args)
-        # If there is a buffer, execute the block, then extract its contents
-        else
-          pos = buffer.length
-          block.call(*args)
-
-          # extract the block
-          data = buffer[pos..-1]
-
-          # replace it in the original with empty string
-          buffer[pos..-1] = ''
-
-          data
-        end
+        _old_buf, @_erb_buf = @_erb_buf, ""
+        block.call(*args)
+        ret = @_erb_buf
+        @_erb_buf = _old_buf
+        ret
       end
 
       # DOC
       def concat_erb(string, binding)
-        _erb_buffer(binding) << string
+        @_erb_buf << string
       end
             
     end
@@ -192,14 +203,52 @@ module Merb::Template
 end
 
 module Erubis
-  module RubyEvaluator
+  module BlockAwareEnhancer
+    def add_preamble(src)
+      src << "_old_buf, @_erb_buf = @_erb_buf, ''; "
+      src << "@_engine = 'erb'; "
+    end
 
-    # DOC
-    def def_method(object, method_name, filename=nil)
-      m = object.is_a?(Module) ? :module_eval : :instance_eval
-      setup = "@_engine = 'erb'"
-      object.__send__(m, "def #{method_name}(locals={}); #{setup}; #{@src}; end", filename || @filename || '(erubis)')
+    def add_postamble(src)
+      src << "\n" unless src[-1] == ?\n      
+      src << "_ret = @_erb_buf; @_erb_buf = _old_buf; _ret.to_s;\n"
     end
-   
+
+    def add_text(src, text)
+      src << " @_erb_buf.concat('" << escape_text(text) << "'); "
+    end
+
+    def add_expr_escaped(src, code)
+      src << ' @_erb_buf.concat(' << escaped_expr(code) << ');'
+    end
+    
+    def add_stmt2(src, code, tailch)
+      src << code
+      src << " ).to_s; " if tailch == "="
+      src << ';' unless code[-1] == ?\n
+    end
+    
+    def add_expr_literal(src, code)
+      if code =~ /(do|\{)(\s*\|[^|]*\|)?\s*\Z/
+        src << ' @_erb_buf.concat( ' << code << "; "
+      else
+        src << ' @_erb_buf.concat((' << code << ').to_s);'
+      end
+    end
+  end
+
+  class BlockAwareEruby < Eruby
+    include BlockAwareEnhancer
   end
-end
+  
+  # module RubyEvaluator
+  # 
+  #   # DOC
+  #   def def_method(object, method_name, filename=nil)
+  #     m = object.is_a?(Module) ? :module_eval : :instance_eval
+  #     setup = "@_engine = 'erb'"
+  #     object.__send__(m, "def #{method_name}(locals={}); #{setup}; #{@src}; end", filename || @filename || '(erubis)')
+  #   end
+  #  
+  # end
+end