actionpack 2.0.5 → 2.1.0

data/lib/action_view/template_error.rb

@@ -6,10 +6,10 @@ module ActionView
 
     attr_reader :original_exception
 
-    def initialize(base_path, file_path, assigns, source, original_exception)
-      @base_path, @assigns, @source, @original_exception =
-        base_path, assigns.dup, source, original_exception
-      @file_path = file_path
+    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
       @backtrace = compute_backtrace
     end
 
@@ -41,8 +41,9 @@ module ActionView
 
       indent = ' ' * indentation
       line_counter = start_on_line
-
-      source_code[start_on_line..end_on_line].sum do |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}"
       end
@@ -73,7 +74,7 @@ module ActionView
         "#{source_extract}\n    #{clean_backtrace.join("\n    ")}\n\n"
     end
 
-    # don't do anything nontrivial here. Any raised exception from here becomes fatal
+    # don't do anything nontrivial here. Any raised exception from here becomes fatal 
     # (and can't be rescued).
     def backtrace
       @backtrace

data/lib/action_view/template_finder.rb

@@ -0,0 +1,177 @@
+module ActionView #:nodoc:
+  class TemplateFinder #:nodoc:
+
+    class InvalidViewPath < StandardError #:nodoc:
+      attr_reader :unprocessed_path
+      def initialize(path)
+        @unprocessed_path = path
+        super("Unprocessed view path found: #{@unprocessed_path.inspect}.  Set your view paths with #append_view_path, #prepend_view_path, or #view_paths=.")
+      end
+    end
+
+    cattr_reader :processed_view_paths
+    @@processed_view_paths = Hash.new {|hash, key| hash[key] = []}
+
+    cattr_reader :file_extension_cache
+    @@file_extension_cache = Hash.new {|hash, key|
+      hash[key] = Hash.new {|hash, key| hash[key] = []}
+    }
+
+    class << self #:nodoc:
+
+      # This method is not thread safe. Mutex should be used whenever this is accessed from an instance method
+      def process_view_paths(*view_paths)
+        view_paths.flatten.compact.each do |dir|
+          next if @@processed_view_paths.has_key?(dir)
+          @@processed_view_paths[dir] = []
+          
+          # 
+          # Dir.glob("#{dir}/**/*/**") reads all the directories in view path and templates inside those directories
+          # Dir.glob("#{dir}/**") reads templates residing at top level of view path
+          # 
+          (Dir.glob("#{dir}/**/*/**") | Dir.glob("#{dir}/**")).each do |file|
+            unless File.directory?(file)
+              @@processed_view_paths[dir] << file.split(dir).last.sub(/^\//, '')
+
+              # Build extension cache
+              extension = file.split(".").last
+              if template_handler_extensions.include?(extension)
+                key = file.split(dir).last.sub(/^\//, '').sub(/\.(\w+)$/, '')
+                @@file_extension_cache[dir][key] << extension
+              end
+            end
+          end
+        end
+      end
+
+      def update_extension_cache_for(extension)
+        @@processed_view_paths.keys.each do |dir|
+          Dir.glob("#{dir}/**/*.#{extension}").each do |file|
+            key = file.split(dir).last.sub(/^\//, '').sub(/\.(\w+)$/, '')
+            @@file_extension_cache[dir][key] << extension
+          end
+        end
+      end
+
+      def template_handler_extensions
+        ActionView::Template.template_handler_extensions
+      end
+
+      def reload!
+        view_paths = @@processed_view_paths.keys
+
+        @@processed_view_paths = Hash.new {|hash, key| hash[key] = []}
+        @@file_extension_cache = Hash.new {|hash, key|
+          hash[key] = Hash.new {|hash, key| hash[key] = []}
+        }
+
+        process_view_paths(view_paths)
+      end
+    end
+
+    attr_accessor :view_paths
+
+    def initialize(*args)
+      @template = args.shift
+
+      @view_paths = args.flatten
+      @view_paths = @view_paths.respond_to?(:find) ? @view_paths.dup : [*@view_paths].compact
+      check_view_paths(@view_paths)
+    end
+
+    def prepend_view_path(path)
+      @view_paths.unshift(*path)
+
+      self.class.process_view_paths(path)
+    end
+
+    def append_view_path(path)
+      @view_paths.push(*path)
+
+      self.class.process_view_paths(path)
+    end
+
+    def view_paths=(path)
+      @view_paths = path
+      self.class.process_view_paths(path)
+    end
+
+    def pick_template(template_path, extension)
+      file_name = "#{template_path}.#{extension}"
+      base_path = find_base_path_for(file_name)
+      base_path.blank? ? false : "#{base_path}/#{file_name}"
+    end
+    alias_method :template_exists?, :pick_template
+
+    def file_exists?(template_path)
+      # Clear the forward slash in the beginning if exists
+      template_path = template_path.sub(/^\//, '')
+
+      template_file_name, template_file_extension = path_and_extension(template_path)
+
+      if template_file_extension
+        template_exists?(template_file_name, template_file_extension)
+      else
+        template_exists?(template_file_name, pick_template_extension(template_path))
+      end
+    end
+
+    def find_base_path_for(template_file_name)
+      @view_paths.find { |path| @@processed_view_paths[path].include?(template_file_name) }
+    end
+
+    # Returns the view path that the full path resides in.
+    def extract_base_path_from(full_path)
+      @view_paths.find { |p| full_path[0..p.size - 1] == p }
+    end
+
+    # Gets the extension for an existing template with the given template_path.
+    # Returns the format with the extension if that template exists.
+    #
+    #   pick_template_extension('users/show')
+    #   # => 'html.erb'
+    #
+    #   pick_template_extension('users/legacy')
+    #   # => "rhtml"
+    #
+    def pick_template_extension(template_path)
+      if extension = find_template_extension_from_handler(template_path, @template.template_format) || find_template_extension_from_first_render
+        extension
+      elsif @template.template_format == :js && extension = find_template_extension_from_handler(template_path, :html)
+        @template.template_format = :html
+        extension
+      end
+    end
+
+    def find_template_extension_from_handler(template_path, template_format = @template.template_format)
+      formatted_template_path = "#{template_path}.#{template_format}"
+
+      view_paths.each do |path|
+        if (extensions = @@file_extension_cache[path][formatted_template_path]).any?
+          return "#{template_format}.#{extensions.first}"
+        elsif (extensions = @@file_extension_cache[path][template_path]).any?
+          return extensions.first.to_s
+        end
+      end
+      nil
+    end
+
+    # Splits the path and extension from the given template_path and returns as an array.
+    def path_and_extension(template_path)
+      template_path_without_extension = template_path.sub(/\.(\w+)$/, '')
+      [ template_path_without_extension, $1 ]
+    end
+
+    # Determine the template extension from the <tt>@first_render</tt> filename
+    def find_template_extension_from_first_render
+      File.basename(@template.first_render.to_s)[/^[^.]+\.(.+)$/, 1]
+    end
+
+    private
+      def check_view_paths(view_paths)
+        view_paths.each do |path|
+          raise InvalidViewPath.new(path) unless @@processed_view_paths.has_key?(path)
+        end
+      end
+  end
+end

data/lib/action_view/template_handler.rb

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

data/lib/action_view/template_handlers/builder.rb

@@ -3,6 +3,8 @@ require 'builder'
 module ActionView
   module TemplateHandlers
     class Builder < TemplateHandler
+      include Compilable
+
       def self.line_offset
         2
       end
@@ -10,10 +12,16 @@ module ActionView
       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 +
+        "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
+      end
     end
   end
 end

data/lib/action_view/template_handlers/compilable.rb

@@ -0,0 +1,128 @@
+module ActionView
+  module TemplateHandlers
+    module Compilable
+
+      def self.included(base)
+        base.extend ClassMethod
+
+        # Map method names to their compile time
+        base.cattr_accessor :compile_time
+        base.compile_time = {}
+
+        # Map method names to the names passed in local assigns so far
+        base.cattr_accessor :template_args
+        base.template_args = {}
+
+        # Count the number of inline templates
+        base.cattr_accessor :inline_template_count
+        base.inline_template_count = 0
+      end
+
+      module ClassMethod
+        # If a handler is mixin this module, set compilable to true
+        def compilable?
+          true
+        end
+      end
+      
+      def render(template)
+        @view.send :execute, template
+      end
+
+      # Compile and evaluate the template's code
+      def compile_template(template)
+        return unless compile_template?(template)
+
+        render_symbol = assign_method_name(template)
+        render_source = create_template_source(template, render_symbol)
+        line_offset   = self.template_args[render_symbol].size + self.line_offset
+
+        begin
+          file_name = template.filename || 'compiled-template'
+          ActionView::Base::CompiledTemplates.module_eval(render_source, file_name, -line_offset)
+        rescue Exception => e  # errors from template code
+          if @view.logger
+            @view.logger.debug "ERROR: compiling #{render_symbol} RAISED #{e}"
+            @view.logger.debug "Function body: #{render_source}"
+            @view.logger.debug "Backtrace: #{e.backtrace.join("\n")}"
+          end
+
+          raise ActionView::TemplateError.new(template, @view.assigns, e)
+        end
+
+        self.compile_time[render_symbol] = Time.now
+        # logger.debug "Compiled template #{file_name || template}\n  ==> #{render_symbol}" if logger
+      end
+
+      private
+
+      # Method to check whether template compilation is necessary.
+      # The template will be compiled if the inline template or file has not been compiled yet,
+      # if local_assigns has a new key, which isn't supported by the compiled code yet,
+      # or if the file has changed on disk and checking file mods hasn't been disabled.
+      def compile_template?(template)
+        method_key    = template.method_key
+        render_symbol = @view.method_names[method_key]
+
+        compile_time = self.compile_time[render_symbol]
+        if compile_time && supports_local_assigns?(render_symbol, template.locals)
+          if template.filename && !@view.cache_template_loading
+            template_changed_since?(template.filename, compile_time)
+          end
+        else
+          true
+        end
+      end
+
+      def assign_method_name(template)
+        @view.method_names[template.method_key] ||= compiled_method_name(template)
+      end
+
+      def compiled_method_name(template)
+        ['_run', self.class.to_s.demodulize.underscore, compiled_method_name_file_path_segment(template.filename)].compact.join('_').to_sym
+      end
+
+      def compiled_method_name_file_path_segment(file_name)
+        if file_name
+          s = File.expand_path(file_name)
+          s.sub!(/^#{Regexp.escape(File.expand_path(RAILS_ROOT))}/, '') if defined?(RAILS_ROOT)
+          s.gsub!(/([^a-zA-Z0-9_])/) { $1.ord }
+          s
+        else
+          (self.inline_template_count += 1).to_s
+        end
+      end
+
+      # Method to create the source code for a given template.
+      def create_template_source(template, render_symbol)
+        body = compile(template)
+
+        self.template_args[render_symbol] ||= {}
+        locals_keys = self.template_args[render_symbol].keys | template.locals.keys
+        self.template_args[render_symbol] = locals_keys.inject({}) { |h, k| h[k] = true; h }
+
+        locals_code = ""
+        locals_keys.each do |key|
+          locals_code << "#{key} = local_assigns[:#{key}]\n"
+        end
+
+        "def #{render_symbol}(local_assigns)\n#{locals_code}#{body}\nend"
+      end
+
+      # Return true if the given template was compiled for a superset of the keys in local_assigns
+      def supports_local_assigns?(render_symbol, local_assigns)
+        local_assigns.empty? ||
+          ((args = self.template_args[render_symbol]) && local_assigns.all? { |k,_| args.has_key?(k) })
+      end
+
+      # Method to handle checking a whether a template has changed since last compile; isolated so that templates
+      # not stored on the file system can hook and extend appropriately.
+      def template_changed_since?(file_name, compile_time)
+        lstat = File.lstat(file_name)
+        compile_time < lstat.mtime ||
+          (lstat.symlink? && compile_time < File.stat(file_name).mtime)
+      end
+
+    end
+  end
+end

data/lib/action_view/template_handlers/erb.rb

@@ -2,19 +2,54 @@ require 'erb'
 
 class ERB
   module Util
-    HTML_ESCAPE = { '&' => '&amp;', '"' => '&quot;', '>' => '&gt;', '<' => '&lt;' }
+    HTML_ESCAPE = { '&' => '&amp;',  '>' => '&gt;',   '<' => '&lt;', '"' => '&quot;' }
+    JSON_ESCAPE = { '&' => '\u0026', '>' => '\u003E', '<' => '\u003C' }
 
+    # A utility method for escaping HTML tag characters.
+    # This method is also aliased as <tt>h</tt>.
+    #
+    # In your ERb templates, use this method to escape any unsafe content. For example:
+    #   <%=h @person.name %>
+    #
+    # ==== Example:
+    #   puts html_escape("is a > 0 & a < 10?")
+    #   # => is a &gt; 0 &amp; a &lt; 10?
     def html_escape(s)
       s.to_s.gsub(/[&"><]/) { |special| HTML_ESCAPE[special] }
     end
+
+    # A utility method for escaping HTML entities in JSON strings.
+    # This method is also aliased as <tt>j</tt>.
+    #
+    # In your ERb templates, use this method to escape any HTML entities:
+    #   <%=j @person.to_json %>
+    #
+    # ==== Example:
+    #   puts json_escape("is a > 0 & a < 10?")
+    #   # => is a \u003E 0 \u0026 a \u003C 10?
+    def json_escape(s)
+      s.to_s.gsub(/[&"><]/) { |special| JSON_ESCAPE[special] }
+    end
+
+    alias j json_escape
+    module_function :j
+    module_function :json_escape
   end
 end
 
 module ActionView
   module TemplateHandlers
     class ERB < TemplateHandler
+      include Compilable
+
       def compile(template)
-        ::ERB.new(template, nil, @view.erb_trim_mode).src
+        ::ERB.new(template.source, nil, @view.erb_trim_mode).src
+      end
+
+      def cache_fragment(block, name = {}, options = nil) #:nodoc:
+        @view.fragment_for(block, name, options) do
+          eval(ActionView::Base.erb_variable, block.binding)
+        end
       end
     end
   end