actionpack 2.3.18 → 3.0.0.beta

data/lib/action_view/template/error.rb

@@ -0,0 +1,105 @@
+require "active_support/core_ext/enumerable"
+
+module ActionView
+  class Template
+    # The Template::Error exception is raised when the compilation of the template fails. This exception then gathers a
+    # bunch of intimate details and uses it to report a very precise exception message.
+    class Error < ActionViewError #:nodoc:
+      SOURCE_CODE_RADIUS = 3
+
+      attr_reader :original_exception
+
+      def initialize(template, assigns, original_exception)
+        @template, @assigns, @original_exception = template, assigns.dup, original_exception
+        @backtrace = compute_backtrace
+      end
+
+      def file_name
+        @template.identifier
+      end
+
+      def message
+        ActiveSupport::Deprecation.silence { original_exception.message }
+      end
+
+      def clean_backtrace
+        if defined?(Rails) && Rails.respond_to?(:backtrace_cleaner)
+          Rails.backtrace_cleaner.clean(original_exception.backtrace)
+        else
+          original_exception.backtrace
+        end
+      end
+
+      def sub_template_message
+        if @sub_templates
+          "Trace of template inclusion: " +
+          @sub_templates.collect { |template| template.inspect }.join(", ")
+        else
+          ""
+        end
+      end
+
+      def source_extract(indentation = 0)
+        return unless num = line_number
+        num = num.to_i
+
+        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]
+
+        source_code.sum do |line|
+          line_counter += 1
+          "#{indent}#{line_counter}: #{line}\n"
+        end
+      end
+
+      def sub_template_of(template_path)
+        @sub_templates ||= []
+        @sub_templates << template_path
+      end
+
+      def line_number
+        @line_number ||=
+          if file_name
+            regexp = /#{Regexp.escape File.basename(file_name)}:(\d+)/
+
+            $1 if message =~ regexp or clean_backtrace.find { |line| line =~ regexp }
+          end
+      end
+
+      def to_s
+        "\n#{self.class} (#{message}) #{source_location}:\n" + 
+        "#{source_extract}\n    #{clean_backtrace.join("\n    ")}\n\n"
+      end
+
+      # don't do anything nontrivial here. Any raised exception from here becomes fatal 
+      # (and can't be rescued).
+      def backtrace
+        @backtrace
+      end
+
+      private
+        def compute_backtrace
+          [
+            "#{source_location.capitalize}\n\n#{source_extract(4)}\n    " +
+            clean_backtrace.join("\n    ")
+          ]
+        end
+
+        def source_location
+          if line_number
+            "on line ##{line_number} of "
+          else
+            'in '
+          end + file_name
+        end
+    end
+  end
+
+  TemplateError = Template::Error
+end

data/lib/action_view/template/handler.rb

@@ -0,0 +1,41 @@
+require "action_dispatch/http/mime_type"
+require 'active_support/core_ext/class/attribute'
+
+# Legacy TemplateHandler stub
+module ActionView
+  class Template
+    module Handlers #:nodoc:
+      module Compilable
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          def call(template)
+            new.compile(template)
+          end
+        end
+
+        def compile(template)
+          raise "Need to implement #{self.class.name}#compile(template)"
+        end
+      end
+    end
+
+    class Template::Handler
+      class_attribute :default_format
+      self.default_format = Mime::HTML
+
+      def self.call(template)
+        raise "Need to implement #{self.class.name}#call(template)"
+      end
+
+      def render(template, local_assigns)
+        raise "Need to implement #{self.class.name}#render(template, local_assigns)"
+      end
+    end
+  end
+  
+  TemplateHandlers = Template::Handlers
+  TemplateHandler = Template::Handler
+end

data/lib/action_view/template/handlers.rb

@@ -0,0 +1,54 @@
+module ActionView #:nodoc:
+  class Template
+    module Handlers #:nodoc:
+      autoload :ERB, 'action_view/template/handlers/erb'
+      autoload :RJS, 'action_view/template/handlers/rjs'
+      autoload :Builder, 'action_view/template/handlers/builder'
+
+      def self.extended(base)
+        base.register_default_template_handler :erb, ERB
+        base.register_template_handler :rjs, RJS
+        base.register_template_handler :builder, Builder
+
+        # TODO: Depreciate old template extensions
+        base.register_template_handler :rhtml, ERB
+        base.register_template_handler :rxml, Builder
+      end
+
+      @@template_handlers = {}
+      @@default_template_handlers = nil
+    
+      def self.extensions
+        @@template_handlers.keys
+      end
+
+      # 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 {|key| key.to_s }.sort
+      end
+
+      def registered_template_handler(extension)
+        extension && @@template_handlers[extension.to_sym]
+      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 && registered_template_handler(extension.to_sym)) || @@default_template_handlers
+      end
+    end
+  end
+end

data/lib/action_view/{template_handlers → template/handlers}/builder.rb

@@ -1,13 +1,13 @@
-require 'builder'
-
 module ActionView
-  module TemplateHandlers
-    class Builder < TemplateHandler
+  module Template::Handlers
+    class Builder < Template::Handler
       include Compilable
 
+      self.default_format = Mime::XML
+
       def compile(template)
-        "_set_controller_content_type(Mime::XML);" +
-          "xml = ::Builder::XmlMarkup.new(:indent => 2);" +
+        require 'builder'
+        "xml = ::Builder::XmlMarkup.new(:indent => 2);" +
           "self.output_buffer = xml.target!;" +
           template.source +
           ";xml.target!;"

data/lib/action_view/template/handlers/erb.rb

@@ -0,0 +1,58 @@
+require 'active_support/core_ext/class/attribute_accessors'
+require 'active_support/core_ext/string/output_safety'
+require 'erubis'
+
+module ActionView
+  module Template::Handlers
+    class Erubis < ::Erubis::Eruby
+      def add_preamble(src)
+        src << "@output_buffer = ActiveSupport::SafeBuffer.new;"
+      end
+
+      def add_text(src, text)
+        return if text.empty?
+        src << "@output_buffer.safe_concat('" << escape_text(text) << "');"
+      end
+
+      def add_expr_literal(src, code)
+        if code =~ /\s*raw\s+(.*)/
+          src << "@output_buffer.safe_concat((" << $1 << ").to_s);"
+        else
+          src << '@output_buffer << ((' << code << ').to_s);'
+        end
+      end
+
+      def add_expr_escaped(src, code)
+        src << '@output_buffer << ' << escaped_expr(code) << ';'
+      end
+
+      def add_postamble(src)
+        src << '@output_buffer.to_s'
+      end
+    end
+
+    class ERB < Template::Handler
+      include Compilable
+
+      ##
+      # :singleton-method:
+      # Specify trim mode for the ERB compiler. Defaults to '-'.
+      # See ERb documentation for suitable values.
+      cattr_accessor :erb_trim_mode
+      self.erb_trim_mode = '-'
+
+      self.default_format = Mime::HTML
+      
+      cattr_accessor :erubis_implementation
+      self.erubis_implementation = Erubis
+
+      def compile(template)
+        source = template.source.gsub(/\A(<%(#.*coding[:=]\s*(\S+)\s*)-?%>)\s*\n?/, '')
+        erb = "<% __in_erb_template=true %>#{source}"
+        result = self.class.erubis_implementation.new(erb, :trim=>(self.class.erb_trim_mode == "-")).src
+        result = "#{$2}\n#{result}" if $2
+        result
+      end
+    end
+  end
+end

data/lib/action_view/{template_handlers → template/handlers}/rjs.rb

@@ -1,13 +1,18 @@
 module ActionView
-  module TemplateHandlers
-    class RJS < TemplateHandler
+  module Template::Handlers
+    class RJS < Template::Handler
       include Compilable
 
+      self.default_format = Mime::JS
+
       def compile(template)
-        "@template_format = :html;" +
         "controller.response.content_type ||= Mime::JS;" +
           "update_page do |page|;#{template.source}\nend"
       end
+
+      def default_format
+        Mime::JS
+      end
     end
   end
 end

data/lib/action_view/template/resolver.rb

@@ -0,0 +1,164 @@
+require "pathname"
+require "active_support/core_ext/class"
+require "active_support/core_ext/array/wrap"
+require "action_view/template"
+
+module ActionView
+  # Abstract superclass
+  class Resolver
+
+    class_inheritable_accessor(:registered_details)
+    self.registered_details = {}
+
+    def self.register_detail(name, options = {})
+      registered_details[name] = lambda do |val|
+        val = Array.wrap(val || yield)
+        val |= [nil] unless options[:allow_nil] == false
+        val
+      end
+    end
+
+    register_detail(:locale)  { [I18n.locale] }
+    register_detail(:formats) { Mime::SET.symbols }
+    register_detail(:handlers, :allow_nil => false) do
+      Template::Handlers.extensions
+    end
+
+    def initialize(options = {})
+      @cache  = options[:cache]
+      @cached = {}
+    end
+
+    # Normalizes the arguments and passes it on to find_template
+    def find(*args)
+      find_all(*args).first
+    end
+
+    def find_all(name, details = {}, prefix = nil, partial = nil)
+      details = normalize_details(details)
+      name, prefix = normalize_name(name, prefix)
+
+      cached([name, details, prefix, partial]) do
+        find_templates(name, details, prefix, partial)
+      end
+    end
+
+  private
+
+    # This is what child classes implement. No defaults are needed
+    # because Resolver guarantees that the arguments are present and
+    # normalized.
+    def find_templates(name, details, prefix, partial)
+      raise NotImplementedError
+    end
+
+    def normalize_details(details)
+      details = details.dup
+      # TODO: Refactor this concern out of the resolver
+      details.delete(:formats) if details[:formats] == [:"*/*"]
+      registered_details.each do |k, v|
+        details[k] = v.call(details[k])
+      end
+      details
+    end
+
+    # Support legacy foo.erb names even though we now ignore .erb
+    # as well as incorrectly putting part of the path in the template
+    # name instead of the prefix.
+    def normalize_name(name, prefix)
+      handlers = Template::Handlers.extensions.join('|')
+      name = name.to_s.gsub(/\.(?:#{handlers})$/, '')
+
+      parts = name.split('/')
+      return parts.pop, [prefix, *parts].compact.join("/")
+    end
+
+    def cached(key)
+      return yield unless @cache
+      return @cached[key] if @cached.key?(key)
+      @cached[key] = yield
+    end
+  end
+
+  class PathResolver < Resolver
+
+    EXTENSION_ORDER = [:locale, :formats, :handlers]
+
+    def to_s
+      @path.to_s
+    end
+    alias to_path to_s
+
+    def find_templates(name, details, prefix, partial)
+      path = build_path(name, details, prefix, partial)
+      query(path, EXTENSION_ORDER.map { |ext| details[ext] })
+    end
+
+  private
+
+    def build_path(name, details, prefix, partial)
+      path = ""
+      path << "#{prefix}/" unless prefix.empty?
+      path << (partial ? "_#{name}" : name)
+      path
+    end
+
+    def query(path, exts)
+      query = File.join(@path, path)
+      exts.each do |ext|
+        query << '{' << ext.map {|e| e && ".#{e}" }.join(',') << '}'
+      end
+
+      Dir[query].reject { |p| File.directory?(p) }.map do |p|
+        Template.new(File.read(p), File.expand_path(p), *path_to_details(p))
+      end
+    end
+
+    # # TODO: fix me
+    # # :api: plugin
+    def path_to_details(path)
+      # [:erb, :format => :html, :locale => :en, :partial => true/false]
+      if m = path.match(%r'((^|.*/)(_)?[\w-]+)((?:\.[\w-]+)*)\.(\w+)$')
+        partial = m[3] == '_'
+        details = (m[4]||"").split('.').reject { |e| e.empty? }
+        handler = Template.handler_class_for_extension(m[5])
+
+        format  = Mime[details.last] && details.pop.to_sym
+        locale  = details.last && details.pop.to_sym
+
+        virtual_path = (m[1].gsub("#{@path}/", "") << details.join("."))
+
+        return handler, :format => format, :locale => locale, :partial => partial,
+                        :virtual_path => virtual_path
+      end
+    end
+  end
+
+  class FileSystemResolver < PathResolver
+    def initialize(path, options = {})
+      raise ArgumentError, "path already is a Resolver class" if path.is_a?(Resolver)
+      super(options)
+      @path = Pathname.new(path).expand_path
+    end
+  end
+
+  # TODO: remove hack
+  class FileSystemResolverWithFallback < Resolver
+    def initialize(path, options = {})
+      super(options)
+      @paths = [FileSystemResolver.new(path, options), FileSystemResolver.new("", options), FileSystemResolver.new("/", options)]
+    end
+
+    def find_templates(*args)
+      @paths.each do |p|
+        template = p.find_templates(*args)
+        return template unless template.empty?
+      end
+      []
+    end
+
+    def to_s
+      @paths.first.to_s
+    end
+  end
+end