actionpack 2.1.2 → 2.2.2

data/lib/action_view/template.rb

@@ -1,127 +1,116 @@
+require 'action_controller/mime_type'
+
 module ActionView #:nodoc:
-  class Template #:nodoc:
-
-    attr_accessor :locals
-    attr_reader :handler, :path, :extension, :filename, :path_without_extension, :method
-
-    def initialize(view, path, use_full_path, locals = {})
-      @view = view
-      @finder = @view.finder
-
-      # Clear the forward slash at the beginning if exists
-      @path = use_full_path ? path.sub(/^\//, '') : path
-      @view.first_render ||= @path
-      @source = nil # Don't read the source until we know that it is required
-      set_extension_and_file_name(use_full_path)
-      
-      @locals = locals || {}
-      @handler = self.class.handler_class_for_extension(@extension).new(@view)
+  class Template
+    extend TemplateHandlers
+    extend ActiveSupport::Memoizable
+    include Renderable
+
+    attr_accessor :filename, :load_path, :base_path, :name, :format, :extension
+    delegate :to_s, :to => :path
+
+    def initialize(template_path, load_paths = [])
+      template_path = template_path.dup
+      @base_path, @name, @format, @extension = split(template_path)
+      @base_path.to_s.gsub!(/\/$/, '') # Push to split method
+      @load_path, @filename = find_full_path(template_path, load_paths)
+
+      # Extend with partial super powers
+      extend RenderablePartial if @name =~ /^_/
     end
 
-    def render_template
-      render
-    rescue Exception => e
-      raise e unless filename
-      if TemplateError === e
-        e.sub_template_of(filename)
-        raise e
-      else
-        raise TemplateError.new(self, @view.assigns, e)
-      end
-    end
-    
-    def render
-      prepare!
-      @handler.render(self)
+    def format_and_extension
+      (extensions = [format, extension].compact.join(".")).blank? ? nil : extensions
     end
+    memoize :format_and_extension
 
-    def source
-      @source ||= File.read(self.filename)
+    def multipart?
+      format && format.include?('.')
     end
 
-    def method_key
-      @filename
+    def content_type
+      format.gsub('.', '/')
     end
 
-    def base_path_for_exception
-      @finder.find_base_path_for("#{@path_without_extension}.#{@extension}") || @finder.view_paths.first
-    end
-    
-    def prepare!
-      @view.send :evaluate_assigns
-      @view.current_render_extension = @extension
-      
-      if @handler.compilable?
-        @handler.compile_template(self) # compile the given template, if necessary
-        @method = @view.method_names[method_key] # Set the method name for this template and run it
-      end
+    def mime_type
+      Mime::Type.lookup_by_extension(format) if format
     end
+    memoize :mime_type
 
-    private
-
-    def set_extension_and_file_name(use_full_path)
-      @path_without_extension, @extension = @finder.path_and_extension(@path)
-      if use_full_path
-        if @extension
-          @filename = @finder.pick_template(@path_without_extension, @extension)
-        else
-          @extension = @finder.pick_template_extension(@path).to_s
-          raise_missing_template_exception unless @extension
-          
-          @filename = @finder.pick_template(@path, @extension)
-          @extension = @extension.gsub(/^.+\./, '') # strip off any formats
-        end
-      else
-        @filename = @path
-      end
+    def path
+      [base_path, [name, format, extension].compact.join('.')].compact.join('/')
+    end
+    memoize :path
 
-      raise_missing_template_exception if @filename.blank?
+    def path_without_extension
+      [base_path, [name, format].compact.join('.')].compact.join('/')
     end
-    
-    def raise_missing_template_exception
-      full_template_path = @path.include?('.') ? @path : "#{@path}.#{@view.template_format}.erb"
-      display_paths = @finder.view_paths.join(':')
-      template_type = (@path =~ /layouts/i) ? 'layout' : 'template'
-      raise(MissingTemplate, "Missing #{template_type} #{full_template_path} in view path #{display_paths}")
+    memoize :path_without_extension
+
+    def path_without_format_and_extension
+      [base_path, name].compact.join('/')
     end
+    memoize :path_without_format_and_extension
 
-    # Template Handlers
-    
-    @@template_handlers = HashWithIndifferentAccess.new
-    @@default_template_handlers = nil
-    
-    # Register a class that knows how to handle template files with the given
-    # extension. This can be used to implement new template types.
-    # The constructor for the class must take the ActiveView::Base instance
-    # as a parameter, and the class must implement a +render+ method that
-    # takes the contents of the template to render as well as the Hash of
-    # local assigns available to the template. The +render+ method ought to
-    # return the rendered template as a string.
-    def self.register_template_handler(extension, klass)
-      @@template_handlers[extension.to_sym] = klass
-      TemplateFinder.update_extension_cache_for(extension.to_s)
+    def relative_path
+      path = File.expand_path(filename)
+      path.sub!(/^#{Regexp.escape(File.expand_path(RAILS_ROOT))}\//, '') if defined?(RAILS_ROOT)
+      path
     end
+    memoize :relative_path
 
-    def self.template_handler_extensions
-      @@template_handlers.keys.map(&:to_s).sort
+    def source
+      File.read(filename)
     end
+    memoize :source
 
-    def self.register_default_template_handler(extension, klass)
-      register_template_handler(extension, klass)
-      @@default_template_handlers = klass
+    def method_segment
+      relative_path.to_s.gsub(/([^a-zA-Z0-9_])/) { $1.ord }
     end
+    memoize :method_segment
 
-    def self.handler_class_for_extension(extension)
-      (extension && @@template_handlers[extension.to_sym]) || @@default_template_handlers
+    def render_template(view, local_assigns = {})
+      render(view, local_assigns)
+    rescue Exception => e
+      raise e unless filename
+      if TemplateError === e
+        e.sub_template_of(self)
+        raise e
+      else
+        raise TemplateError.new(self, view.assigns, e)
+      end
     end
 
-    register_default_template_handler :erb, TemplateHandlers::ERB
-    register_template_handler :rjs, TemplateHandlers::RJS
-    register_template_handler :builder, TemplateHandlers::Builder
+    private
+      def valid_extension?(extension)
+        Template.template_handler_extensions.include?(extension)
+      end
+
+      def find_full_path(path, load_paths)
+        load_paths = Array(load_paths) + [nil]
+        load_paths.each do |load_path|
+          file = [load_path, path].compact.join('/')
+          return load_path, file if File.file?(file)
+        end
+        raise MissingTemplate.new(load_paths, path)
+      end
 
-    # TODO: Depreciate old template extensions
-    register_template_handler :rhtml, TemplateHandlers::ERB
-    register_template_handler :rxml, TemplateHandlers::Builder
-    
+      # Returns file split into an array
+      #   [base_path, name, format, extension]
+      def split(file)
+        if m = file.match(/^(.*\/)?([^\.]+)\.?(\w+)?\.?(\w+)?\.?(\w+)?$/)
+          if m[5] # Multipart formats
+            [m[1], m[2], "#{m[3]}.#{m[4]}", m[5]]
+          elsif m[4] # Single format
+            [m[1], m[2], m[3], m[4]]
+          else
+            if valid_extension?(m[3]) # No format
+              [m[1], m[2], nil, m[3]]
+            else # No extension
+              [m[1], m[2], m[3], nil]
+            end
+          end
+        end
+      end
   end
 end

data/lib/action_view/template_error.rb

@@ -7,12 +7,14 @@ module ActionView
     attr_reader :original_exception
 
     def initialize(template, assigns, original_exception)
-      @base_path = template.base_path_for_exception
-      @assigns, @source, @original_exception = assigns.dup, template.source, original_exception
-      @file_path = template.filename
+      @template, @assigns, @original_exception = template, assigns.dup, original_exception
       @backtrace = compute_backtrace
     end
 
+    def file_name
+      @template.relative_path
+    end
+
     def message
       ActiveSupport::Deprecation.silence { original_exception.message }
     end
@@ -24,7 +26,7 @@ module ActionView
     def sub_template_message
       if @sub_templates
         "Trace of template inclusion: " +
-        @sub_templates.collect { |template| strip_base_path(template) }.join(", ")
+        @sub_templates.collect { |template| template.relative_path }.join(", ")
       else
         ""
       end
@@ -34,18 +36,18 @@ module ActionView
       return unless num = line_number
       num = num.to_i
 
-      source_code = IO.readlines(@file_path)
+      source_code = @template.source.split("\n")
 
       start_on_line = [ num - SOURCE_CODE_RADIUS - 1, 0 ].max
       end_on_line   = [ num + SOURCE_CODE_RADIUS - 1, source_code.length].min
 
       indent = ' ' * indentation
       line_counter = start_on_line
-      return unless source_code = source_code[start_on_line..end_on_line] 
-      
+      return unless source_code = source_code[start_on_line..end_on_line]
+
       source_code.sum do |line|
         line_counter += 1
-        "#{indent}#{line_counter}: #{line}"
+        "#{indent}#{line_counter}: #{line}\n"
       end
     end
 
@@ -63,12 +65,6 @@ module ActionView
         end
     end
 
-    def file_name
-      stripped = strip_base_path(@file_path)
-      stripped.slice!(0,1) if stripped[0] == ?/
-      stripped
-    end
-
     def to_s
       "\n\n#{self.class} (#{message}) #{source_location}:\n" +
         "#{source_extract}\n    #{clean_backtrace.join("\n    ")}\n\n"
@@ -88,12 +84,6 @@ module ActionView
         ]
       end
 
-      def strip_base_path(path)
-        stripped_path = File.expand_path(path).gsub(@base_path, "")
-        stripped_path.gsub!(/^#{Regexp.escape File.expand_path(RAILS_ROOT)}/, '') if defined?(RAILS_ROOT)
-        stripped_path
-      end
-
       def source_location
         if line_number
           "on line ##{line_number} of "
@@ -105,6 +95,6 @@ module ActionView
 end
 
 if defined?(Exception::TraceSubstitutions)
-  Exception::TraceSubstitutions << [/:in\s+`_run_(html|xml).*'\s*$/, '']
+  Exception::TraceSubstitutions << [/:in\s+`_run_.*'\s*$/, '']
   Exception::TraceSubstitutions << [%r{^\s*#{Regexp.escape RAILS_ROOT}/}, ''] if defined?(RAILS_ROOT)
 end

data/lib/action_view/template_handler.rb

@@ -1,34 +1,14 @@
-module ActionView
-  class TemplateHandler
+# Legacy TemplateHandler stub
 
-    def self.line_offset
-      0
-    end
-
-    def self.compilable?
-      false
-    end
-
-    def initialize(view)
-      @view = view
-    end
-
-    def render(template)
-    end
-
-    def compile(template)
-    end
-
-    def compilable?
-      self.class.compilable?
-    end
-
-    def line_offset
-      self.class.line_offset
+module ActionView
+  module TemplateHandlers
+    module Compilable
     end
+  end
 
-    # Called by CacheHelper#cache
-    def cache_fragment(block, name = {}, options = nil)
+  class TemplateHandler
+    def self.call(template)
+      new.compile(template)
     end
   end
 end

data/lib/action_view/template_handlers.rb

@@ -0,0 +1,45 @@
+require 'action_view/template_handler'
+require 'action_view/template_handlers/builder'
+require 'action_view/template_handlers/erb'
+require 'action_view/template_handlers/rjs'
+
+module ActionView #:nodoc:
+  module TemplateHandlers #:nodoc:
+    def self.extended(base)
+      base.register_default_template_handler :erb, TemplateHandlers::ERB
+      base.register_template_handler :rjs, TemplateHandlers::RJS
+      base.register_template_handler :builder, TemplateHandlers::Builder
+
+      # TODO: Depreciate old template extensions
+      base.register_template_handler :rhtml, TemplateHandlers::ERB
+      base.register_template_handler :rxml, TemplateHandlers::Builder
+    end
+
+    @@template_handlers = {}
+    @@default_template_handlers = nil
+
+    # Register a class that knows how to handle template files with the given
+    # extension. This can be used to implement new template types.
+    # The constructor for the class must take the ActiveView::Base instance
+    # as a parameter, and the class must implement a +render+ method that
+    # takes the contents of the template to render as well as the Hash of
+    # local assigns available to the template. The +render+ method ought to
+    # return the rendered template as a string.
+    def register_template_handler(extension, klass)
+      @@template_handlers[extension.to_sym] = klass
+    end
+
+    def template_handler_extensions
+      @@template_handlers.keys.map(&:to_s).sort
+    end
+
+    def register_default_template_handler(extension, klass)
+      register_template_handler(extension, klass)
+      @@default_template_handlers = klass
+    end
+
+    def handler_class_for_extension(extension)
+      (extension && @@template_handlers[extension.to_sym]) || @@default_template_handlers
+    end
+  end
+end

data/lib/action_view/template_handlers/builder.rb

@@ -5,22 +5,12 @@ module ActionView
     class Builder < TemplateHandler
       include Compilable
 
-      def self.line_offset
-        2
-      end
-
       def compile(template)
-        content_type_handler = (@view.send!(:controller).respond_to?(:response) ? "controller.response" : "controller")
-        "#{content_type_handler}.content_type ||= Mime::XML\n" +
-        "xml = ::Builder::XmlMarkup.new(:indent => 2)\n" +
-        template.source +
-        "\nxml.target!\n"
-      end
-
-      def cache_fragment(block, name = {}, options = nil)
-        @view.fragment_for(block, name, options) do
-          eval('xml.target!', block.binding)
-        end
+        "_set_controller_content_type(Mime::XML);" +
+          "xml = ::Builder::XmlMarkup.new(:indent => 2);" +
+          "self.output_buffer = xml.target!;" +
+          template.source +
+          ";xml.target!;"
       end
     end
   end

data/lib/action_view/template_handlers/erb.rb

@@ -42,14 +42,17 @@ module ActionView
     class ERB < TemplateHandler
       include Compilable
 
+      # Specify trim mode for the ERB compiler. Defaults to '-'.
+      # See ERb documentation for suitable values.
+      cattr_accessor :erb_trim_mode
+      self.erb_trim_mode = '-'
+
       def compile(template)
-        ::ERB.new(template.source, nil, @view.erb_trim_mode).src
-      end
+        src = ::ERB.new("<% __in_erb_template=true %>#{template.source}", nil, erb_trim_mode, '@output_buffer').src
 
-      def cache_fragment(block, name = {}, options = nil) #:nodoc:
-        @view.fragment_for(block, name, options) do
-          eval(ActionView::Base.erb_variable, block.binding)
-        end
+        # Ruby 1.9 prepends an encoding to the source. However this is
+        # useless because you can only set an encoding on the first line
+        RUBY_VERSION >= '1.9' ? src.sub(/\A#coding:.*\n/, '') : src
       end
     end
   end

data/lib/action_view/template_handlers/rjs.rb

@@ -3,24 +3,9 @@ module ActionView
     class RJS < TemplateHandler
       include Compilable
 
-      def self.line_offset
-        2
-      end
-
       def compile(template)
-        "controller.response.content_type ||= Mime::JS\n" +
-        "update_page do |page|\n#{template.source}\nend"
-      end
-
-      def cache_fragment(block, name = {}, options = nil) #:nodoc:
-        @view.fragment_for(block, name, options) do
-          begin
-            debug_mode, ActionView::Base.debug_rjs = ActionView::Base.debug_rjs, false
-            eval('page.to_s', block.binding)
-          ensure
-            ActionView::Base.debug_rjs = debug_mode
-          end
-        end
+        "controller.response.content_type ||= Mime::JS;" +
+          "update_page do |page|;#{template.source}\nend"
       end
     end
   end